# 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: ```python 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) ``` Hinweis Die Pandas `merge()`-Funktion gleicht der SQL-JOIN-Operation in relationalen Datenbanken. Wenn Sie also bereits mit Datenbanksprachen wie [SQL](https://www.ionos.com/de-ch/digitalguide/server/knowhow/was-ist-sql/) vertraut sind, kann das beim Verständnis von Pandas DataFrame-`merge()`-Methode helfen. Zu beachten ist jedoch, dass das Verhalten stellenweise abweicht: Beinhalten beide der Schlüsselspalten Werte, an denen der Schlüssel zu *null* auswertet, werden diese ebenfalls zusammengeführt. ### Relevante Parameter Mithilfe der verschiedenen Parameter, die Pandas `merge()` entgegennimmt, spezifizieren Sie nicht nur die zu kombinierenden [Pandas DataFrames](https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/python-pandas-dataframe/), sondern auch die Art des Joins und weitere Details.
Parameter Beschreibung Standardwert
`left` Erster DataFrame, der verbunden werden soll
`right` Zweiter DataFrame, der verbunden werden soll
`how` Art der durchzuführenden Join-Operation (`inner`, `outer`, `left` oder `right`) `inner`
`on` Spalte oder Indexebene(n), die als Schlüssel verwendet werden; muss in beiden DataFrames vorhanden sein
`left_on` Spalte oder Indexebene(n) des linken DataFrames, die als Schlüssel verwendet werden
`right_on` Spalte oder Indexebene(n) des rechten DataFrames, die als Schlüssel verwendet werden
`left_index` Wenn `True`, wird Index des linken DataFrames als Schlüssel genutzt `False`
`right_index` Wenn `True`, wird Index des rechten DataFrames als Schlüssel genutzt `False`
`sort` Wenn `True`, werden die resultierenden DataFrame-Schlüssel lexikographisch sortiert. `False`
`suffixes` Suffixes, die genutzt werden, um gleichnamige Spalten eindeutig zu machen `("_x", "_y")`
`copy` Wenn `False`, wird eine Kopie vermieden `True`
## 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: ```python 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 resultierenden DataFrames sehen folgendermaßen aus: ```none 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: ```python # 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. ```none 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. ```python # 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. ```none 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 anderen bekannten `JOIN`-Varianten funktionieren quasi analog. ### 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: ```python 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: ```none 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: ```python # 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. ```none 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: ```python 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: ```none 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: ```python # 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: ```none Wert1 Wert2 B 2 4 C 3 5 ``` This is a markdown version of: [https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/python-pandas-dataframe-merge/](https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/python-pandas-dataframe-merge/) for AI/LLM consumption.