Die Pandas-Funktion DataFrame.merge() dient dazu, zwei Da­ta­Frames anhand von ge­mein­sa­men Schlüs­seln (Keys) mit­ein­an­der zu verbinden. Auf diese Weise lassen sich Daten ver­schie­de­ner Quellen effizient kom­bi­nie­ren, um um­fas­sen­de­re Analysen durch­zu­füh­ren.

Syntax der Pandas merge()-Funktion

Die Python Pandas DataFrame-merge()-Methode kann eine ganze Reihe ver­schie­de­ner Parameter ent­ge­gen­neh­men, welche die Art und Weise der Kom­bi­na­ti­on der zu ver­bin­den­den Da­ta­Frames be­ein­flus­sen. Die all­ge­mei­ne Syntax der merge()-Funktion lautet dabei wie folgt:

DataFrame.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)
python

Relevante Parameter

Mithilfe der ver­schie­de­nen Parameter, die Pandas merge() ent­ge­gen­nimmt, spe­zi­fi­zierst du nicht nur die zu kom­bi­nie­ren­den Pandas Da­ta­Frames, sondern auch die Art des Joins und weitere Details.

Parameter Be­schrei­bung Stan­dard­wert
left Erster DataFrame für die Ver­bin­dung
right Zweiter DataFrame für die Ver­bin­dung
how Art der Join-Operation (inner, outer, left oder right) inner
on Spalte oder In­de­xe­be­ne(n) als ge­mein­sa­mer Schlüssel
left_on Spalte oder In­de­xe­be­ne(n) des linken Da­ta­Frames als Schlüssel
right_on Spalte oder In­de­xe­be­ne(n) des rechten Da­ta­Frames als Schlüssel
left_index Bei True dient der linke Index als Schlüssel False
right_index Bei True dient der rechte Index als Schlüssel False
sort Bei True erfolgt eine le­xi­ko­gra­phi­sche Sor­tie­rung der Schlüssel False
suffixes Suffixe zur Ein­deu­tig­keit gleich­na­mi­ger Spalten ("_x", "_y")
copy Bei False wird keine Kopie erstellt True

Anwendung von Pandas merge()

Prak­ti­sche Beispiele helfen dabei, die Funk­ti­ons­wei­se von Pandas merge() besser zu verstehen.

INNER JOIN

Ein INNER JOIN verbindet zwei Pandas Da­ta­Frames und liefert nur jene Zeilen, bei denen die Schlüssel in beiden Da­ta­Frames identisch sind. Zuerst erstellen wir zwei Da­ta­Frames mit Bei­spiel­da­ten:

import pandas as pd
# Beispiel-DataFrames
df1 = pd.DataFrame({
    'Schlüssel': ['A', 'B', 'C'],
    'Wert1': [1, 2, 3]
})
df2 = pd.DataFrame({
    'Schlüssel': ['B', 'C', 'D'],
    'Wert2': [4, 5, 6]
})
print(df1)
print(df2)
python

Die beiden Da­ta­Frames sehen so aus:

Schlüssel    Wert1
0                 A            1
1                 B            2
2                 C            3
    Schlüssel    Wert2
0                 B            4
1                 C            5
2                 D            6

Ein INNER JOIN lässt sich nun mit der merge()-Funktion umsetzen:

# INNER JOIN
result = pd.merge(df1, df2, how='inner', on='Schlüssel')
print(result)
python

Das Ergebnis zeigt, dass nur die Zeilen mit den Schlüs­seln B und C über­nom­men werden, da diese in beiden ur­sprüng­li­chen Da­ta­Frames vorkommen.

Schlüssel    Wert1    Wert2
0                 B            2            4
1                 C            3            5

OUTER JOIN

Ein OUTER JOIN verknüpft ebenfalls zwei Da­ta­Frames. Anders als beim INNER JOIN werden hier alle Zeilen aus­ge­ge­ben, wobei fehlende Daten mit NaN befüllt werden.

# OUTER JOIN
result = pd.merge(df1, df2, how='outer', on='Schlüssel')
print(result)
python

Wie erwartet enthält das Ergebnis sämtliche Zeilen beider Da­ta­Frames. Für Schlüssel A (nur in df1) und Schlüssel D (nur in df2) werden die Lücken als NaN dar­ge­stellt.

Schlüssel    Wert1    Wert2
0                 A        1.0        NaN
1                 B        2.0        4.0
2                 C        3.0        5.0
3                 D        NaN        6.0
Hinweis

Alle weiteren JOIN-Varianten lassen sich auf die gleiche Weise anwenden.

Ver­wen­dung von left_on und right_on

Sollten die Da­ta­Frames un­ter­schied­li­che Namen für ihre Schlüs­sel­spal­ten nutzen, kannst du dies über die Parameter left_on und right_on de­fi­nie­ren. Dazu erstellen wir zwei neue Da­ta­Frames:

df3 = pd.DataFrame({
    'Schlüssel': ['A', 'B', 'C'],
    'Wert1': [1, 2, 3]
})
df4 = pd.DataFrame({
    'Schlüssel2': ['B', 'C', 'D'],
    'Wert2': [4, 5, 6]
})
print(df3)
print(df4)
python

Die Da­ta­Frames prä­sen­tie­ren sich wie folgt:

Schlüssel    Wert1
0                 A            1
1                 B            2
2                 C            3
    Schlüssel2    Wert2
0                    B            4
1                    C            5
2                    D            6

Für die JOIN-Operation mit ab­wei­chen­den Schlüs­seln werden die Parameter left_on und right_on genutzt:

# Join mit unterschiedlichen Schlüsselspaltennamen
result = pd.merge(df3, df4, how='inner', left_on='Schlüssel', right_on='Schlüssel2')
print(result)
python

Durch die explizite Angabe von left_on='Schlüssel' und right_on='Schlüssel2' werden die passenden Spalten für die Ver­knüp­fung her­an­ge­zo­gen.

Schlüssel    Wert1 Schlüssel2    Wert2
0                 B            2                    B            4
1                 C            3                    C            5

Ver­wen­dung von Indizes als Schlüssel

Du kannst ebenso die Indizes der Da­ta­Frames als Ver­knüp­fungs­schlüs­sel nutzen. Setze dafür left_index und right_index auf True. Wir starten mit zwei Da­ta­Frames inklusive Indizes:

df5 = pd.DataFrame({
    'Wert1': [1, 2, 3]
}, index=['A', 'B', 'C'])
df6 = pd.DataFrame({
    'Wert2': [4, 5, 6]
}, index=['B', 'C', 'D'])
print(df5)
print(df6)
python

Die er­stell­ten Da­ta­Frames sehen so aus:

Wert1
A        1
B        2
C        3
    Wert2
B        4
C        5
D        6

Nun erfolgt die JOIN-Operation auf Basis der Indizes:

# JOIN mit Indizes
result = pd.merge(df5, df6, how='inner', left_index=True, right_index=True)
print(result)
python

Das Resultat ist ein JOIN, der sich an den Indizes der Da­ta­Frames ori­en­tiert:

Wert1  Wert2
B        2        4
C        3        5
Zum Hauptmenü