Pandas Concat: DataFrames in Python zusammenfügen

Name

Soren Atelier

Updated on 9.2.2026

Reale Daten befinden sich selten in einer einzigen Datei. Sie laden die Januar-Verkaufsdaten aus einer CSV-Datei, die Februar-Daten aus einer anderen und die Q1-Ziele aus einer dritten. Sie scrapen mehrere Webseiten in separate DataFrames. Sie teilen einen großen Datensatz für parallele Verarbeitung auf und müssen die Teile wieder zusammensetzen. In jedem Fall benötigen Sie eine zuverlässige Methode, um DataFrames zu kombinieren, ohne Zeilen zu verlieren, Spalten durcheinanderzubringen oder Ihren Index zu beschädigen.

Die pandas concat-Funktion (pd.concat()) ist das Standardwerkzeug für diese Aufgabe. Sie stapelt DataFrames vertikal (Zeilen hinzufügen) oder horizontal (Spalten hinzufügen), behandelt unterschiedliche Spalten elegant und skaliert auf beliebig viele DataFrames in einem einzigen Aufruf. Dieser Leitfaden behandelt jeden Parameter, den Sie benötigen, mit funktionierenden Codebeispielen, die Sie direkt in Ihr Notebook einfügen können.

Was pd.concat() macht -- Grundlegende Syntax

pd.concat() nimmt eine Liste (oder ein Dictionary) von DataFrames und fügt sie entlang einer angegebenen Achse zusammen. Stellen Sie es sich wie das Stapeln von Bausteinen vor -- vertikal, um mehr Zeilen hinzuzufügen, oder nebeneinander, um mehr Spalten hinzuzufügen.

import pandas as pd
 
result = pd.concat(
    objs,              # list or dict of DataFrames
    axis=0,            # 0 = vertical (rows), 1 = horizontal (columns)
    join='outer',      # 'outer' or 'inner'
    ignore_index=False,
    keys=None,
    sort=False,
    verify_integrity=False
)

Wichtige Parameter auf einen Blick

Beispieldaten für alle Beispiele

Jedes Beispiel unten verwendet diese DataFrames:

import pandas as pd
 
df_jan = pd.DataFrame({
    'product': ['Widget', 'Gadget', 'Sprocket'],
    'units_sold': [150, 200, 80],
    'revenue': [1500, 3000, 960]
})
 
df_feb = pd.DataFrame({
    'product': ['Widget', 'Gadget', 'Sprocket'],
    'units_sold': [170, 180, 95],
    'revenue': [1700, 2700, 1140]
})
 
print(df_jan)
print(df_feb)

Ausgabe:

    product  units_sold  revenue
0    Widget         150     1500
1    Gadget         200     3000
2  Sprocket          80      960

    product  units_sold  revenue
0    Widget         170     1700
1    Gadget         180     2700
2  Sprocket          95     1140

DataFrames vertikal zusammenfügen (axis=0)

Vertikale Verkettung ist der häufigste Anwendungsfall. Sie stapelt einen DataFrame auf einen anderen und fügt Zeilen hinzu. Dies verwenden Sie, wenn Sie monatliche Dateien, Batch-Ergebnisse oder beliebige Daten haben, die über mehrere Tabellen mit den gleichen Spalten verteilt sind.

combined = pd.concat([df_jan, df_feb])
print(combined)

Ausgabe:

    product  units_sold  revenue
0    Widget         150     1500
1    Gadget         200     3000
2  Sprocket          80      960
0    Widget         170     1700
1    Gadget         180     2700
2  Sprocket          95     1140

Beachten Sie den Index: Beide DataFrames haben ihre ursprünglichen Indexwerte (0, 1, 2) beibehalten, sodass das Ergebnis doppelte Indexwerte hat. Das ist normalerweise nicht gewünscht. Die Lösung ist der Parameter ignore_index, der als Nächstes behandelt wird.

Der Parameter ignore_index -- Index zurücksetzen

Das Setzen von ignore_index=True verwirft den ursprünglichen Index und weist einen neuen sequenziellen Index ab 0 zu:

combined = pd.concat([df_jan, df_feb], ignore_index=True)
print(combined)

Ausgabe:

    product  units_sold  revenue
0    Widget         150     1500
1    Gadget         200     3000
2  Sprocket          80      960
3    Widget         170     1700
4    Gadget         180     2700
5  Sprocket          95     1140

Wann verwenden: Fast immer bei vertikaler Verkettung. Sofern Ihr Index keine bedeutungsvolle Information enthält (wie Zeitstempel oder eindeutige IDs), setzen Sie ihn zurück, um spätere Verwirrung zu vermeiden.

Der Parameter keys -- Einen hierarchischen Index erstellen

Der Parameter keys fügt dem Index eine Ebene hinzu, die kennzeichnet, aus welcher Quelle jede Zeile stammt. Dies erzeugt einen MultiIndex (hierarchischen Index):

combined = pd.concat([df_jan, df_feb], keys=['January', 'February'])
print(combined)

Ausgabe:

               product  units_sold  revenue
January  0      Widget         150     1500
         1      Gadget         200     3000
         2    Sprocket          80      960
February 0      Widget         170     1700
         1      Gadget         180     2700
         2    Sprocket          95     1140

Sie können dann Daten aus einer bestimmten Quelle mit .loc auswählen:

# Get only January data
jan_data = combined.loc['January']
print(jan_data)

Ausgabe:

    product  units_sold  revenue
0    Widget         150     1500
1    Gadget         200     3000
2  Sprocket          80      960

Wann verwenden: Verwenden Sie keys, wenn Sie nachverfolgen müssen, zu welchem ursprünglichen DataFrame jede Zeile gehört -- zum Beispiel Daten aus verschiedenen Experimenten, Zeiträumen oder Datenquellen.

Horizontal zusammenfügen (axis=1) -- Nebeneinander

Das Setzen von axis=1 platziert DataFrames nebeneinander und fügt Spalten hinzu. Pandas richtet Zeilen nach ihren Indexwerten aus.

targets = pd.DataFrame({
    'target_units': [160, 190, 90],
    'target_revenue': [1600, 2850, 1080]
})
 
result = pd.concat([df_jan, targets], axis=1)
print(result)

Ausgabe:

    product  units_sold  revenue  target_units  target_revenue
0    Widget         150     1500           160            1600
1    Gadget         200     3000           190            2850
2  Sprocket          80      960            90            1080

Dies funktioniert sauber, weil beide DataFrames den gleichen Index (0, 1, 2) teilen. Wenn die Indizes nicht übereinstimmen, erhalten Sie NaN-Werte für die nicht übereinstimmenden Zeilen:

df_a = pd.DataFrame({'value_a': [10, 20, 30]}, index=[0, 1, 2])
df_b = pd.DataFrame({'value_b': [40, 50, 60]}, index=[1, 2, 3])
 
result = pd.concat([df_a, df_b], axis=1)
print(result)

Ausgabe:

   value_a  value_b
0     10.0      NaN
1     20.0     40.0
2     30.0     50.0
3      NaN     60.0

Zeile 0 hat keinen value_b (kein passender Index in df_b), und Zeile 3 hat keinen value_a (kein passender Index in df_a).

Der Parameter join -- Inner vs Outer

Der Parameter join steuert, was passiert, wenn DataFrames unterschiedliche Spalten (bei axis=0) oder unterschiedliche Indexwerte (bei axis=1) haben.

outer join (Standard) -- Alles behalten

df_with_extra = pd.DataFrame({
    'product': ['Widget', 'Gadget'],
    'units_sold': [200, 250],
    'region': ['East', 'West']
})
 
result = pd.concat([df_jan, df_with_extra], join='outer', ignore_index=True)
print(result)

Ausgabe:

    product  units_sold  revenue region
0    Widget         150   1500.0    NaN
1    Gadget         200   3000.0    NaN
2  Sprocket          80    960.0    NaN
3    Widget         200      NaN   East
4    Gadget         250      NaN   West

Alle Spalten aus beiden DataFrames erscheinen. Fehlende Werte werden mit NaN gefüllt.

inner join -- Nur gemeinsame Spalten behalten

result = pd.concat([df_jan, df_with_extra], join='inner', ignore_index=True)
print(result)

Ausgabe:

   product  units_sold
0   Widget         150
1   Gadget         200
2 Sprocket          80
3   Widget         200
4   Gadget         250

Nur Spalten, die in beiden DataFrames existieren, bleiben erhalten. Die Spalte revenue (fehlt in df_with_extra) und die Spalte region (fehlt in df_jan) werden beide entfernt.

Wann inner join verwenden: Wenn Sie ein sauberes Ergebnis ohne NaN-Werte wollen und bereit sind, Spalten zu verlieren, die nicht in jedem DataFrame vorkommen.

Eine Liste von DataFrames zusammenfügen

Einer der größten Vorteile von pd.concat() gegenüber anderen Kombinationsmethoden ist, dass es beliebig viele DataFrames in einem einzigen Aufruf verarbeitet. Dies ist das Standardmuster zum Kombinieren von Dateien, die in einer Schleife geladen werden:

import pandas as pd
 
# Simulate loading monthly CSV files
months = {
    'Jan': {'product': ['Widget', 'Gadget'], 'units': [150, 200]},
    'Feb': {'product': ['Widget', 'Gadget'], 'units': [170, 180]},
    'Mar': {'product': ['Widget', 'Gadget'], 'units': [190, 210]},
}
 
dfs = []
for month, data in months.items():
    df = pd.DataFrame(data)
    df['month'] = month
    dfs.append(df)
 
all_data = pd.concat(dfs, ignore_index=True)
print(all_data)

Ausgabe:

  product  units month
0  Widget    150   Jan
1  Gadget    200   Jan
2  Widget    170   Feb
3  Gadget    180   Feb
4  Widget    190   Mar
5  Gadget    210   Mar

Dieses Muster -- eine Liste von DataFrames aufbauen und dann einmal concat aufrufen -- ist viel schneller als das einzelne Anhängen eines DataFrames in einer Schleife. Jedes Anhängen erstellt eine vollständige Kopie, aber ein einzelner pd.concat()-Aufruf reserviert den Speicher einmalig.

concat vs merge vs append -- Vergleichstabelle

Pandas bietet mehrere Möglichkeiten, DataFrames zu kombinieren. Die richtige Wahl hängt davon ab, wie Sie sie kombinieren möchten:

Wann was verwenden

• Verwenden Sie pd.concat(), wenn Ihre DataFrames die gleiche Struktur haben (gleiche Spalten) und Sie sie stapeln möchten. Verwenden Sie es auch für horizontale Verkettung bei Ausrichtung nach Index.
• Verwenden Sie pd.merge(), wenn Sie Zeilen basierend auf Spaltenwerten abgleichen müssen -- wie das Verbinden einer Verkaufstabelle mit einer Produkttabelle über product_id. Weitere Details finden Sie in unserem Pandas Merge Leitfaden.
• Vermeiden Sie DataFrame.append() -- es wurde in pandas 1.4 als veraltet markiert und in pandas 2.0 entfernt. Verwenden Sie stattdessen pd.concat([df1, df2]).

Häufige Fehler und Lösungen

1. Spalten stimmen nicht überein

Beim Zusammenfügen von DataFrames mit unterschiedlichen Spaltennamen füllt der Standard-Outer-Join fehlende Werte mit NaN. Wenn Sie dies nicht erwartet haben, überprüfen Sie Ihre Spaltennamen:

# Diagnose: compare column names
print(df1.columns.tolist())
print(df2.columns.tolist())
 
# Fix: rename columns to match before concatenating
df2 = df2.rename(columns={'sales': 'revenue', 'qty': 'units_sold'})
combined = pd.concat([df1, df2], ignore_index=True)

2. Datentyp-Diskrepanzen nach der Verkettung

Wenn ein DataFrame eine Spalte als int64 speichert und ein anderer als float64, konvertiert pandas zu float. Schlimmer noch, wenn einer sie als String speichert, erhalten Sie eine Spalte mit object-Datentyp:

# Check dtypes after concat
combined = pd.concat([df1, df2], ignore_index=True)
print(combined.dtypes)
 
# Fix: cast before concatenating
df2['units_sold'] = df2['units_sold'].astype(int)
combined = pd.concat([df1, df2], ignore_index=True)

3. Doppelte Indexwerte

Ohne ignore_index=True behält die vertikale Verkettung die ursprünglichen Indizes bei, was zu doppelten Werten führt. Dies verursacht Probleme bei .loc-Abfragen:

combined = pd.concat([df1, df2])
# combined.loc[0] returns TWO rows, not one
 
# Fix option 1: use ignore_index
combined = pd.concat([df1, df2], ignore_index=True)
 
# Fix option 2: use verify_integrity to catch the issue early
combined = pd.concat([df1, df2], verify_integrity=True)  # raises ValueError

4. Versehentliches Zusammenfügen entlang der falschen Achse

Wenn Ihr Ergebnis doppelt so viele Spalten statt doppelt so vieler Zeilen hat (oder umgekehrt), überprüfen Sie den Parameter axis:

# Wrong: this adds columns side by side
wrong = pd.concat([df1, df2], axis=1)
 
# Right: this stacks rows vertically
right = pd.concat([df1, df2], axis=0)

Visualisieren Sie Ihre zusammengefügten DataFrames mit PyGWalker

Nach dem Zusammenfügen von Daten aus mehreren Quellen müssen Sie häufig das Ergebnis überprüfen und Muster im kombinierten Datensatz erkunden. Anstatt manuellen Plot-Code mit matplotlib oder seaborn zu schreiben, können Sie PyGWalker (opens in a new tab) verwenden -- eine Open-Source-Python-Bibliothek, die jeden pandas DataFrame in eine interaktive, Tableau-ähnliche visuelle Explorationsumgebung direkt in Jupyter Notebook verwandelt.

import pandas as pd
import pygwalker as pyg
 
# Combine monthly sales data
df_jan = pd.DataFrame({
    'product': ['Widget', 'Gadget', 'Sprocket'],
    'units_sold': [150, 200, 80],
    'revenue': [1500, 3000, 960],
    'month': ['Jan', 'Jan', 'Jan']
})
 
df_feb = pd.DataFrame({
    'product': ['Widget', 'Gadget', 'Sprocket'],
    'units_sold': [170, 180, 95],
    'revenue': [1700, 2700, 1140],
    'month': ['Feb', 'Feb', 'Feb']
})
 
combined = pd.concat([df_jan, df_feb], ignore_index=True)
 
# Launch interactive visualization
walker = pyg.walk(combined)

Mit PyGWalker können Sie product auf die x-Achse und revenue auf die y-Achse ziehen und dann nach month aufteilen, um sofort Umsatztrends über Perioden hinweg zu vergleichen -- kein Chart-Code erforderlich. Sie können Balkendiagramme, Streudiagramme, Liniendiagramme und mehr erstellen, indem Sie einfach Felder ziehen. Es ist besonders nützlich, um zu überprüfen, ob Ihre Verkettung korrekt funktioniert hat und ob Daten aus verschiedenen Quellen wie erwartet übereinstimmen.

Installieren Sie PyGWalker mit pip install pygwalker, oder probieren Sie es in Google Colab (opens in a new tab) oder Kaggle (opens in a new tab) aus.

FAQ

Was ist der Unterschied zwischen pandas concat und merge?

pd.concat() stapelt DataFrames vertikal (Zeilen hinzufügen) oder horizontal (Spalten hinzufügen) durch Ausrichtung am Index. pd.merge() verbindet zwei DataFrames durch Abgleich von Werten in bestimmten Spalten, wie ein SQL JOIN. Verwenden Sie concat, wenn Ihre DataFrames die gleichen Spalten haben und Sie Zeilen kombinieren möchten. Verwenden Sie merge, wenn Sie Zeilen basierend auf einer gemeinsamen Schlüsselspalte abgleichen müssen.

Verändert pd.concat() die ursprünglichen DataFrames?

Nein. pd.concat() gibt immer einen neuen DataFrame zurück. Die ursprünglichen DataFrames bleiben unverändert. Dies entspricht dem pandas-Designprinzip, dass Operationen neue Objekte zurückgeben, anstatt Daten an Ort und Stelle zu ändern.

Wie füge ich DataFrames mit unterschiedlichen Spalten zusammen?

Verwenden Sie pd.concat() mit dem Standard join='outer' -- es behält alle Spalten aus allen DataFrames und füllt fehlende Werte mit NaN. Wenn Sie nur Spalten möchten, die in jedem DataFrame vorkommen, setzen Sie join='inner'. Sie können Spalten auch vor dem Zusammenfügen umbenennen, um die Ausrichtung sicherzustellen.

Ist pd.concat() schneller als DataFrame.append()?

Ja. DataFrame.append() wurde in pandas 1.4 als veraltet markiert und in pandas 2.0 entfernt. Es rief intern pd.concat() auf, erstellte aber bei jedem Aufruf eine Kopie. Beim Kombinieren vieler DataFrames ist das Sammeln in einer Liste und einmaliges Aufrufen von pd.concat() deutlich schneller, da der Speicher nur einmal reserviert wird.

Wie setze ich den Index nach der Verkettung zurück?

Übergeben Sie ignore_index=True an pd.concat(): pd.concat([df1, df2], ignore_index=True). Dies ersetzt die ursprünglichen Indexwerte durch einen neuen sequenziellen Index ab 0. Alternativ können Sie .reset_index(drop=True) auf das Ergebnis anwenden.

Fazit

Die pandas concat()-Funktion ist das bevorzugte Werkzeug zum Kombinieren von DataFrames, die die gleiche Struktur teilen. Hier sind die wichtigsten Erkenntnisse:

• Vertikale Verkettung (axis=0) stapelt Zeilen und ist der häufigste Anwendungsfall -- ideal zum Kombinieren monatlicher Dateien, Batch-Ergebnisse oder aufgeteilter Datensätze.
• Horizontale Verkettung (axis=1) platziert DataFrames nebeneinander, ausgerichtet am Index.
• Verwenden Sie ignore_index=True, um einen sauberen sequenziellen Index zu erhalten (in den meisten Fällen empfohlen).
• Verwenden Sie keys, um einen hierarchischen Index zu erstellen, der nachverfolgt, aus welcher Quelle jede Zeile stammt.
• Der Parameter join steuert, wie nicht übereinstimmende Spalten behandelt werden: 'outer' behält alles, 'inner' behält nur gemeinsame Spalten.
• Sammeln Sie DataFrames immer in einer Liste und rufen Sie pd.concat() einmal auf, anstatt in einer Schleife anzuhängen.
• Verwenden Sie pd.merge() stattdessen, wenn Sie SQL-ähnliche Joins auf Spaltenwerten benötigen.

Sobald Ihre Daten zusammengefügt sind, können Sie mit Tools wie PyGWalker (opens in a new tab) das kombinierte Ergebnis visuell erkunden, ohne Chart-Code zu schreiben, was es schneller macht, Ihre Datenpipeline zu überprüfen und Muster über Quellen hinweg zu entdecken.