Python Pandas: DataFrames mit merge() verbinden

Die Pandas-Funktion DataFrame.merge() dient dazu, zwei DataFrames anhand von gemeinsamen Schlüsseln (Keys) miteinander zu verbinden. Auf diese Weise lassen sich Daten verschiedener Quellen effizient kombinieren, um umfassendere Analysen durchzuführen.

Syntax von Pandas merge()-Funktion

Python Pandas DataFrame-merge()-Methode kann eine ganze Reihe verschiedener Parameter entgegennehmen, die die Art und Weise der Kombination der zu verbindenden DataFrames beeinflussen. Die allgemeine 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 verschiedenen Parameter, die Pandas merge() entgegennimmt, spezifizieren Sie nicht nur die zu kombinierenden Pandas DataFrames, sondern auch die Art des Joins und weitere Details.

Anwendung von Pandas merge()

Verschiedene Beispiele können dabei helfen, die Vorgehensweise der Pandas merge()-Funktion nachzuvollziehen.

INNER JOIN

Ein INNER JOIN verbindet zwei Pandas DataFrames und gibt nur die Zeilen zurück, bei denen die Schlüssel in beiden DataFrames übereinstimmen. Zunächst werden zwei DataFrames mit Beispieldaten erstellt:

import pandas as pd
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 resultierenden DataFrames sehen folgendermaß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 durchführen, 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üsseln B und C in den Ergebnis-DataFrame aufgenommen werden, da diese in beiden ursprünglichen DataFrames vorhanden sind.

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

OUTER JOIN

Ein OUTER JOIN verbindet ebenfalls zwei DataFrames miteinander. Im Gegensatz zum INNER JOIN werden alle Zeilen zurückgegeben, wobei fehlende Werte mit NaN aufgefü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 DataFrames einbezogen. 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

Verwendung von left_on und right_on

Manchmal haben die beiden DataFrames unterschiedliche Schlüsselspaltennamen. 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 DataFrames 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 DataFrames präsentieren 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 unterschiedlichen Schlüsseln vorzunehmen, werden nun die Parameter left_on und right_on spezifiziert:

# 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 entsprechenden Schlüsselspalten für die Verbindung genutzt.

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

Verwendung von Indizes als Schlüssel

Sie können auch die Indizes der DataFrames als Schlüssel für die Verbindung verwenden, indem Sie die Parameter left_index und right_index auf True setzen. Es werden zunächst zwei neue DataFrames 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 erstellten DataFrames 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 durchgeführt werden:

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

Das Ergebnis ist wenig überraschend ein JOIN basierend auf den Indizes der DataFrames:

Wert1  Wert2
B        2        4
C        3        5