pandas
Unisci, unisciti e concatena
Ricerca…
Sintassi
Dataframe. unire (a destra, come = 'inner', on = None, left_on = None, right_on = None, left_index = False, right_index = False, sort = False, suffixes = ('_ x', '_y'), copy = True, indicatore = Falso )
Unisci oggetti DataFrame eseguendo un'operazione di join in stile database per colonne o indici.
Se si uniscono colonne su colonne, gli indici DataFrame verranno ignorati. Altrimenti, se si uniscono indici su indici o indici su una colonna o colonne, l'indice verrà passato.
Parametri
| parametri | Spiegazione |
|---|---|
| destra | dataframe |
| Come | {'left', 'right', 'outer', 'inner'}, default 'inner' |
| lasciato acceso | etichetta o lista, o array-like. Nomi dei campi per unirsi in DataFrame a sinistra. Può essere un vettore o un elenco di vettori della lunghezza di DataFrame per utilizzare un vettore particolare come chiave di join anziché colonne |
| right_on | etichetta o lista, o array-like. Nomi dei campi per unirmi a destra in DataFrame o in un vettore / elenco di vettori per left_on docs |
| left_index | booleano, predefinito False. Utilizzare l'indice da sinistra DataFrame come chiave di join. Se è un MultiIndex, il numero di chiavi nell'altro DataFrame (l'indice o un numero di colonne) deve corrispondere al numero di livelli |
| right_index | booleano, predefinito False. Utilizzare l'indice dal DataFrame corretto come chiave di join. Gli stessi avvertimenti di left_index |
| ordinare | booleano, predefinito Fals. Ordinare le chiavi di join lessicograficamente nel risultato DataFrame |
| suffissi | Sequenza di 2 lunghezze (tupla, lista, ...). Suffisso da applicare ai nomi di colonne sovrapposte rispettivamente sul lato sinistro e destro |
| copia | booleano, predefinito True. Se False, non copiare i dati inutilmente |
| indicatore | booleano o stringa, predefinito False. Se True, aggiunge una colonna per emettere DataFrame chiamato "_merge" con informazioni sull'origine di ogni riga. Se stringa, la colonna con le informazioni sull'origine di ogni riga verrà aggiunta all'output DataFrame e la colonna verrà denominata con il valore di stringa. La colonna Informazioni è di tipo Categoriale e assume un valore di "left_only" per le osservazioni la cui chiave di unione viene visualizzata solo in "Data" di sinistra, "right_only" per le osservazioni la cui chiave di unione viene visualizzata solo in "Data" DataFrame e "entrambi" se la la chiave di fusione dell'osservazione si trova in entrambi. |
fondersi
Ad esempio, vengono date due tabelle,
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
L'obiettivo è ottenere la nuova tabella T3:
id x y s1 s2 s3
8 42 1.9 55 56 58
9 30 1.9 57 58 60
Che è quello di creare colonne s1 , s2 e s3 , ciascuna corrispondente a una riga (il numero di righe per id è sempre fisso e uguale a 3)
Applicando join (che accetta un argomento opzionale che può essere una colonna o più nomi di colonne, che specifica che il DataFrame passato deve essere allineato su quella colonna in DataFrame). Quindi la soluzione può essere come mostrato di seguito:
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
Se li separo:
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
Unione di due 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
Join interno:
Utilizza l'intersezione di chiavi da due 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
In alternativa, specificare l'intersezione di chiavi da due 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
Join esterno:
Utilizza l'unione delle chiavi da due 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
Unire a sinistra:
Utilizza solo le chiavi da DataFrame sinistro.
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
Giusto Iscriviti
Utilizza solo le chiavi dal giusto 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
Unione / concatenazione / unione di più frame di dati (orizzontalmente e verticalmente)
genera frame di dati di esempio:
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
unire / unire / concatenare i frame di dati [df1, df2, df3] verticalmente - aggiungere righe
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
unione / unione / concatenazione di frame di dati orizzontalmente (allineamento per indice):
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
Unisci, Unisci e Concat
L'unione dei nomi delle chiavi è la stessa
pd.merge(df1, df2, on='key')
L'unione dei nomi delle chiavi è diversa
pd.merge(df1, df2, left_on='l_key', right_on='r_key')
Diversi tipi di unione
pd.merge(df1, df2, on='key', how='left')
Unione su più chiavi
pd.merge(df1, df2, on=['key1', 'key2'])
Trattamento di colonne sovrapposte
pd.merge(df1, df2, on='key', suffixes=('_left', '_right'))
Utilizzo dell'indice di riga invece delle chiavi di unione
pd.merge(df1, df2, right_index=True, left_index=True)
Evitare l'uso della sintassi .join in quanto fornisce un'eccezione per le colonne sovrapposte
Fusione sull'indice dataframe sinistro e colonna destra dataframe
pd.merge(df1, df2, right_index=True, left_on='l_key')
Concetti i dati
Incollato verticalmente
pd.concat([df1, df2, df3], axis=0)
Incollato orizzontalmente
pd.concat([df1, df2, df3], axis=1)
Qual è la differenza tra join e merging
Considera i dati a left e a 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
Pensa di join come vuoi combinare ai dataframes in base ai loro rispettivi indici. Se ci sono colonne sovrapposte, join ti consente di aggiungere un suffisso al nome della colonna sovrapposta dal dataframe sinistro. I nostri due dataframe hanno un nome di colonna sovrapposto A
left.join(right, lsuffix='_')
A_ B A C
X a 1 a 3
Y b 2 b 4
Si noti che l'indice è conservato e abbiamo 4 colonne. 2 colonne da left e 2 da right .
Se gli indici non si allineano
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
Ho usato un'unione esterna per illustrare meglio il punto. Se gli indici non si allineano, il risultato sarà l'unione degli indici.
Possiamo dire a join di utilizzare una colonna specifica nel dataframe sinistro da utilizzare come chiave di join, ma continuerà a utilizzare l'indice dalla destra.
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
Pensa a merge come allineato sulle colonne. Per impostazione predefinita, l' merge cerca le colonne sovrapposte su cui fondersi. merge consente un migliore controllo sulle chiavi di unione consentendo all'utente di specificare un sottoinsieme delle colonne sovrapposte da utilizzare con il parametro on o consentire separatamente la specifica di quali colonne a sinistra e di quali colonne sulla destra devono essere unite.
merge restituirà un dataframe combinato in cui l'indice verrà distrutto.
Questo semplice esempio trova la colonna sovrapposta come 'A' e combina in base ad essa.
left.merge(right)
A B C
0 a 1 3
1 b 2 4
Nota che l'indice è [0, 1] e non più ['X', 'Y']
È possibile specificare esplicitamente che si sta unendo l'indice con il parametro left_index o right_index
left.merge(right, left_index=True, right_index=True, suffixes=['_', ''])
A_ B A C
X a 1 a 3
Y b 2 b 4
E questo sembra esattamente come l'esempio di join sopra.