DataFrames in Pandas verbinden Tutorial

Beginne damit, die Bibliothek zu importieren, die du während des gesamten Tutorials verwenden wirst: pandas

import pandas as pd
Bereitgestellt von

Du wirst alle Operationen in diesem Lernprogramm an den Dummy-DataFrames durchführen, die du erstellen wirst. Um einen DataFrame zu erstellen, kannst du ein Python-Wörterbuch verwenden wie:

dummy_data1 = {
        'id': ['1', '2', '3', '4', '5'],
        'Feature1': ['A', 'C', 'E', 'G', 'I'],
        'Feature2': ['B', 'D', 'F', 'H', 'J']}
Bereitgestellt von

Hier sind die Schlüssel des Wörterbuchs dummy_data1 die Spaltennamen, und die Werte in der Liste sind die Daten, die jeder Beobachtung oder Zeile entsprechen. Um dies in einen Pandas DataFrame umzuwandeln, verwendest du die Funktion DataFrame() von Pandas zusammen mit dem Argument columns, um deine Spalten zu benennen:

df1 = pd.DataFrame(dummy_data1, columns = ['id', 'Feature1', 'Feature2'])

df1
Bereitgestellt von

Wie du siehst, hast du jetzt einen DataFrame mit den drei Spalten id, Feature1 und Feature2. Es gibt eine zusätzliche unbenannte Spalte, die Pandas von Haus aus als Zeilenbeschriftung erstellt. Ähnlich wie beim vorherigen DataFrame df1 wirst du zwei weitere DataFrames df2 und df3 erstellen:

dummy_data2 = {
        'id': ['1', '2', '6', '7', '8'],
        'Feature1': ['K', 'M', 'O', 'Q', 'S'],
        'Feature2': ['L', 'N', 'P', 'R', 'T']}
Bereitgestellt von

df2 = pd.DataFrame(dummy_data2, columns = ['id', 'Feature1', 'Feature2'])

df2
Bereitgestellt von

dummy_data3 = {
        'id': ['1', '2', '3', '4', '5', '7', '8', '9', '10', '11'],
        'Feature3': [12, 13, 14, 15, 16, 17, 15, 12, 13, 23]}
Bereitgestellt von

df3 = pd.DataFrame(dummy_data3, columns = ['id', 'Feature3'])

df3
Bereitgestellt von

 concat()

Um die DataFrames entlang der Zeile einfach zu verketten, kannst du die Funktion concat() in Pandas verwenden. Du musst die Namen der DataFrames in einer Liste als Argument an die Funktion concat() übergeben:

df_row = pd.concat([df1, df2])

df_row
Bereitgestellt von

Du kannst sehen, dass die beiden DataFrames df1 und df2 jetzt zu einem einzigen DataFrame df_row entlang der Zeile verkettet sind. Allerdings scheinen die Zeilenbeschriftungen falsch zu sein. Wenn du möchtest, dass die Zeilenbeschriftungen automatisch entsprechend der Verknüpfung angepasst werden, musst du beim Aufruf der Funktion concat() das Argument ignore_index auf True setzen:

df_row_reindex = pd.concat([df1, df2], ignore_index=True)

df_row_reindex
Bereitgestellt von

Jetzt sind die Zeilenbeschriftungen korrekt!

pandas bietet dir auch die Möglichkeit, die DataFrames nach der Verkettung mit einem Schlüssel zu versehen, damit du weißt, welche Daten aus welchem DataFrame stammen. Du kannst das Gleiche erreichen, indem du zusätzliche Argumente übergibst, die die Bezeichnungsnamen der DataFrames in einer Liste angeben. Hier führst du die gleiche Verkettung mit den Schlüsseln x und y für die DataFrames df1 bzw. df2 durch.

frames = [df1,df2]
df_keys = pd.concat(frames, keys=['x', 'y'])

df_keys
Bereitgestellt von

Die Angabe der Schlüssel erleichtert auch das Abrufen von Daten, die zu einem bestimmten DataFrame gehören. Du kannst die Daten des DataFrame df2 mit der Beschriftung y mit der Methode loc abrufen:

df_keys.loc['y']
Bereitgestellt von

Du kannst auch ein Wörterbuch an concat() übergeben. In diesem Fall werden die Wörterbuchschlüssel für das Argument keys verwendet (sofern keine anderen Schlüssel angegeben werden):

pieces = {'x': df1, 'y': df2}

df_piece = pd.concat(pieces)

df_piece
Bereitgestellt von

Es ist zu beachten, dass concat() eine vollständige Kopie der Daten erstellt und die ständige Wiederverwendung dieser Funktion zu einem erheblichen Leistungsverlust führen kann. Wenn du die Operation auf mehrere Datensätze anwenden musst, verwende ein Listenverständnis.

frames = [ process_your_file(f) for f in files ]
result = pd.concat(frames)
Bereitgestellt von

Um DataFrames entlang einer Spalte zu verketten, kannst du den Achsenparameter als 1 angeben:

df_col = pd.concat([df1,df2], axis=1)

df_col
Bereitgestellt von

pandas DataFrames zusammenführen

Ein weiterer allgegenwärtiger Vorgang im Zusammenhang mit DataFrames ist die Zusammenführung. Zwei DataFrames können unterschiedliche Informationen über dieselbe Entität enthalten und durch ein gemeinsames Merkmal/eine gemeinsame Spalte miteinander verbunden sein. Um diese DataFrames zu verbinden, bietet Pandas mehrere Funktionen wie concat(), merge(), join() usw. In diesem Abschnitt übst du die Verwendung der merge()-Funktion von Pandas.

Du kannst die DataFrames df_row (die du durch Verkettung von df1 und df2 entlang der Zeile erstellt hast) und df3 über die gemeinsame Spalte (oder den Schlüssel) id verbinden. Dazu übergibst du die Namen der DataFrames und ein zusätzliches Argument als Name der gemeinsamen Spalte, hier id, an die Funktion merge():

df_merge_col = pd.merge(df_row, df3, on='id')

df_merge_col
Bereitgestellt von

Du kannst feststellen, dass die DataFrames jetzt zu einem einzigen DataFrame zusammengeführt werden, der auf den gemeinsamen Werten in der id-Spalte der beiden DataFrames basiert. In diesem Beispiel war der ID-Wert 1 sowohl bei A, B als auch bei K, L im DataFrame df_row vorhanden, so dass dieser ID-Wert zweimal im endgültigen DataFrame df_merge_col mit dem wiederholten Wert 12 von Feature3 aus dem DataFrame df3 wiederholt wurde.

Es kann vorkommen, dass die Spalten, für die du die DataFrames zusammenführen willst, unterschiedliche Namen haben (anders als in diesem Fall). Für solche Zusammenführungen musst du die Argumente left_on als linken DataFrame-Namen und right_on als rechten DataFrame-Namen angeben, wie :

df_merge_difkey = pd.merge(df_row, df3, left_on='id', right_on='id')

df_merge_difkey
Bereitgestellt von

Du kannst auch Zeilen an einen DataFrame anhängen, indem du eine Reihe oder ein Diktat an die Funktion append() übergibst, die einen neuen DataFrame zurückgibt:

add_row = pd.Series(['10', 'X1', 'X2', 'X3'],
                    index=['id','Feature1', 'Feature2', 'Feature3'])

df_add_row = df_merge_col.append(add_row, ignore_index=True)

df_add_row
Bereitgestellt von

Arten von Pandas Verbinden

In diesem Abschnitt lernst du die verschiedenen Join-Logiken kennen, mit denen du Pandas DataFrames anhand einer gemeinsamen Spalte/eines gemeinsamen Schlüssels zusammenführen kannst. Die Logik, die hinter diesen Verknüpfungen steckt, ist fast dieselbe, die du auch in SQL hast, wenn du Tabellen verknüpfst.

Vollständiger äußerer Join

Der FULL OUTER JOIN kombiniert die Ergebnisse des linken und des rechten Outer Joins. Der verknüpfte DataFrame enthält alle Datensätze aus beiden DataFrames und füllt NaNs für fehlende Übereinstimmungen auf beiden Seiten auf. Du kannst eine vollständige äußere Verknüpfung durchführen, indem du in der Funktion merge() das Argument how als outer angibst:

df_outer = pd.merge(df1, df2, on='id', how='outer')

df_outer
Bereitgestellt von

Du kannst feststellen, dass der resultierende DataFrame alle Einträge aus beiden Tabellen mit NaN-Werten für fehlende Übereinstimmungen auf beiden Seiten enthält. Eine weitere Besonderheit ist das Suffix, das an die Spaltennamen angehängt wurde, um zu zeigen, welche Spalte aus welchem DataFrame stammt. Die Standard-Suffixe sind x und y. Du kannst sie jedoch ändern, indem du das Suffixe-Argument in der Funktion merge() angibst:

df_suffix = pd.merge(df1, df2, left_on='id',right_on='id',how='outer',suffixes=('_left','_right'))

df_suffix
Bereitgestellt von

Innere Verbindung

Der INNER JOIN erzeugt nur die Datensätze, die sowohl in DataFrame A als auch in DataFrame B übereinstimmen. Um den INNER JOIN durchzuführen, musst du Inner im How-Argument der Funktion merge() übergeben:

df_inner = pd.merge(df1, df2, on='id', how='inner')

df_inner
Bereitgestellt von

Rechts Verbinden

Der RIGHT JOIN erzeugt einen vollständigen Satz von Datensätzen aus DataFrame B (rechter DataFrame), mit den übereinstimmenden Datensätzen (sofern vorhanden) in DataFrame A (linker DataFrame). Wenn es keine Übereinstimmung gibt, steht auf der rechten Seite Null. Du musst right im How-Argument der Funktion merge() übergeben, um right join zu machen:

df_right = pd.merge(df1, df2, on='id', how='right')

df_right
Bereitgestellt von

Linke Fuge

Die LINKS-Verknüpfung erzeugt einen vollständigen Satz von Datensätzen aus DataFrame A (linker DataFrame), mit den passenden Datensätzen (sofern vorhanden) in DataFrame B (rechter DataFrame). Wenn es keine Übereinstimmung gibt, steht auf der linken Seite Null. Du musst left im how-Argument der Funktion merge() übergeben, um left join zu machen:

df_left = pd.merge(df1, df2, on='id', how='left')

df_left
Bereitgestellt von

Verbinden auf dem Index

Manchmal musst du die Verknüpfung mit den Indizes oder den Zeilenbeschriftungen durchführen. Dazu musst du right_index (für die Indizes des rechten DataFrame) und left_index (für die Indizes des linken DataFrame) als True angeben:

df_index = pd.merge(df1, df2, right_index=True, left_index=True)

df_index
Bereitgestellt von

Pandas Verbinden

Die Funktion Pandas DataFrame.join wird zum Verbinden von Datenrahmen mit eindeutigen Indizes verwendet. Du kannst das optionale Argument `on` verwenden, um Spaltennamen auf dem Index zu verbinden und wie die Argumente die Operation der beiden Objekte behandeln. Standardmäßig wird die innere Verknüpfung verwendet. 

pandas Join Zwei DataFrames

Lass uns zwei Datenrahmen mit .join verbinden. Wir haben `lsuffix` und `rsuffix` bereitgestellt, um den Spaltenüberschneidungsfehler zu vermeiden. Die Verknüpfung basiert auf dem Index und nicht auf der Spalte, also müssen wir entweder die "id"-Spalte ändern oder ein Suffix hinzufügen.

df2.join(df3, lsuffix='_left', rsuffix='_right')

Wir können auch Spalten mit dem Index verbinden, indem wir das Argument "on" verwenden. Um die Verknüpfung erfolgreich anzuwenden, müssen wir die Spalte "id" in den Index df3 aufnehmen und das Argument "on" mit der Spalte "id" versehen. Standardmäßig wird die linke Verknüpfung verwendet.   

df2.join(df3.set_index('id'), on='id')

Genau wie bei der Merge-Funktion können wir die Funktionsweise von Join ändern, indem wir ein "wie"-Argument angeben. In unserem Fall werden wir eine innere Verknüpfung verwenden. 

df2.join(df3.set_index('id'), on='id', how = "inner")

Zeitreihenfreundlicher Zusammenschluss

Pandas bietet spezielle Funktionen zum Zusammenführen von Zeitreihen-DataFrames. Die vielleicht nützlichste und beliebteste ist die Funktion merge_asof(). merge_asof() ist ähnlich wie ein Ordered Left-Join, nur dass du auf den nächstgelegenen Schlüssel statt auf gleiche Schlüssel abgleichst. Für jede Zeile im linken DataFrame wählst du die letzte Zeile im rechten DataFrame aus, deren On-Schlüssel kleiner ist als der Schlüssel des linken DataFrame. Beide DataFrames müssen nach dem Schlüssel sortiert sein.

Optional kann eine asof-Zusammenführung eine gruppenweise Zusammenführung durchführen. Dies gilt auch für die by-Taste und die nächstgelegene Übereinstimmung mit der on-Taste.

Du hast zum Beispiel Trades und Quotes, die du zusammenführen möchtest. Hier wird der linke DataFrame als Trades und der rechte DataFrame als Quotes gewählt. Sie werden nach der Schlüsselzeit und gruppenweise nach ihrem Tickersymbol zusammengeführt.

trades = pd.DataFrame({
    'time': pd.to_datetime(['20160525 13:30:00.023',
                            '20160525 13:30:00.038',
                            '20160525 13:30:00.048',
                            '20160525 13:30:00.048',
                            '20160525 13:30:00.048']),
    'ticker': ['MSFT', 'MSFT','GOOG', 'GOOG', 'AAPL'],
    'price': [51.95, 51.95,720.77, 720.92, 98.00],
    'quantity': [75, 155,100, 100, 100]},
    columns=['time', 'ticker', 'price', 'quantity'])

quotes = pd.DataFrame({
    'time': pd.to_datetime(['20160525 13:30:00.023',
                            '20160525 13:30:00.023',
                            '20160525 13:30:00.030',
                            '20160525 13:30:00.041',
                            '20160525 13:30:00.048',
                            '20160525 13:30:00.049',
                            '20160525 13:30:00.072',
                            '20160525 13:30:00.075']),
    'ticker': ['GOOG', 'MSFT', 'MSFT','MSFT', 'GOOG', 'AAPL', 'GOOG','MSFT'],
    'bid': [720.50, 51.95, 51.97, 51.99,720.50, 97.99, 720.50, 52.01],
    'ask': [720.93, 51.96, 51.98, 52.00,720.93, 98.01, 720.88, 52.03]},
    columns=['time', 'ticker', 'bid', 'ask'])Bereitgestellt von

trades
Bereitgestellt von

quotes
Bereitgestellt von

df_merge_asof = pd.merge_asof(trades, quotes,
              on='time',
              by='ticker')

df_merge_asof
Bereitgestellt von

Wenn du genau hinsiehst, kannst du den Grund für das NaN in der AAPL-Tickerzeile erkennen. Da die rechten DataFrame-Kurse keinen Zeitwert unter 13:30:00.048 (die Zeit in der linken Tabelle) für den AAPL-Ticker enthielten, wurden NaNs in die Bid- und Ask-Spalten eingefügt.

Du kannst auch eine vordefinierte Toleranzgrenze für die Zeitspalte festlegen. Angenommen, du möchtest, dass asof nur innerhalb von 2 ms zwischen der Kurszeit und der Handelszeit zusammengeführt wird, dann musst du ein Toleranzargument angeben:

df_merge_asof_tolerance = pd.merge_asof(trades, quotes,
              on='time',
              by='ticker',
              tolerance=pd.Timedelta('2ms'))

df_merge_asof_tolerance
Bereitgestellt von

Beachte den Unterschied zwischen dem obigen und dem vorherigen Ergebnis. Die Zeilen werden nicht zusammengeführt, wenn die Zeittoleranz nicht 2ms beträgt.

Fazit

In diesem Lernprogramm hast du gelernt, DataFrames auf der Grundlage verschiedener Logiken mit den Funktionen concat() und merge() der Pandas-Bibliothek zu verketten und zusammenzuführen. Gegen Ende hast du auch die spezielle Funktion merge_asof() zum Zusammenführen von Zeitreihen-DataFrames geübt. Nebenbei hast du auch gelernt, mit den Indizes der DataFrames zu spielen. Es gibt noch weitere Möglichkeiten, DataFrames in Pandas zu verbinden, und ich empfehle dir, einen Blick in die fantastische Dokumentation zu werfen. Viel Spaß beim Erkunden!

Dieses Tutorial wurde mit Hilfe der Pandas-Dokumentation geschrieben.

Wenn du mehr über Pandas erfahren möchtest, besuche den DataCamp-Kurs Pandas Foundations und schau dir unser DataFrames in Python Pandas Tutorial an.

DataCamp bietet außerdem verschiedene andere praktische Pandas-Tutorials an:

• CSV-Daten in Pandas importieren
• Hinzufügen von Spalten in Pandas
• Werte in Pandas sortieren
• Entfernen von Duplikaten in Pandas mit drop_duplicates

Viel Spaß beim Lernen!