pandas
Slå samman, gå med och sammankoppla
Sök…
Syntax
DataFrame. sammanslagning ( höger, hur = 'inre', på = Ingen, vänster_on = Ingen, höger_on = Ingen, vänster_index = Falsk, höger_index = Falsk, sortera = Falsk, suffikser = ('_ x', '_y'), kopia = Sann, indikator = falsk )
Slå samman DataFrame-objekt genom att utföra en databas-stil gå med i kolumner eller index.
Om du går med i kolumner i kolumner ignoreras DataFrame-indexen. Annars om du går med i index på index eller index i en kolumn eller kolumner kommer indexet att vidarebefordras.
parametrar
| parametrar | Förklaring |
|---|---|
| rätt | DataFrame |
| hur | {'vänster', 'höger', 'yttre', 'inre'}, standard 'inre' |
| kvar på | etikett eller lista eller array-liknande. Fältnamn att gå med i vänster DataFrame. Kan vara en vektor eller lista över vektorer med längden på DataFrame för att använda en viss vektor som kopplingsnyckel istället för kolumner |
| right_on | etikett eller lista eller array-liknande. Fältnamn att gå med i höger DataFrame eller vektor / lista över vektorer per vänster på dokument |
| left_index | boolean, default False. Använd indexet från vänster DataFrame som kopplingsnyckel (er). Om det är en MultiIndex måste antalet nycklar i den andra DataFrame (antingen index eller ett antal kolumner) matcha antalet nivåer |
| right_index | boolean, default False. Använd indexet från höger DataFrame som kopplingsnyckel. Samma varningar som left_index |
| sortera | boolean, standard Fals. Sortera kopplingstangenterna leksikografiskt i resultatet DataFrame |
| suffix | 2-längdssekvens (tupel, lista, ...). Suffix för att tillämpas på överlappande kolumnnamn i vänster respektive höger sida |
| kopia | boolean, default True. Om det är falskt, kopiera inte data onödigt |
| indikator | booleska eller sträng, standard falsk. Om det är sant lägger du till en kolumn för att mata ut DataFrame som heter "_merge" med information om källan för varje rad. Om sträng läggs kolumn med information om källan för varje rad till utgången DataFrame, och kolumnen kommer att namnges strängens värde. Informationskolumnen är kategorisk och tar ett värde på "vänster" för observationer vars sammanslagningsnyckel bara visas i "vänster" DataFrame, "höger_only" för observationer vars sammanslagningsnyckel bara visas i "höger" DataFrame och "båda" om observations sammanslagningsnyckel finns i båda. |
Sammanfoga
Till exempel ges två tabeller,
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
Målet är att få den nya tabellen T3:
id x y s1 s2 s3
8 42 1.9 55 56 58
9 30 1.9 57 58 60
Vilket är att skapa kolumner s1 , s2 och s3 , var och en motsvarar en rad (antalet rader per id är alltid fast och lika med 3)
Genom att tillämpa join (vilket tar ett valfritt argument för argument som kan vara en kolumn eller flera kolumnnamn, som anger att det passerade DataFrame ska anpassas på den kolumnen i DataFrame). Så lösningen kan vara som visas nedan:
df = df1.merge (df2.groupby ('id') ['signal']. applicera (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
Om jag skiljer dem:
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
Slå samman två 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
Inre koppling:
Använder skärningspunkten mellan nycklar från två 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
Alternativt ange skärningspunkten mellan nycklar från två Dataframes.
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
Yttre sammanfogning:
Använder föreningen mellan nycklarna från två 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
Vänster gå med:
Använder bara nycklar från vänster 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
Rätt gå
Använder bara nycklar från höger 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
Sammanfoga / sammanfoga / sammanfoga flera dataramar (horisontellt och vertikalt)
generera exempeldataramar:
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
sammanfoga / gå med / sammanfoga dataramar [df1, df2, df3] vertikalt - lägg till rader
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
sammanfoga / gå med / sammanfoga datoramar horisontellt (justera efter 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
Slå samman, gå med och slå samman
Sammanfogning av nyckelnamn är samma
pd.merge(df1, df2, on='key')
Sammanfogning av nyckelnamn är olika
pd.merge(df1, df2, left_on='l_key', right_on='r_key')
Olika typer av sammanfogningar
pd.merge(df1, df2, on='key', how='left')
Sammanfogning på flera tangenter
pd.merge(df1, df2, on=['key1', 'key2'])
Behandling av överlappande kolumner
pd.merge(df1, df2, on='key', suffixes=('_left', '_right'))
Använd radindex istället för att slå samman tangenter
pd.merge(df1, df2, right_index=True, left_index=True)
Undvik användning av .join syntax eftersom det ger undantag för överlappande kolumner
Sammanfogning på vänster dataframe index och höger dataframe kolumn
pd.merge(df1, df2, right_index=True, left_on='l_key')
Concate dataframes
Limma vertikalt
pd.concat([df1, df2, df3], axis=0)
Limade horisontellt
pd.concat([df1, df2, df3], axis=1)
Vad är skillnaden mellan sammanfogning och sammanslagning
Betrakta dataramarna till left och 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
Tänk på join som att kombinera med dataframe baserat på deras respektive index. Om det finns överlappande kolumner, join vill att du lägger till ett suffix till det överlappande kolumnnamnet från vänster dataframe. Våra två dataframe har ett överlappande kolumnnamn A
left.join(right, lsuffix='_')
A_ B A C
X a 1 a 3
Y b 2 b 4
Observera att indexet bevaras och vi har 4 kolumner. 2 kolumner från left och 2 från right .
Om indexen inte var i linje
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
Jag använde en yttre koppling för att bättre illustrera poängen. Om indexen inte står i linje kommer resultatet att bli indexenas index.
Vi kan säga att join ska använda en specifik kolumn i vänster dataframe för att använda som kopplingsnyckel, men den kommer fortfarande att använda indexet från höger.
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
Tänk på merge som inriktning på kolumner. Som standard kommer merge att leta efter överlappande kolumner där du kan smälta samman. merge ger bättre kontroll över sammanslagningstangenterna genom att låta användaren specificera en delmängd av de överlappande kolumnerna som ska användas med parameter on , eller att separat tillåta specifikationen för vilka kolumner till vänster och vilka kolumner till höger som ska slås samman.
merge kommer att returnera ett kombinerat dataframe där indexet förstörs.
Detta enkla exempel finner att den överlappande kolumnen är 'A' och kombinerar baserat på den.
left.merge(right)
A B C
0 a 1 3
1 b 2 4
Observera att indexet är [0, 1] och inte längre ['X', 'Y']
Du kan uttryckligen ange att du går samman på index med left_index eller right_index parameter
left.merge(right, left_index=True, right_index=True, suffixes=['_', ''])
A_ B A C
X a 1 a 3
Y b 2 b 4
Och det ser ut precis som join exemplet ovan.