NumPy Concatenate : Joindre des tableaux avec np.concatenate, vstack et hstack

Name

Soren Atelier

Updated on 10/02/2026

Combiner des tableaux est l'une des operations les plus courantes en calcul numerique. Vous divisez les donnees pour le traitement, puis vous devez les reassembler. Vous chargez des caracteristiques de sources multiples dans une seule matrice. Vous empilez les predictions de plusieurs modeles pour l'assemblage. Utiliser des listes Python pour combiner des tableaux avec des boucles ou + detruit les performances et cree des copies inutilement.

NumPy fournit des fonctions specialisees pour joindre des tableaux qui operent a la vitesse du C et vous donnent un controle precis sur l'axe de concatenation. Ce guide couvre np.concatenate(), np.vstack(), np.hstack(), np.stack() et leurs cas d'utilisation.

np.concatenate() -- La fonction principale

np.concatenate() joint une sequence de tableaux le long d'un axe existant.

Tableaux 1D

import numpy as np
 
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = np.array([7, 8, 9])
 
result = np.concatenate([a, b, c])
print(result)  # [1 2 3 4 5 6 7 8 9]
print(result.shape)  # (9,)

Tableaux 2D le long des lignes (axis=0)

import numpy as np
 
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
 
# Empiler verticalement (ajouter des lignes)
result = np.concatenate([a, b], axis=0)
print(result)
# [[1 2]
#  [3 4]
#  [5 6]
#  [7 8]]
print(result.shape)  # (4, 2)

Tableaux 2D le long des colonnes (axis=1)

import numpy as np
 
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
 
# Empiler horizontalement (ajouter des colonnes)
result = np.concatenate([a, b], axis=1)
print(result)
# [[1 2 5 6]
#  [3 4 7 8]]
print(result.shape)  # (2, 4)

Exigences de forme

Tous les tableaux doivent avoir la meme forme sauf le long de l'axe de concatenation.

import numpy as np
 
a = np.ones((3, 4))    # 3 lignes, 4 colonnes
b = np.zeros((2, 4))   # 2 lignes, 4 colonnes
 
# OK : nombre de lignes different, meme nombre de colonnes, axis=0
result = np.concatenate([a, b], axis=0)
print(result.shape)  # (5, 4)
 
# ERREUR : nombre de colonnes different
c = np.ones((3, 5))
# np.concatenate([a, c], axis=0)  # ValueError: dimensions don't match

np.vstack() -- Empilement vertical

np.vstack() empile les tableaux verticalement (le long de l'axe 0). Equivalent a np.concatenate(arrays, axis=0) mais gere aussi les tableaux 1D en les traitant comme des lignes individuelles.

import numpy as np
 
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
 
# vstack traite les tableaux 1D comme des lignes
result = np.vstack([a, b])
print(result)
# [[1 2 3]
#  [4 5 6]]
print(result.shape)  # (2, 3)
 
# Avec des tableaux 2D
c = np.array([[1, 2], [3, 4]])
d = np.array([[5, 6]])
result = np.vstack([c, d])
print(result)
# [[1 2]
#  [3 4]
#  [5 6]]

np.hstack() -- Empilement horizontal

np.hstack() empile les tableaux horizontalement (le long de l'axe 1 pour 2D, axe 0 pour 1D).

import numpy as np
 
# Tableaux 1D : concatene comme np.concatenate
a = np.array([1, 2, 3])
b = np.array([4, 5])
result = np.hstack([a, b])
print(result)  # [1 2 3 4 5]
 
# Tableaux 2D : ajoute des colonnes
c = np.array([[1], [2], [3]])
d = np.array([[4], [5], [6]])
result = np.hstack([c, d])
print(result)
# [[1 4]
#  [2 5]
#  [3 6]]

np.stack() -- Cree un nouvel axe

Contrairement a concatenate, stack joint les tableaux le long d'un nouvel axe, augmentant le nombre de dimensions de 1.

import numpy as np
 
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
 
# Empiler le long du nouvel axe 0 (par defaut)
result = np.stack([a, b])
print(result)
# [[1 2 3]
#  [4 5 6]]
print(result.shape)  # (2, 3)
 
# Empiler le long du nouvel axe 1
result = np.stack([a, b], axis=1)
print(result)
# [[1 4]
#  [2 5]
#  [3 6]]
print(result.shape)  # (3, 2)

Tous les tableaux d'entree doivent avoir la meme forme pour np.stack().

Comparaison des fonctions

Exemples pratiques

Combiner des caracteristiques pour l'apprentissage automatique

import numpy as np
 
# Tableaux de caracteristiques de differentes sources
ages = np.array([25, 30, 35, 40])
incomes = np.array([50000, 60000, 75000, 90000])
scores = np.array([720, 680, 750, 800])
 
# Empiler en colonnes pour creer la matrice de caracteristiques
X = np.column_stack([ages, incomes, scores])
print(X)
# [[   25 50000   720]
#  [   30 60000   680]
#  [   35 75000   750]
#  [   40 90000   800]]
print(X.shape)  # (4, 3)

Resultats de traitement par lots

import numpy as np
 
# Traiter les donnees par lots, combiner les resultats
results = []
for batch_start in range(0, 100, 25):
    batch = np.random.randn(25, 10)  # 25 echantillons, 10 caracteristiques
    processed = batch * 2 + 1  # Traitement
    results.append(processed)
 
# Combiner tous les lots verticalement
all_results = np.vstack(results)
print(all_results.shape)  # (100, 10)

Traitement d'images -- Combiner les canaux

import numpy as np
 
height, width = 100, 100
 
# Canaux de couleur separes
red = np.random.randint(0, 256, (height, width))
green = np.random.randint(0, 256, (height, width))
blue = np.random.randint(0, 256, (height, width))
 
# Combiner en image RGB
rgb_image = np.stack([red, green, blue], axis=2)
print(rgb_image.shape)  # (100, 100, 3)

Visualiser les donnees combinees

Apres avoir concatene des tableaux de differentes sources, PyGWalker (opens in a new tab) vous permet d'explorer le jeu de donnees combine de maniere interactive dans Jupyter :

import pandas as pd
import pygwalker as pyg
 
# Convertir le tableau concatene en DataFrame
df = pd.DataFrame(X, columns=['age', 'income', 'score'])
walker = pyg.walk(df)

FAQ

Quelle est la difference entre np.concatenate et np.stack ?

np.concatenate joint les tableaux le long d'un axe existant sans changer le nombre de dimensions. np.stack joint les tableaux le long d'un nouvel axe, ajoutant une dimension. Par exemple, empiler deux tableaux (3,) avec concatenate donne (6,), tandis que stack donne (2, 3).

Que signifie axis dans np.concatenate ?

Le parametre axis specifie le long de quelle dimension joindre. axis=0 concatene le long des lignes (ajout de lignes), axis=1 le long des colonnes (ajout de colonnes). Pour les tableaux 2D, axis=0 est l'empilement vertical et axis=1 est l'empilement horizontal.

Quand utiliser vstack, hstack ou concatenate ?

Utilisez vstack pour ajouter des lignes (empilement vertical), hstack pour ajouter des colonnes (empilement horizontal) et concatenate quand vous devez specifier un axe arbitraire. vstack et hstack sont des fonctions pratiques qui gerent les tableaux 1D de maniere plus intuitive que concatenate.

Pourquoi j'obtiens un ValueError lors de la concatenation de tableaux ?

Tous les tableaux doivent avoir la meme forme sauf le long de l'axe de concatenation. Si vous concatenez le long de axis=0, tous les tableaux doivent avoir le meme nombre de colonnes. Verifiez les formes avec array.shape avant de concatener.

Comment concatener des tableaux de dimensions differentes ?

Remodelezd'abord les tableaux pour qu'ils aient des dimensions compatibles. Utilisez np.expand_dims(array, axis) pour ajouter une dimension, ou array.reshape(new_shape). Par exemple, pour faire vstack d'un tableau 1D avec un tableau 2D, remodelez le tableau 1D : array.reshape(1, -1).

Conclusion

NumPy fournit une boite a outils complete pour joindre des tableaux : np.concatenate() pour la jonction polyvalente le long de n'importe quel axe, np.vstack()/np.hstack() pour l'empilement vertical/horizontal intuitif, et np.stack() quand vous devez creer une nouvelle dimension. Rappelez-vous que concatenate joint le long d'axes existants tandis que stack en cree de nouveaux. Faites correspondre les dimensions soigneusement et utilisez vstack/hstack pour le code le plus lisible lors d'operations courantes sur les lignes/colonnes.