Pandas Merge: Der vollständige Leitfaden zum Zusammenführen von DataFrames in Python

Name

Soren Atelier

Updated on 9.2.2026

Die Arbeit mit einem einzelnen DataFrame ist in der realen Welt selten. Die meisten Datenanalyseprojekte erfordern die Kombination von Daten aus mehreren Quellen – Verkaufsaufzeichnungen mit Kundenprofilen, Sensormesswerte mit Gerätemetadaten oder Umfrageantworten mit demografischen Tabellen. Die pandas merge-Funktion ist das Standardwerkzeug, das Python-Entwickler verwenden, um DataFrames zusammenzuführen, und ihr gutes Verständnis macht den Unterschied, ob die Datenaufbereitung Minuten oder Stunden dauert.

Dieser Leitfaden behandelt jeden Aspekt von pd.merge(): die vier Hauptverbindungstypen, das Zusammenführen über mehrere Spalten, die Behandlung doppelter Namen und häufige Fallstricke. Jedes Beispiel verwendet funktionierenden Code, den Sie direkt in Ihr Notebook kopieren können.

Was pd.merge() macht

pd.merge() kombiniert zwei DataFrames, indem Zeilen basierend auf einer oder mehreren gemeinsamen Spalten (sogenannte Schlüssel) abgeglichen werden. Es funktioniert wie eine SQL JOIN-Anweisung. Sie wählen aus, welche Spalten abgeglichen werden sollen und welche Art von Join durchgeführt werden soll, und pandas erledigt den Rest.

Hier ist die grundlegende Syntax:

import pandas as pd
 
result = pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,
                  suffixes=('_x', '_y'), indicator=False, validate=None)

Referenz der Hauptparameter

Wenn Sie on, left_on und right_on weglassen, wird pandas automatisch alle Spalten verbinden, die in beiden DataFrames denselben Namen haben.

Beispieldaten für alle Beispiele

Jedes Beispiel unten verwendet diese beiden DataFrames:

import pandas as pd
 
employees = pd.DataFrame({
    'emp_id': [1, 2, 3, 4, 5],
    'name': ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve'],
    'dept_id': [10, 20, 10, 30, 20]
})
 
departments = pd.DataFrame({
    'dept_id': [10, 20, 40],
    'dept_name': ['Engineering', 'Marketing', 'Sales']
})
 
print(employees)
print(departments)

Ausgabe:

   emp_id     name  dept_id
0       1    Alice       10
1       2      Bob       20
2       3  Charlie       10
3       4    Diana       30
4       5      Eve       20

   dept_id    dept_name
0       10  Engineering
1       20    Marketing
2       40        Sales

Beachten Sie, dass dept_id 30 nur in employees existiert und dept_id 40 nur in departments. Diese Nichtübereinstimmung ist beabsichtigt – sie macht den Unterschied zwischen den Join-Typen deutlich.

Inner Merge (Standard)

Ein Inner Merge gibt nur die Zeilen zurück, in denen der Schlüssel in beiden DataFrames existiert. Zeilen ohne Übereinstimmung werden gelöscht.

inner_result = pd.merge(employees, departments, on='dept_id', how='inner')
print(inner_result)

Ausgabe:

   emp_id     name  dept_id    dept_name
0       1    Alice       10  Engineering
1       3  Charlie       10  Engineering
2       2      Bob       20    Marketing
3       5      Eve       20    Marketing

Diana (dept_id=30) wird gelöscht, da Abteilung 30 nicht in der departments-Tabelle existiert. Abteilung 40 (Vertrieb) fehlt ebenfalls, da kein Mitarbeiter zu ihr gehört.

Wann Inner Merge verwenden: Verwenden Sie es, wenn Sie nur vollständige Datensätze wollen – Zeilen, die auf beiden Seiten gültige Daten haben. Dies ist der sicherste Standard, da er niemals NaN-Werte aus nicht übereinstimmenden Zeilen einführt.

Left Merge

Ein Left Merge behält alle Zeilen vom linken DataFrame und nur die übereinstimmenden Zeilen vom rechten. Wo es keine Übereinstimmung gibt, werden die rechten Spalten mit NaN gefüllt.

left_result = pd.merge(employees, departments, on='dept_id', how='left')
print(left_result)

Ausgabe:

   emp_id     name  dept_id    dept_name
0       1    Alice       10  Engineering
1       2      Bob       20    Marketing
2       3  Charlie       10  Engineering
3       4    Diana       30          NaN
4       5      Eve       20    Marketing

Diana ist jetzt enthalten, aber ihr dept_name ist NaN, da Abteilung 30 keinen Eintrag in der departments-Tabelle hat.

Wann Left Merge verwenden: Verwenden Sie es, wenn der linke DataFrame Ihr "primärer" Datensatz ist und Sie ihn mit zusätzlichen Spalten anreichern möchten, ohne Zeilen aus der Primärtabelle zu verlieren. Dies ist der häufigste Merge-Typ in der Praxis.

Right Merge

Ein Right Merge ist das Spiegelbild eines Left Merge. Es behält alle Zeilen vom rechten DataFrame und nur übereinstimmende Zeilen vom linken.

right_result = pd.merge(employees, departments, on='dept_id', how='right')
print(right_result)

Ausgabe:

   emp_id     name  dept_id    dept_name
0     1.0    Alice       10  Engineering
1     3.0  Charlie       10  Engineering
2     2.0      Bob       20    Marketing
3     5.0      Eve       20    Marketing
4     NaN      NaN       40        Sales

Die Vertriebsabteilung (dept_id=40) erscheint jetzt, obwohl kein Mitarbeiter zu ihr gehört. Die Mitarbeiterfelder sind für diese Zeile NaN.

Wann Right Merge verwenden: In der Praxis sind Right Merges selten. Sie können einen Right Merge immer als Left Merge umschreiben, indem Sie die DataFrame-Reihenfolge vertauschen. Die meisten Codebasen bevorzugen Left Merges für Konsistenz.

Outer Merge (Full Outer Join)

Ein Outer Merge gibt alle Zeilen von beiden DataFrames zurück. Wo es keine Übereinstimmung gibt, werden fehlende Werte mit NaN gefüllt.

outer_result = pd.merge(employees, departments, on='dept_id', how='outer')
print(outer_result)

Ausgabe:

   emp_id     name  dept_id    dept_name
0     1.0    Alice       10  Engineering
1     3.0  Charlie       10  Engineering
2     2.0      Bob       20    Marketing
3     5.0      Eve       20    Marketing
4     4.0    Diana       30          NaN
5     NaN      NaN       40        Sales

Sowohl Diana (keine passende Abteilung) als auch Vertrieb (keine passenden Mitarbeiter) erscheinen im Ergebnis.

Wann Outer Merge verwenden: Verwenden Sie es, wenn Sie ein vollständiges Bild beider Datensätze benötigen und identifizieren möchten, welche Zeilen nicht übereinstimmen. Der indicator-Parameter ist hier besonders hilfreich.

Schneller Vergleich der Merge-Typen

Zusammenführen über mehrere Spalten

Wenn eine einzelne Spalte nicht ausreicht, um eine Übereinstimmung eindeutig zu identifizieren, übergeben Sie eine Liste von Spaltennamen an on:

sales = pd.DataFrame({
    'year': [2024, 2024, 2025, 2025],
    'quarter': ['Q1', 'Q2', 'Q1', 'Q2'],
    'revenue': [100, 150, 200, 250]
})
 
targets = pd.DataFrame({
    'year': [2024, 2024, 2025, 2025],
    'quarter': ['Q1', 'Q2', 'Q1', 'Q2'],
    'target': [120, 140, 210, 230]
})
 
merged = pd.merge(sales, targets, on=['year', 'quarter'])
print(merged)

Ausgabe:

   year quarter  revenue  target
0  2024      Q1      100     120
1  2024      Q2      150     140
2  2025      Q1      200     210
3  2025      Q2      250     230

Dies entspricht einem zusammengesetzten Schlüssel in SQL. Sowohl year als auch quarter müssen übereinstimmen, damit Zeilen verbunden werden.

Zusammenführen mit unterschiedlichen Spaltennamen

Manchmal verwenden die beiden DataFrames unterschiedliche Namen für dasselbe Konzept. Verwenden Sie left_on und right_on anstelle von on:

orders = pd.DataFrame({
    'order_id': [101, 102, 103],
    'customer_id': [1, 2, 3],
    'amount': [50.0, 75.0, 120.0]
})
 
customers = pd.DataFrame({
    'id': [1, 2, 4],
    'name': ['Alice', 'Bob', 'Diana']
})
 
merged = pd.merge(orders, customers, left_on='customer_id', right_on='id', how='left')
print(merged)

Ausgabe:

   order_id  customer_id  amount   id   name
0       101            1    50.0  1.0  Alice
1       102            2    75.0  2.0    Bob
2       103            3   120.0  NaN    NaN

Beachten Sie, dass sowohl die Spalten customer_id als auch id im Ergebnis erscheinen. Sie können das Duplikat danach löschen:

merged = merged.drop(columns=['id'])

Umgang mit doppelten Spaltennamen mit Suffixen

Wenn beide DataFrames Spalten mit demselben Namen haben (außer dem Schlüssel), fügt pandas Suffixe hinzu, um sie zu unterscheiden:

df1 = pd.DataFrame({
    'id': [1, 2, 3],
    'score': [85, 90, 78]
})
 
df2 = pd.DataFrame({
    'id': [1, 2, 3],
    'score': [88, 92, 80]
})
 
# Standard-Suffixe
merged = pd.merge(df1, df2, on='id')
print(merged)

Ausgabe:

   id  score_x  score_y
0   1       85       88
1   2       90       92
2   3       78       80

Sie können die Suffixe anpassen, um Spaltennamen aussagekräftiger zu machen:

merged = pd.merge(df1, df2, on='id', suffixes=('_midterm', '_final'))
print(merged)

Ausgabe:

   id  score_midterm  score_final
0   1             85           88
1   2             90           92
2   3             78           80

Verwendung des Indicator-Parameters

Der indicator-Parameter fügt eine _merge-Spalte hinzu, die anzeigt, woher jede Zeile stammt:

result = pd.merge(employees, departments, on='dept_id', how='outer', indicator=True)
print(result)

Ausgabe:

   emp_id     name  dept_id    dept_name      _merge
0     1.0    Alice       10  Engineering        both
1     3.0  Charlie       10  Engineering        both
2     2.0      Bob       20    Marketing        both
3     5.0      Eve       20    Marketing        both
4     4.0    Diana       30          NaN   left_only
5     NaN      NaN       40        Sales  right_only

Dies ist äußerst nützlich für Datenqualitätsprüfungen – Sie können schnell Zeilen filtern, die nicht übereinstimmen:

unmatched = result[result['_merge'] != 'both']
print(unmatched)

merge() vs join() vs concat() -- Wann welche verwenden

Pandas bietet drei Möglichkeiten, DataFrames zu kombinieren. Hier ist, wann Sie welche verwenden sollten:

Faustregeln:

• Verwenden Sie pd.merge(), wenn Sie DataFrames basierend auf Spaltenwerten kombinieren (der häufigste Fall).
• Verwenden Sie df.join(), wenn Ihr Join-Schlüssel der Index ist und Sie eine kürzere Syntax wünschen.
• Verwenden Sie pd.concat(), wenn Sie DataFrames übereinander stapeln (Zeilen anhängen) oder nebeneinander platzieren.

Häufige Fehler und Fehlerbehebung

1. MergeError: Spalten überlappen sich, aber kein Suffix angegeben

Dies geschieht, wenn beide DataFrames Nicht-Schlüssel-Spalten mit demselben Namen haben und Sie suffixes=(False, False) setzen:

# Behebung: verwenden Sie aussagekräftige Suffixe
merged = pd.merge(df1, df2, on='id', suffixes=('_left', '_right'))

2. Unerwartete Zeilenexplosion (Viele-zu-Viele-Merge)

Wenn beide DataFrames doppelte Werte im Join-Schlüssel haben, erstellt pandas ein kartesisches Produkt der übereinstimmenden Zeilen. Dies kann dazu führen, dass Ihr Ergebnis weit mehr Zeilen als beide Eingaben hat:

# Auf Duplikate vor dem Zusammenführen prüfen
print(df1['key'].duplicated().sum())
print(df2['key'].duplicated().sum())
 
# Verwenden Sie validate, um dies früh zu erkennen
merged = pd.merge(df1, df2, on='key', validate='one_to_many')

Der validate-Parameter akzeptiert 'one_to_one', 'one_to_many', 'many_to_one' und 'many_to_many'. Er wirft einen MergeError, wenn die Daten nicht der erwarteten Kardinalität entsprechen.

3. Schlüsselspalte hat unterschiedliche dtypes

Wenn ein DataFrame den Schlüssel als int64 speichert und der andere als object (String), schlägt der Merge entweder fehl oder erzeugt null Übereinstimmungen:

# dtypes prüfen
print(df1['id'].dtype)  # int64
print(df2['id'].dtype)  # object
 
# Behebung: in denselben Typ umwandeln
df2['id'] = df2['id'].astype(int)
merged = pd.merge(df1, df2, on='id')

4. NaN-Werte in Schlüsseln

Zeilen mit NaN in der Join-Schlüsselspalte passen zu nichts (NaN != NaN in pandas). Löschen oder füllen Sie sie zuerst:

df1 = df1.dropna(subset=['key'])

Visualisieren Sie Ihre zusammengeführten DataFrames mit PyGWalker

Nach dem Zusammenführen Ihrer Daten besteht der nächste Schritt normalerweise darin, das Ergebnis zu erkunden – Verteilungen anzusehen, Muster zu erkennen und Anomalien zu überprüfen. Anstatt Dutzende von matplotlib- oder seaborn-Aufrufen zu schreiben, können Sie PyGWalker (opens in a new tab) verwenden, eine Open-Source-Python-Bibliothek, die jeden pandas DataFrame direkt in Jupyter Notebook in eine interaktive, Tableau-ähnliche visuelle Explorationsschnittstelle verwandelt.

import pandas as pd
import pygwalker as pyg
 
# Führen Sie Ihre DataFrames zusammen
employees = pd.DataFrame({
    'emp_id': [1, 2, 3, 4, 5],
    'name': ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve'],
    'dept_id': [10, 20, 10, 30, 20],
    'salary': [95000, 82000, 105000, 78000, 91000]
})
 
departments = pd.DataFrame({
    'dept_id': [10, 20, 30],
    'dept_name': ['Engineering', 'Marketing', 'Design']
})
 
merged = pd.merge(employees, departments, on='dept_id')
 
# Starten Sie die interaktive Visualisierung -- ziehen und ablegen zum Erkunden
walker = pyg.walk(merged)

Mit PyGWalker können Sie dept_name auf die x-Achse und salary auf die y-Achse ziehen, um sofort die Gehaltsverteilung nach Abteilung zu sehen – kein Diagrammcode erforderlich. Sie können Balkendiagramme, Streudiagramme, Histogramme und mehr erstellen, indem Sie einfach Felder ziehen. Es ist besonders leistungsfähig für die Erkundung der Ergebnisse komplexer Merges, bei denen Sie überprüfen müssen, ob der Join wie erwartet funktioniert hat.

Sie können PyGWalker jetzt in Google Colab (opens in a new tab), Kaggle (opens in a new tab) ausprobieren oder es mit pip install pygwalker installieren.

FAQ

Was ist der Unterschied zwischen pandas merge und join?

pd.merge() verbindet DataFrames standardmäßig basierend auf Spaltenwerten und unterstützt alle Join-Typen (inner, left, right, outer, cross). df.join() verbindet standardmäßig über den Index und verwendet einen Left Join. Unter der Haube ruft join() merge() auf, sodass sie dieselben Ergebnisse liefern – merge() gibt Ihnen einfach mehr Kontrolle darüber, welche Spalten abgeglichen werden sollen.

Wie führe ich zwei DataFrames über mehrere Spalten in pandas zusammen?

Übergeben Sie eine Liste von Spaltennamen an den on-Parameter: pd.merge(df1, df2, on=['col_a', 'col_b']). Beide Spalten müssen übereinstimmen, damit Zeilen verbunden werden. Dies entspricht einem zusammengesetzten Schlüssel in SQL.

Warum erstellt mein pandas merge doppelte Zeilen?

Doppelte Zeilen erscheinen, wenn der Join-Schlüssel wiederholte Werte in einem oder beiden DataFrames hat. Pandas erstellt ein kartesisches Produkt aller übereinstimmenden Zeilen. Verwenden Sie df.duplicated(subset=['key']).sum(), um vor dem Zusammenführen auf Duplikate zu prüfen, oder verwenden Sie validate='one_to_one', um es früh zu erkennen.

Was ist ein Cross Merge in pandas?

Ein Cross Merge (how='cross') erzeugt das kartesische Produkt beider DataFrames – jede Zeile von links wird mit jeder Zeile von rechts gepaart. Wenn links 3 Zeilen und rechts 4 Zeilen hat, hat das Ergebnis 12 Zeilen. Es ist nützlich zum Generieren aller möglichen Kombinationen, z. B. zum Paaren jedes Produkts mit jedem Standort.

Wie führe ich einen pandas merge über den Index durch?

Setzen Sie left_index=True und/oder right_index=True: pd.merge(df1, df2, left_index=True, right_index=True). Sie können auch Index- und Spaltenschlüssel mischen: pd.merge(df1, df2, left_on='col_a', right_index=True).

Fazit

Die pandas merge()-Funktion ist das flexibelste und am weitesten verbreitete Werkzeug zum Kombinieren von DataFrames in Python. Um die wichtigsten Punkte zusammenzufassen:

• Inner Merge (Standard) behält nur Zeilen, die in beiden DataFrames übereinstimmen.
• Left Merge behält alle Zeilen vom linken DataFrame und füllt NaN, wo rechts keine Übereinstimmung vorliegt.
• Right Merge behält alle Zeilen vom rechten DataFrame – bevorzugen Sie aber Left Merge mit vertauschter Reihenfolge für Konsistenz.
• Outer Merge behält alles von beiden Seiten, nützlich zur Identifizierung nicht übereinstimmender Datensätze mit indicator=True.
• Verwenden Sie on für gleichnamige Schlüssel, left_on/right_on für unterschiedlich benannte Schlüssel und suffixes zur Behandlung überlappender Spalten.
• Überprüfen Sie immer auf doppelte Schlüssel und nicht übereinstimmende dtypes vor dem Zusammenführen, um unerwartete Ergebnisse zu vermeiden.

Sobald Ihre Daten zusammengeführt sind, ermöglichen Tools wie PyGWalker (opens in a new tab) die visuelle Erkundung des Ergebnisses ohne Diagrammcode, wodurch der gesamte Analyse-Workflow schneller und intuitiver wird.