pandas
Zusammenführen, verbinden und verketten
Suche…
Syntax
DataFrame. merge ( rechts, wie = 'inner', ein = keine, left_on = keine, right_on = keine, left_index = false, right_index = false, sort = false, Suffixe = ('_ x', '_y') Indikator = False )
Fügen Sie DataFrame-Objekte zusammen, indem Sie einen Join-Vorgang im Datenbankstil nach Spalten oder Indizes ausführen.
Wenn Sie Spalten für Spalten verbinden, werden die DataFrame-Indizes ignoriert. Andernfalls wird der Index weitergegeben, wenn Indizes für Indizes oder Indizes für eine oder mehrere Spalten zusammengefügt werden.
Parameter
| Parameter | Erläuterung |
|---|---|
| Recht | DataFrame |
| Wie | {'left', 'right', 'outer', 'inner'}, Standardeinstellung 'inner' |
| links auf | Beschriftung oder Liste oder Array-like. Feldnamen, an denen der linke DataFrame teilnehmen soll. Kann ein Vektor oder eine Liste von Vektoren der Länge des DataFrame sein, um einen bestimmten Vektor als Verknüpfungsschlüssel anstelle von Spalten zu verwenden |
| direkt am | Beschriftung oder Liste oder Array-like. Feldnamen, an denen im rechten DataFrame oder Vektor / Liste der Vektoren pro left_on docs eine Verbindung hergestellt werden kann |
| left_index | boolean, Standardwert False. Verwenden Sie den Index aus dem linken DataFrame als Verbindungsschlüssel. Wenn es sich um einen MultiIndex handelt, muss die Anzahl der Schlüssel im anderen DataFrame (entweder der Index oder eine Anzahl von Spalten) mit der Anzahl der Ebenen übereinstimmen |
| right_index | boolean, Standardwert False. Verwenden Sie den Index aus dem rechten DataFrame als Verbindungsschlüssel. Gleiche Vorbehalte wie left_index |
| Sortieren | boolean, Standardwert Fals. Sortieren Sie die Join-Schlüssel im Ergebnis-DataFrame lexikographisch |
| Suffixe | Sequenz mit 2 Längen (Tupel, Liste, ...). Suffix für überlappende Spaltennamen auf der linken bzw. rechten Seite |
| Kopieren | boolean, Standardeinstellung True. Bei Falsch kopieren Sie Daten nicht unnötig |
| Indikator | boolean oder string, default False. Bei True wird der Ausgabedatenleiste "_merge" mit einer Spalte mit Informationen zur Quelle jeder Zeile hinzugefügt. Bei einer Zeichenfolge wird eine Spalte mit Informationen zur Quelle jeder Zeile zum Ausgabe-DataFrame hinzugefügt, und die Spalte wird als Wert der Zeichenfolge bezeichnet. Die Informationsspalte ist vom Typ "Kategorisch" und nimmt den Wert "left_only" für Beobachtungen an, deren Zusammenführungsschlüssel nur in "linkem" DataFrame angezeigt wird, "right_only" für Beobachtungen, deren Zusammenführungsschlüssel nur in "rechtem" DataFrame erscheint Der Merge-Schlüssel der Beobachtung wird in beiden gefunden. |
Verschmelzen
Zum Beispiel werden zwei Tabellen angegeben:
T1
id x y
8 42 1.9
9 30 1.9
T2
id signal
8 55
8 56
8 59
9 57
9 58
9 60
Ziel ist es, die neue Tabelle T3 zu erhalten:
id x y s1 s2 s3
8 42 1.9 55 56 58
9 30 1.9 57 58 60
Die Spalten s1 , s2 und s3 erstellen, die jeweils einer Zeile entsprechen (die Anzahl der Zeilen pro id ist immer fest und entspricht 3).
Durch Anwenden von join (für das optional ein Argument erforderlich ist, das eine Spalte oder mehrere Spaltennamen sein kann, das angibt, dass der übergebene DataFrame für diese Spalte in dem DataFrame ausgerichtet werden soll). Die Lösung kann also wie folgt aussehen:
df = df1.merge (df2.groupby ('id') ['signal']. apply (lambda x: x.reset_index (drop = true)). unstack (). reset_index ())
df
Out[63]:
id x y 0 1 2
0 8 42 1.9 55 56 59
1 9 30 1.9 57 58 60
Wenn ich sie trenne:
df2t = df2.groupby('id')['signal'].apply(lambda x: x.reset_index(drop=True)).unstack().reset_index()
df2t
Out[59]:
id 0 1 2
0 8 55 56 59
1 9 57 58 60
df = df1.merge(df2t)
df
Out[61]:
id x y 0 1 2
0 8 42 1.9 55 56 59
1 9 30 1.9 57 58 60
Zusammenführen von zwei DataFrames
In [1]: df1 = pd.DataFrame({'x': [1, 2, 3], 'y': ['a', 'b', 'c']})
In [2]: df2 = pd.DataFrame({'y': ['b', 'c', 'd'], 'z': [4, 5, 6]})
In [3]: df1
Out[3]:
x y
0 1 a
1 2 b
2 3 c
In [4]: df2
Out[4]:
y z
0 b 4
1 c 5
2 d 6
Inner Join:
Verwendet die Schnittmenge von Schlüsseln aus zwei DataFrames.
In [5]: df1.merge(df2) # by default, it does an inner join on the common column(s)
Out[5]:
x y z
0 2 b 4
1 3 c 5
Alternativ können Sie den Schnittpunkt von Schlüsseln aus zwei Dataframes angeben.
In [5]: merged_inner = pd.merge(left=df1, right=df2, left_on='y', right_on='y')
Out[5]:
x y z
0 2 b 4
1 3 c 5
Äußere Verbindung:
Verwendet die Vereinigung der Schlüssel aus zwei DataFrames.
In [6]: df1.merge(df2, how='outer')
Out[6]:
x y z
0 1.0 a NaN
1 2.0 b 4.0
2 3.0 c 5.0
3 NaN d 6.0
Links beitreten:
Verwendet nur Schlüssel vom linken DataFrame.
In [7]: df1.merge(df2, how='left')
Out[7]:
x y z
0 1 a NaN
1 2 b 4.0
2 3 c 5.0
Rechts beitreten
Verwendet nur Schlüssel vom rechten DataFrame.
In [8]: df1.merge(df2, how='right')
Out[8]:
x y z
0 2.0 b 4
1 3.0 c 5
2 NaN d 6
Zusammenführen / Verketten / Verbinden mehrerer Datenrahmen (horizontal und vertikal)
Beispieldatenrahmen generieren:
In [57]: df3 = pd.DataFrame({'col1':[211,212,213], 'col2': [221,222,223]})
In [58]: df1 = pd.DataFrame({'col1':[11,12,13], 'col2': [21,22,23]})
In [59]: df2 = pd.DataFrame({'col1':[111,112,113], 'col2': [121,122,123]})
In [60]: df3 = pd.DataFrame({'col1':[211,212,213], 'col2': [221,222,223]})
In [61]: df1
Out[61]:
col1 col2
0 11 21
1 12 22
2 13 23
In [62]: df2
Out[62]:
col1 col2
0 111 121
1 112 122
2 113 123
In [63]: df3
Out[63]:
col1 col2
0 211 221
1 212 222
2 213 223
Datenrahmen [df1, df2, df3] vertikal zusammenfügen / zusammenfügen / verketten - Zeilen hinzufügen
In [64]: pd.concat([df1,df2,df3], ignore_index=True)
Out[64]:
col1 col2
0 11 21
1 12 22
2 13 23
3 111 121
4 112 122
5 113 123
6 211 221
7 212 222
8 213 223
Datenrahmen horizontal zusammenführen / zusammenfügen / verketten (Ausrichtung nach Index):
In [65]: pd.concat([df1,df2,df3], axis=1)
Out[65]:
col1 col2 col1 col2 col1 col2
0 11 21 111 121 211 221
1 12 22 112 122 212 222
2 13 23 113 123 213 223
Merge, Join und Concat
Das Zusammenführen von Schlüsselnamen ist identisch
pd.merge(df1, df2, on='key')
Das Zusammenführen von Schlüsselnamen ist unterschiedlich
pd.merge(df1, df2, left_on='l_key', right_on='r_key')
Verschiedene Arten der Verbindung
pd.merge(df1, df2, on='key', how='left')
Zusammenführen auf mehreren Schlüsseln
pd.merge(df1, df2, on=['key1', 'key2'])
Behandlung überlappender Säulen
pd.merge(df1, df2, on='key', suffixes=('_left', '_right'))
Zeilenindex verwenden, anstatt Schlüssel zusammenzuführen
pd.merge(df1, df2, right_index=True, left_index=True)
Vermeiden Sie die Verwendung der .join Syntax, da sie eine Ausnahme für überlappende Spalten gibt
Zusammenführen des linken Datenrahmenindex und der rechten Datenrahmenspalte
pd.merge(df1, df2, right_index=True, left_on='l_key')
Datenrahmen zusammenfassen
Vertikal geklebt
pd.concat([df1, df2, df3], axis=0)
Horizontal geklebt
pd.concat([df1, df2, df3], axis=1)
Was ist der Unterschied zwischen Join und Merge?
Betrachten Sie die Datenrahmen left und right
left = pd.DataFrame([['a', 1], ['b', 2]], list('XY'), list('AB'))
left
A B
X a 1
Y b 2
right = pd.DataFrame([['a', 3], ['b', 4]], list('XY'), list('AC'))
right
A C
X a 3
Y b 4
join
Stellen Sie sich den join so vor, als wollten Sie ihn basierend auf den jeweiligen Indizes zu Datenrahmen kombinieren. Wenn überlappende Spalten vorhanden sind, möchten Sie, dass join dem überlappenden Spaltennamen aus dem linken Datenrahmen ein Suffix hinzufügt. Unsere beiden Datenrahmen haben einen überlappenden Spaltennamen A
left.join(right, lsuffix='_')
A_ B A C
X a 1 a 3
Y b 2 b 4
Beachten Sie, dass der Index beibehalten wird und wir 4 Spalten haben. 2 Spalten von left und 2 von right .
Wenn die Indizes nicht übereinstimmen
left.join(right.reset_index(), lsuffix='_', how='outer')
A_ B index A C
0 NaN NaN X a 3.0
1 NaN NaN Y b 4.0
X a 1.0 NaN NaN NaN
Y b 2.0 NaN NaN NaN
Ich habe eine äußere Verbindung verwendet, um den Punkt besser zu veranschaulichen. Wenn die Indizes nicht übereinstimmen, wird das Ergebnis die Vereinigung der Indizes sein.
Wir können join anweisen, eine bestimmte Spalte im linken Datenrahmen als Join-Schlüssel zu verwenden, der Index wird jedoch weiterhin von rechts verwendet.
left.reset_index().join(right, on='index', lsuffix='_')
index A_ B A C
0 X a 1 a 3
1 Y b 2 b 4
merge
Stellen Sie sich die merge als Ausrichtung auf Spalten vor. Bei der merge wird standardmäßig nach überlappenden Spalten gesucht, in denen die Zusammenführung erfolgen soll. merge die merge besser steuern, indem Sie dem Benutzer die Möglichkeit geben, eine Untermenge der überlappenden Spalten anzugeben, die mit dem Parameter on , oder die Angabe, welche Spalten links und welche Spalten rechts zusammengeführt werden sollen.
merge wird ein kombinierter Datenrahmen zurückgegeben, in dem der Index gelöscht wird.
In diesem einfachen Beispiel wird die überlappende Spalte als 'A' und basierend darauf kombiniert.
left.merge(right)
A B C
0 a 1 3
1 b 2 4
Beachten Sie, dass der Index [0, 1] und nicht länger ['X', 'Y']
Sie können explizit angeben, dass Sie den Index mit dem left_index oder right_index zusammenführen
left.merge(right, left_index=True, right_index=True, suffixes=['_', ''])
A_ B A C
X a 1 a 3
Y b 2 b 4
Und das sieht genauso aus wie das join Beispiel oben.