Python Pandas: Da­ta­Frames mit merge() verbinden

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 von Pandas merge()-Funktion

Python Pandas DataFrame-merge()-Methode kann eine ganze Reihe ver­schie­de­ner Parameter ent­ge­gen­neh­men, die 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)

Relevante Parameter

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

Anwendung von Pandas merge()

Ver­schie­de­ne Beispiele können dabei helfen, die Vor­ge­hens­wei­se der Pandas merge()-Funktion nach­zu­voll­zie­hen.

INNER JOIN

Ein INNER JOIN verbindet zwei Pandas Da­ta­Frames und gibt nur die Zeilen zurück, bei denen die Schlüssel in beiden Da­ta­Frames über­ein­stim­men. Zunächst werden zwei Da­ta­Frames mit Bei­spiel­da­ten erstellt:

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)

Die beiden re­sul­tie­ren­den Da­ta­Frames sehen fol­gen­der­ma­ßen 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

Man kann nun einen INNER JOIN durch­füh­ren, indem die merge()-Funktion genutzt wird:

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

Die Ausgabe zeigt, dass in diesem Beispiel nur die Zeilen mit den Schlüs­seln B und C in den Ergebnis-DataFrame auf­ge­nom­men werden, da diese in beiden ur­sprüng­li­chen Da­ta­Frames vorhanden sind.

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

OUTER JOIN

Ein OUTER JOIN verbindet ebenfalls zwei Da­ta­Frames mit­ein­an­der. Im Gegensatz zum INNER JOIN werden alle Zeilen zu­rück­ge­ge­ben, wobei fehlende Werte mit NaN auf­ge­füllt werden.

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

Wie erwartet werden im Ergebnis-DataFrame alle Zeilen aus beiden Da­ta­Frames ein­be­zo­gen. Für den Schlüssel A, der nur in df1 vorhanden ist, und den Schlüssel D, der nur in df2 vorhanden ist, werden die fehlenden Werte als NaN eingefügt.

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

Ver­wen­dung von left_on und right_on

Manchmal haben die beiden Da­ta­Frames un­ter­schied­li­che Schlüs­sel­spal­ten­na­men. In diesem Fall können Sie die Parameter left_on und right_on verwenden, um anzugeben, welche Spalten verwendet werden sollen. Hierzu werden zunächst zwei neue Da­ta­Frames erstellt:

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)

Die beiden 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

Um die JOIN-Operation mit un­ter­schied­li­chen Schlüs­seln vor­zu­neh­men, werden nun die Parameter left_on und right_on spe­zi­fi­ziert:

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

Durch die explizite Nutzung von left_on='Schlüssel' und right_on='Schlüssel2' werden die ent­spre­chen­den Schlüs­sel­spal­ten für die Ver­bin­dung genutzt.

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

Ver­wen­dung von Indizes als Schlüssel

Sie können auch die Indizes der Da­ta­Frames als Schlüssel für die Ver­bin­dung verwenden, indem Sie die Parameter left_index und right_index auf True setzen. Es werden zunächst zwei neue Da­ta­Frames mit Indizes erstellt:

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)

Die im obigen Code er­stell­ten Da­ta­Frames sind die Folgenden:

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

Nun kann eine JOIN-Operation basierend auf den Indizes durch­ge­führt werden:

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

Das Ergebnis ist wenig über­ra­schend ein JOIN basierend auf den Indizes der Da­ta­Frames:

Wert1  Wert2
B        2        4
C        3        5