Direkt zum Inhalt

DataFrames in Pandas verbinden Tutorial

In diesem Lernprogramm lernst du verschiedene Möglichkeiten kennen, wie mehrere DataFrames in Python mit der Pandas-Bibliothek zusammengeführt werden können.
Aktualisierte 16. Jan. 2025  · 19 Min. Lesezeit

Hast du schon einmal versucht, eine Kaggle-Herausforderung zu lösen? Wenn ja, ist dir vielleicht aufgefallen, dass bei den meisten Herausforderungen die Daten in mehreren Dateien vorliegen, wobei einige Spalten in mehr als einer Datei vorhanden sind. Was ist das erste, was dir in den Sinn kommt? Schließ dich ihnen natürlich an!

In diesem Lernprogramm übst du einige Standardtechniken für das Zusammenfügen von Pandas. Genauer gesagt, wirst du lernen:

  • DataFrames entlang der Zeilen und Spalten verketten.
  • Führe DataFrames nach bestimmten Schlüsseln mit verschiedenen Join-Logiken wie Left-Join, Inner-Join usw. zusammen.
  • DataFrames nach Index verbinden.
  • Zeitserienfreundliche Zusammenführung in Pandas

Auf dem Weg dorthin lernst du auch ein paar Tricks, die du vor und nach dem Beitritt benötigst.

Pandas verbinden

Das Verbinden und Zusammenführen von DataFrames ist der wichtigste Prozess, um mit der Datenanalyse und maschinellen Lernaufgaben zu beginnen. Es ist eines der Toolkits, die jeder Datenanalyst oder Data Scientist beherrschen sollte, denn in fast allen Fällen stammen die Daten aus mehreren Quellen und Dateien. Möglicherweise musst du alle Daten durch eine Art von Verknüpfungslogik an einem Ort zusammenführen und dann mit der Analyse beginnen. Menschen, die mit SQL-ähnlichen Abfragesprachen arbeiten, wissen vielleicht, wie wichtig diese Aufgabe ist. Auch wenn du einige Modelle für maschinelles Lernen auf Daten aufbauen willst, musst du vielleicht mehrere CSV-Dateien in einem einzigen DataFrame zusammenführen.

Zum Glück gibt es die beliebteste Bibliothek in Python, pandas, die dir hilft! pandas bietet verschiedene Möglichkeiten, Reihen, DataFrames und Panel-Objekte mit verschiedenen Arten von Mengenlogik für die Indizes und relationalen Algebra-Funktionen im Falle von Join-/Merge-Operationen einfach zu kombinieren.

Führe den Code aus diesem Tutorial online aus und bearbeite ihn

Code ausführen

pandas Verkettung

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

import pandas as pd

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']}

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
  id Feature1 Feature2
0 1 A B
1 2 C D
2 3 E F
3 4 G H
4 5 I J

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']}
df2 = pd.DataFrame(dummy_data2, columns = ['id', 'Feature1', 'Feature2'])

df2
  id Feature1 Feature2
0 1 K L
1 2 M N
2 6 O P
3 7 Q R
4 8 S T
dummy_data3 = {
        'id': ['1', '2', '3', '4', '5', '7', '8', '9', '10', '11'],
        'Feature3': [12, 13, 14, 15, 16, 17, 15, 12, 13, 23]}
df3 = pd.DataFrame(dummy_data3, columns = ['id', 'Feature3'])

df3
  id Feature3
0 1 12
1 2 13
2 3 14
3 4 15
4 5 16
5 7 17
6 8 15
7 9 12
8 10 13
9 11 23

 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
  id Feature1 Feature2
0 1 A B
1 2 C D
2 3 E F
3 4 G H
4 5 I J
0 1 K L
1 2 M N
2 6 O P
3 7 Q R
4 8 S T

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
  id Feature1 Feature2
0 1 A B
1 2 C D
2 3 E F
3 4 G H
4 5 I J
5 1 K L
6 2 M N
7 6 O P
8 7 Q R
9 8 S T

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
    id Feature1 Feature2
x 0 1 A B
1 2 C D
2 3 E F
3 4 G H
4 5 I J
y 0 1 K L
1 2 M N
2 6 O P
3 7 Q R
4 8 S T

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']
  id Feature1 Feature2
0 1 K L
1 2 M N
2 6 O P
3 7 Q R
4 8 S T

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
    id Feature1 Feature2
x 0 1 A B
1 2 C D
2 3 E F
3 4 G H
4 5 I J
y 0 1 K L
1 2 M N
2 6 O P
3 7 Q R
4 8 S T

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)

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

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

df_col
  id Feature1 Feature2 id Feature1 Feature2
0 1 A B 1 K L
1 2 C D 2 M N
2 3 E F 6 O P
3 4 G H 7 Q R
4 5 I J 8 S T

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
  id Feature1 Feature2 Feature3
0 1 A B 12
1 1 K L 12
2 2 C D 13
3 2 M N 13
4 3 E F 14
5 4 G H 15
6 5 I J 16
7 7 Q R 17
8 8 S T 15

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
  id Feature1 Feature2 Feature3
0 1 A B 12
1 1 K L 12
2 2 C D 13
3 2 M N 13
4 3 E F 14
5 4 G H 15
6 5 I J 16
7 7 Q R 17
8 8 S T 15

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
  id Feature1 Feature2 Feature3
0 1 A B 12
1 1 K L 12
2 2 C D 13
3 2 M N 13
4 3 E F 14
5 4 G H 15
6 5 I J 16
7 7 Q R 17
8 8 S T 15
9 10 X1 X2 X3

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
  id Feature1_x Feature2_x Merkmal1_y Merkmal2_y
0 1 A B K L
1 2 C D M N
2 3 E F NaN NaN
3 4 G H NaN NaN
4 5 I J NaN NaN
5 6 NaN NaN O P
6 7 NaN NaN Q R
7 8 NaN NaN S T

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
  id Feature1_left Feature2_left Feature1_right Feature2_right
0 1 A B K L
1 2 C D M N
2 3 E F NaN NaN
3 4 G H NaN NaN
4 5 I J NaN NaN
5 6 NaN NaN O P
6 7 NaN NaN Q R
7 8 NaN NaN S T

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
  id Feature1_x Feature2_x Merkmal1_y Merkmal2_y
0 1 A B K L
1 2 C D M N

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
  id Feature1_x Feature2_x Merkmal1_y Merkmal2_y
0 1 A B K L
1 2 C D M N
2 6 NaN NaN O P
3 7 NaN NaN Q R
4 8 NaN NaN S T

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
  id Feature1_x Feature2_x Merkmal1_y Merkmal2_y
0 1 A B K L
1 2 C D M N
2 3 E F NaN NaN
3 4 G H NaN NaN
4 5 I J NaN NaN

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
  id_x Feature1_x Feature2_x id_y Merkmal1_y Merkmal2_y
0 1 A B 1 K L
1 2 C D 2 M N
2 3 E F 6 O P
3 4 G H 7 Q R
4 5 I J 8 S T

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')

  id_left Feature1 Feature2 id_right Feature3
0 1 K L 1 12
1 2 M N 2 13
2 6 O P 3 14
3 7 Q R 4 15
4 8 S T 5 16

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')

  id Feature1 Feature2 Feature3
0 1 K L 12.0
1 2 M N 13.0
2 6 O P NaN
3 7 Q R 17.0
4 8 S T 15.0

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")

  id_left Feature1 Feature2 Feature3
0 1 K L 12
1 2 M N 13
3 7 Q R 17
4 8 S T 15

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'])
trades
  Zeit ticker Preis Menge
0 2016-05-25 13:30:00.023 MSFT 51.95 75
1 2016-05-25 13:30:00.038 MSFT 51.95 155
2 2016-05-25 13:30:00.048 GOOG 720.77 100
3 2016-05-25 13:30:00.048 GOOG 720.92 100
4 2016-05-25 13:30:00.048 AAPL 98.00 100
quotes
  Zeit ticker Angebot frage
0 2016-05-25 13:30:00.023 GOOG 720.50 720.93
1 2016-05-25 13:30:00.023 MSFT 51.95 51.96
2 2016-05-25 13:30:00.030 MSFT 51.97 51.98
3 2016-05-25 13:30:00.041 MSFT 51.99 52.00
4 2016-05-25 13:30:00.048 GOOG 720.50 720.93
5 2016-05-25 13:30:00.049 AAPL 97.99 98.01
6 2016-05-25 13:30:00.072 GOOG 720.50 720.88
7 2016-05-25 13:30:00.075 MSFT 52.01 52.03
df_merge_asof = pd.merge_asof(trades, quotes,
              on='time',
              by='ticker')

df_merge_asof
  Zeit ticker Preis Menge Angebot frage
0 2016-05-25 13:30:00.023 MSFT 51.95 75 51.95 51.96
1 2016-05-25 13:30:00.038 MSFT 51.95 155 51.97 51.98
2 2016-05-25 13:30:00.048 GOOG 720.77 100 720.50 720.93
3 2016-05-25 13:30:00.048 GOOG 720.92 100 720.50 720.93
4 2016-05-25 13:30:00.048 AAPL 98.00 100 NaN NaN

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
  Zeit ticker Preis Menge Angebot frage
0 2016-05-25 13:30:00.023 MSFT 51.95 75 51.95 51.96
1 2016-05-25 13:30:00.038 MSFT 51.95 155 NaN NaN
2 2016-05-25 13:30:00.048 GOOG 720.77 100 720.50 720.93
3 2016-05-25 13:30:00.048 GOOG 720.92 100 720.50 720.93
4 2016-05-25 13:30:00.048 AAPL 98.00 100 NaN NaN

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:

Viel Spaß beim Lernen!

Themen

Erfahre mehr über Python und Pandas

Zertifizierung verfügbar

Kurs

Pandas Joins für Tabellenkalkulationsbenutzer

4 hr
3.6K
Lerne, wie du mit der Python-Bibliothek Pandas effektiv und effizient Datensätze im Tabellenformat zusammenführen kannst.
Siehe DetailsRight Arrow
Kurs starten
Mehr anzeigenRight Arrow