pandas
Samenvoegen, samenvoegen en samenvoegen
Zoeken…
Syntaxis
Dataframe. samenvoegen ( rechts, how = 'inner', on = None, left_on = None, right_on = None, left_index = False, right_index = False, sort = False, suffixes = ('_ x', '_y'), copy = True, indicator = niet waar )
DataFrame-objecten samenvoegen door een joinbewerking in databasestijl uit te voeren met kolommen of indexen.
Als u kolommen op kolommen samenvoegt, worden de DataFrame-indexen genegeerd. Als u indexen op indexen of indexen op een kolom of kolommen samenvoegt, wordt de index doorgegeven.
parameters
| parameters | Uitleg |
|---|---|
| Rechtsaf | dataframe |
| hoe | {'left', 'right', 'outer', 'inner'}, standaard 'inner' |
| left_on | label of lijst, of matrixachtig. Veldnamen om mee te doen in het linker DataFrame. Dit kan een vector of een lijst met vectoren met de lengte van het DataFrame zijn om een bepaalde vector te gebruiken als de toetssleutel in plaats van kolommen |
| right_on | label of lijst, of matrixachtig. Veldnamen om mee te werken in het rechter DataFrame of vector / lijst met vectoren per left_on docs |
| left_index | boolean, standaard False. Gebruik de index van het linker DataFrame als de toetssleutel (s). Als het een MultiIndex is, moet het aantal sleutels in het andere DataFrame (de index of een aantal kolommen) overeenkomen met het aantal niveaus |
| right_index | boolean, standaard False. Gebruik de index van het juiste DataFrame als de toetssleutel. Dezelfde kanttekeningen als left_index |
| soort | boolean, standaard Fals. Sorteer de toetssleutels lexicografisch in het resultaat DataFrame |
| achtervoegsels | Reeks van 2 lengtes (tuple, lijst, ...). Achtervoegsel voor respectievelijk overlappende kolomnamen aan de linker- en rechterkant |
| kopiëren | boolean, standaard True. Als het niet waar is, kopieer dan niet onnodig gegevens |
| indicator | boolean of string, standaard False. Indien True, voegt een kolom toe aan output DataFrame met de naam "_merge" met informatie over de bron van elke rij. Als string, wordt kolom met informatie over de bron van elke rij toegevoegd aan output DataFrame en krijgt kolom de naam stringwaarde. De kolom Informatie is van het categorische type en neemt de waarde 'left_only' aan voor observaties waarvan de samenvoegcode alleen wordt weergegeven in 'left' DataFrame, 'right_only' voor observaties waarvan de samenvoegsleutel alleen wordt weergegeven in 'right' DataFrame, en 'beide' als de de samenvoegsleutel van observatie is in beide te vinden. |
Samenvoegen
Er worden bijvoorbeeld twee tabellen gegeven,
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
Het doel is om de nieuwe tafel T3 te krijgen:
id x y s1 s2 s3
8 42 1.9 55 56 58
9 30 1.9 57 58 60
Dat is om kolommen s1 , s2 en s3 , die elk overeenkomen met een rij (het aantal rijen per id is altijd vast en gelijk aan 3)
Door join passen (waarvoor een optioneel argument nodig is dat een kolom of meerdere kolomnamen kan zijn, wat aangeeft dat het doorgegeven DataFrame moet worden uitgelijnd op die kolom in het DataFrame). Dus de oplossing kan zijn zoals hieronder getoond:
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
Als ik ze scheid:
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
Twee DataFrames samenvoegen
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
Innerlijke join:
Gebruikt het snijpunt van sleutels uit twee 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
U kunt ook het snijpunt van sleutels van twee dataframes opgeven.
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
Buitenste join:
Gebruikt de unie van de sleutels van twee 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
Linker join:
Gebruikt alleen sleutels van het linker 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 meedoen
Gebruikt alleen sleutels van het juiste 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
Meerdere dataframes samenvoegen / samenvoegen / samenvoegen (horizontaal en verticaal)
voorbeeldframes genereren:
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
gegevensframes [df1, df2, df3] verticaal samenvoegen / samenvoegen / samenvoegen - rijen toevoegen
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
gegevensframes horizontaal samenvoegen / samenvoegen / samenvoegen (uitlijnen op 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
Samenvoegen, meedoen en samenvoegen
Het samenvoegen van sleutelnamen is hetzelfde
pd.merge(df1, df2, on='key')
Het samenvoegen van sleutelnamen is anders
pd.merge(df1, df2, left_on='l_key', right_on='r_key')
Verschillende soorten verbindingen
pd.merge(df1, df2, on='key', how='left')
Meerdere toetsen samenvoegen
pd.merge(df1, df2, on=['key1', 'key2'])
Behandeling van overlappende kolommen
pd.merge(df1, df2, on='key', suffixes=('_left', '_right'))
Rijindex gebruiken in plaats van sleutels samenvoegen
pd.merge(df1, df2, right_index=True, left_index=True)
Vermijd het gebruik van .join syntaxis omdat dit een uitzondering vormt voor overlappende kolommen
Samenvoegen van linker dataframe-index en rechter dataframe-kolom
pd.merge(df1, df2, right_index=True, left_on='l_key')
Beknopte dataframes
Verticaal gelijmd
pd.concat([df1, df2, df3], axis=0)
Horizontaal gelijmd
pd.concat([df1, df2, df3], axis=1)
Wat is het verschil tussen samenvoegen en samenvoegen
Beschouw de dataframes left en 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
Beschouw join als willen combineren met dataframes op basis van hun respectieve indexen. Als er overlappende kolommen zijn, wil join dat u een achtervoegsel toevoegt aan de overlappende kolomnaam uit het linker dataframe. Onze twee dataframes hebben een overlappende kolomnaam A
left.join(right, lsuffix='_')
A_ B A C
X a 1 a 3
Y b 2 b 4
Merk op dat de index behouden blijft en we 4 kolommen hebben. 2 kolommen van left en 2 van right .
Als de indexen niet zijn uitgelijnd
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
Ik gebruikte een buitenste voeg om het punt beter te illustreren. Als de indexen niet zijn uitgelijnd, is het resultaat de unie van de indexen.
We kunnen join vertellen om een specifieke kolom in het linker dataframe te gebruiken om als de join-sleutel te gebruiken, maar het zal nog steeds de index van rechts gebruiken.
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
Zie merge als uitlijnen op kolommen. Standaard zal merge zoeken naar overlappende kolommen waarin kan worden samengevoegd. merge geeft betere controle over samenvoegtoetsen door de gebruiker in staat te stellen een subset van de overlappende kolommen te specificeren om te gebruiken met parameter on , of om afzonderlijk de specificatie toe te staan welke kolommen aan de linkerkant en welke kolommen aan de rechterkant samenvoegen.
merge retourneert een gecombineerd dataframe waarin de index wordt vernietigd.
Dit eenvoudige voorbeeld vindt de overlappende kolom 'A' en combineert op basis daarvan.
left.merge(right)
A B C
0 a 1 3
1 b 2 4
Merk op dat de index [0, 1] en niet langer ['X', 'Y']
U kunt expliciet aangeven dat u samenvoegt op de index met de left_index of right_index paramter
left.merge(right, left_index=True, right_index=True, suffixes=['_', ''])
A_ B A C
X a 1 a 3
Y b 2 b 4
En dit lijkt precies op het join voorbeeld hierboven.