pandas
Fusionner, rejoindre et concaténer
Recherche…
Syntaxe
Trame de données. merge ( right, how = 'inner', on = None, left_on = None, right_on = Aucun, left_index = False, right_index = False, sort = False, suffixes = ('_ x', '_y'), copy = True, indicateur = Faux )
Fusionner des objets DataFrame en effectuant une opération de jointure de style base de données par colonnes ou index.
Si vous associez des colonnes sur des colonnes, les index DataFrame seront ignorés. Sinon, si vous joignez des index sur des index ou des index sur une ou plusieurs colonnes, l'index sera transmis.
Paramètres
| Paramètres | Explication |
|---|---|
| droite | Trame de données |
| Comment | {'gauche', 'droite', 'extérieur', 'intérieur'}, défaut 'intérieur' |
| à gauche sur | label ou list, ou tableau-like. Noms de champs sur lesquels se joindre dans DataFrame gauche. Peut être un vecteur ou une liste de vecteurs de la longueur du DataFrame pour utiliser un vecteur particulier comme clé de jointure au lieu de colonnes |
| à droite | label ou list, ou tableau-like. Noms de champs sur lesquels se joindre à droite DataFrame ou vecteur / liste de vecteurs par left_on docs |
| left_index | booléen, par défaut False. Utilisez l'index du DataFrame de gauche comme clé (s) de jointure. S'il s'agit d'un MultiIndex, le nombre de clés dans l'autre DataFrame (l'index ou un nombre de colonnes) doit correspondre au nombre de niveaux. |
| right_index | booléen, par défaut False. Utilisez l'index du bon DataFrame comme clé de jointure. Même mise en garde que left_index |
| Trier | booléen, Fals par défaut. Trier les clés de jointure lexicographiquement dans le résultat DataFrame |
| suffixes | Séquence de 2 longueurs (tuple, liste, ...). Suffixe à appliquer aux noms de colonnes qui se chevauchent respectivement à gauche et à droite |
| copie | booléen, par défaut True. Si la valeur est False, ne copiez pas inutilement des données |
| indicateur | booléen ou chaîne, par défaut False. Si True, ajoute une colonne à la sortie DataFrame appelée «_merge» avec des informations sur la source de chaque ligne. Si chaîne, une colonne avec des informations sur la source de chaque ligne sera ajoutée à la sortie DataFrame, et la colonne sera nommée valeur de la chaîne. La colonne d'information est de type catégorique et prend la valeur «left_only» pour les observations dont la clé de fusion n'apparaît que dans le cadre «left» DataFrame, «right_only» pour les observations dont la clé de fusion n'apparaît que dans «right» DataFrame et «both» si La clé de fusion de l'observation se trouve dans les deux. |
Fusionner
Par exemple, deux tables sont données,
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'objectif est d'obtenir la nouvelle table T3:
id x y s1 s2 s3
8 42 1.9 55 56 58
9 30 1.9 57 58 60
Ce qui consiste à créer les colonnes s1 , s2 et s3 , chacune correspondant à une ligne (le nombre de lignes par id est toujours fixe et égal à 3)
En appliquant la join (qui prend un argument facultatif qui peut être une colonne ou plusieurs noms de colonne, ce qui spécifie que le DataFrame transmis doit être aligné sur cette colonne dans le DataFrame). La solution peut donc être la suivante:
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
Si je les sépare:
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
Fusion de deux 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
Jointure interne:
Utilise l'intersection des clés de deux 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
Vous pouvez également spécifier l'intersection des clés à partir de deux cadres de données.
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
Jointure externe:
Utilise l'union des clés de deux 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
Joint gauche:
Utilise uniquement les clés de gauche 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
Droit rejoindre
Utilise uniquement les clés du droit 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
Fusion / concaténation / jonction de plusieurs blocs de données (horizontalement et verticalement)
générer des exemples de trames de données:
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
fusionner / joindre / concaténer des trames de données [df1, df2, df3] verticalement - ajouter des lignes
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
fusionner / joindre / concaténer des blocs de données horizontalement (alignement par 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
Fusionner, rejoindre et concat
La fusion des noms de clés est la même
pd.merge(df1, df2, on='key')
La fusion des noms de clés est différente
pd.merge(df1, df2, left_on='l_key', right_on='r_key')
Différents types d'adhésion
pd.merge(df1, df2, on='key', how='left')
Fusion sur plusieurs clés
pd.merge(df1, df2, on=['key1', 'key2'])
Traitement des colonnes superposées
pd.merge(df1, df2, on='key', suffixes=('_left', '_right'))
Utilisation de l'index de lignes au lieu de fusionner des clés
pd.merge(df1, df2, right_index=True, left_index=True)
Évitez d'utiliser la syntaxe .join car elle donne une exception pour les colonnes qui se chevauchent
Fusion sur l'index de dataframe gauche et la colonne dataframe droite
pd.merge(df1, df2, right_index=True, left_on='l_key')
Concentrer les dataframes
Collé verticalement
pd.concat([df1, df2, df3], axis=0)
Collé horizontalement
pd.concat([df1, df2, df3], axis=1)
Quelle est la différence entre rejoindre et fusionner
Considérons les données à left et à 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
Pensez à join que de vouloir combiner pour dataframes en fonction de leurs indices respectifs. S'il y a des colonnes qui se chevauchent, join voudra que vous ajoutiez un suffixe au nom de la colonne qui se chevauchent à partir du dataframe gauche. Nos deux cadres de données ont un nom de colonne qui se chevauche A
left.join(right, lsuffix='_')
A_ B A C
X a 1 a 3
Y b 2 b 4
Notez que l'index est conservé et que nous avons 4 colonnes. 2 colonnes de left et 2 de right .
Si les index ne sont pas alignés
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
J'ai utilisé une jointure externe pour mieux illustrer ce point. Si les index ne sont pas alignés, le résultat sera l'union des index.
Nous pouvons dire à join d'utiliser une colonne spécifique dans le dataframe de gauche à utiliser comme clé de jointure, mais elle utilisera toujours l'index depuis la droite.
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
Pensez à merge en alignant sur des colonnes. Par défaut, la merge recherche les colonnes qui se chevauchent dans lesquelles fusionner. merge donne un meilleur contrôle sur les clés de fusion en permettant à l'utilisateur de spécifier un sous - ensemble des colonnes qui se chevauchent à utiliser avec le paramètre on ou pour permettre séparément dont la spécification des colonnes à gauche et les colonnes sur le droit de fusionner par.
merge renverra un dataframe combiné dans lequel l'index sera détruit.
Cet exemple simple recherche la colonne qui se chevauche pour être 'A' et combine en fonction de celle-ci.
left.merge(right)
A B C
0 a 1 3
1 b 2 4
Notez que l'index est [0, 1] et non plus ['X', 'Y']
Vous pouvez spécifier explicitement que vous fusionnez sur l'indice avec le left_index ou 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
Et cela ressemble exactement à l'exemple de join ci-dessus.