NumPy Concatenate: Arrays verbinden mit np.concatenate, vstack und hstack

Name

Soren Atelier

Updated on 10.2.2026

Das Kombinieren von Arrays ist eine der haeufigsten Operationen im numerischen Rechnen. Sie teilen Daten zur Verarbeitung auf und muessen sie dann wieder zusammenfuegen. Sie laden Features aus mehreren Quellen in eine einzelne Matrix. Sie stapeln Vorhersagen aus mehreren Modellen fuer Ensembling. Die Verwendung von Python-Listen zum Kombinieren von Arrays mit Schleifen oder + zerstoert die Leistung und erstellt unnoetige Kopien.

NumPy bietet spezialisierte Funktionen zum Verbinden von Arrays, die mit C-Geschwindigkeit arbeiten und Ihnen praezise Kontrolle darueber geben, entlang welcher Achse verkettet werden soll. Dieser Leitfaden behandelt np.concatenate(), np.vstack(), np.hstack(), np.stack() und ihre Anwendungsfaelle.

np.concatenate() -- Die Kernfunktion

np.concatenate() verbindet eine Sequenz von Arrays entlang einer bestehenden Achse.

1D-Arrays

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,)

2D-Arrays entlang Zeilen (axis=0)

import numpy as np
 
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
 
# Vertikal stapeln (Zeilen hinzufuegen)
result = np.concatenate([a, b], axis=0)
print(result)
# [[1 2]
#  [3 4]
#  [5 6]
#  [7 8]]
print(result.shape)  # (4, 2)

2D-Arrays entlang Spalten (axis=1)

import numpy as np
 
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
 
# Horizontal stapeln (Spalten hinzufuegen)
result = np.concatenate([a, b], axis=1)
print(result)
# [[1 2 5 6]
#  [3 4 7 8]]
print(result.shape)  # (2, 4)

Shape-Anforderungen

Alle Arrays muessen die gleiche Form haben, ausser entlang der Verkettungsachse.

import numpy as np
 
a = np.ones((3, 4))    # 3 Zeilen, 4 Spalten
b = np.zeros((2, 4))   # 2 Zeilen, 4 Spalten
 
# OK: unterschiedliche Zeilenanzahl, gleiche Spaltenanzahl, axis=0
result = np.concatenate([a, b], axis=0)
print(result.shape)  # (5, 4)
 
# FEHLER: unterschiedliche Spaltenanzahl
c = np.ones((3, 5))
# np.concatenate([a, c], axis=0)  # ValueError: dimensions don't match

np.vstack() -- Vertikales Stapeln

np.vstack() stapelt Arrays vertikal (entlang Achse 0). Aequivalent zu np.concatenate(arrays, axis=0), behandelt aber auch 1D-Arrays, indem es sie als einzelne Zeilen interpretiert.

import numpy as np
 
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
 
# vstack behandelt 1D-Arrays als Zeilen
result = np.vstack([a, b])
print(result)
# [[1 2 3]
#  [4 5 6]]
print(result.shape)  # (2, 3)
 
# Mit 2D-Arrays
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() -- Horizontales Stapeln

np.hstack() stapelt Arrays horizontal (entlang Achse 1 fuer 2D, Achse 0 fuer 1D).

import numpy as np
 
# 1D-Arrays: verkettet wie 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]
 
# 2D-Arrays: fuegt Spalten hinzu
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() -- Erstellt eine neue Achse

Im Gegensatz zu concatenate verbindet stack Arrays entlang einer neuen Achse und erhoeht die Dimensionsanzahl um 1.

import numpy as np
 
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
 
# Stapeln entlang neuer Achse 0 (Standard)
result = np.stack([a, b])
print(result)
# [[1 2 3]
#  [4 5 6]]
print(result.shape)  # (2, 3)
 
# Stapeln entlang neuer Achse 1
result = np.stack([a, b], axis=1)
print(result)
# [[1 4]
#  [2 5]
#  [3 6]]
print(result.shape)  # (3, 2)

Alle Eingabe-Arrays muessen fuer np.stack() die gleiche Form haben.

Funktionsvergleich

Praktische Beispiele

Features fuer maschinelles Lernen kombinieren

import numpy as np
 
# Feature-Arrays aus verschiedenen Quellen
ages = np.array([25, 30, 35, 40])
incomes = np.array([50000, 60000, 75000, 90000])
scores = np.array([720, 680, 750, 800])
 
# Als Spalten stapeln, um Feature-Matrix zu erstellen
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)

Batch-Verarbeitungsergebnisse

import numpy as np
 
# Daten in Batches verarbeiten, Ergebnisse kombinieren
results = []
for batch_start in range(0, 100, 25):
    batch = np.random.randn(25, 10)  # 25 Samples, 10 Features
    processed = batch * 2 + 1  # Verarbeitung
    results.append(processed)
 
# Alle Batches vertikal kombinieren
all_results = np.vstack(results)
print(all_results.shape)  # (100, 10)

Bildverarbeitung -- Kanaele kombinieren

import numpy as np
 
height, width = 100, 100
 
# Separate Farbkanaele
red = np.random.randint(0, 256, (height, width))
green = np.random.randint(0, 256, (height, width))
blue = np.random.randint(0, 256, (height, width))
 
# Zu RGB-Bild kombinieren
rgb_image = np.stack([red, green, blue], axis=2)
print(rgb_image.shape)  # (100, 100, 3)

Kombinierte Daten visualisieren

Nach dem Verketten von Arrays aus verschiedenen Quellen ermoeglicht PyGWalker (opens in a new tab) die interaktive Erkundung des kombinierten Datensatzes in Jupyter:

import pandas as pd
import pygwalker as pyg
 
# Verkettetes Array in DataFrame konvertieren
df = pd.DataFrame(X, columns=['age', 'income', 'score'])
walker = pyg.walk(df)

FAQ

Was ist der Unterschied zwischen np.concatenate und np.stack?

np.concatenate verbindet Arrays entlang einer bestehenden Achse, ohne die Anzahl der Dimensionen zu aendern. np.stack verbindet Arrays entlang einer neuen Achse und fuegt eine Dimension hinzu. Zum Beispiel ergibt das Stapeln von zwei (3,)-Arrays mit concatenate (6,), waehrend stack (2, 3) ergibt.

Was bedeutet axis in np.concatenate?

Der Parameter axis gibt an, entlang welcher Dimension verbunden werden soll. axis=0 verkettet entlang der Zeilen (fuegt mehr Zeilen hinzu), axis=1 entlang der Spalten (fuegt mehr Spalten hinzu). Fuer 2D-Arrays ist axis=0 vertikales Stapeln und axis=1 horizontales Stapeln.

Wann sollte ich vstack, hstack oder concatenate verwenden?

Verwenden Sie vstack zum Hinzufuegen von Zeilen (vertikal stapeln), hstack zum Hinzufuegen von Spalten (horizontal stapeln) und concatenate, wenn Sie eine beliebige Achse angeben muessen. vstack und hstack sind Komfortfunktionen, die 1D-Arrays intuitiver behandeln als concatenate.

Warum erhalte ich einen ValueError beim Verketten von Arrays?

Alle Arrays muessen die gleiche Form haben, ausser entlang der Verkettungsachse. Wenn Sie entlang axis=0 verketten, muessen alle Arrays die gleiche Anzahl von Spalten haben. Ueberpruefen Sie die Formen mit array.shape vor dem Verketten.

Wie verkette ich Arrays mit unterschiedlichen Dimensionen?

Formen Sie die Arrays zuerst so um, dass sie kompatible Dimensionen haben. Verwenden Sie np.expand_dims(array, axis) zum Hinzufuegen einer Dimension oder array.reshape(new_shape). Um beispielsweise ein 1D-Array mit einem 2D-Array zu vstacken, formen Sie das 1D-Array um: array.reshape(1, -1).

Fazit

NumPy bietet ein vollstaendiges Toolkit zum Verbinden von Arrays: np.concatenate() fuer allgemeines Verbinden entlang jeder Achse, np.vstack()/np.hstack() fuer intuitives vertikales/horizontales Stapeln und np.stack() wenn Sie eine neue Dimension erstellen muessen. Denken Sie daran, dass concatenate entlang bestehender Achsen verbindet, waehrend stack neue erstellt. Passen Sie die Dimensionen sorgfaeltig an und verwenden Sie vstack/hstack fuer den lesbarsten Code bei gaengigen Zeilen-/Spaltenoperationen.