Différence(s) entre merge() et concat() dans pandas

Question

Quelle est la ou les différences essentielles entre pd.DataFrame.merge() y pd.concat() ?

Pour l'instant, voici ce que j'ai trouvé, veuillez commenter si ma compréhension est complète et précise :

• .merge() ne peut utiliser que des colonnes (plus des indices de ligne) et convient sémantiquement aux opérations de type base de données. .concat() peut être utilisé avec l'un ou l'autre axe, en utilisant uniquement les indices, et donne la possibilité d'ajouter un indice hiérarchique.

• Incidemment, cela permet la redondance suivante : les deux peuvent combiner deux cadres de données en utilisant les indices de lignes.

• pd.DataFrame.join() offre simplement un raccourci pour un sous-ensemble des cas d'utilisation de l'application .merge()

(Pandas est excellent pour répondre à un très large éventail de cas d'utilisation dans l'analyse des données. Il peut être un peu décourageant d'explorer la documentation pour savoir quelle est la meilleure façon d'effectuer une tâche particulière. )

Answer 1

Une différence de très haut niveau est que merge() est utilisé pour combiner deux (ou plusieurs) cadres de données sur la base des valeurs de colonnes communes (des indices peuvent également être utilisés, utilisez la fonction left_index=True et/ou right_index=True ), et concat() est utilisé pour ajouter un (ou plusieurs) cadre(s) de données l'un en dessous de l'autre (ou latéralement, selon que l'option axis est définie sur 0 ou 1).

join() est utilisé pour fusionner 2 cadres de données sur la base de l'index ; au lieu d'utiliser la fonction merge() avec l'option left_index=True nous pouvons utiliser join() .

Par exemple :

df1 = pd.DataFrame({'Key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'], 'data1': range(7)})

df1:
   Key  data1
0   b   0
1   b   1
2   a   2
3   c   3
4   a   4
5   a   5
6   b   6

df2 = pd.DataFrame({'Key': ['a', 'b', 'd'], 'data2': range(3)})

df2:
    Key data2
0   a   0
1   b   1
2   d   2

#Merge
# The 2 dataframes are merged on the basis of values in column "Key" as it is 
# a common column in 2 dataframes

pd.merge(df1, df2)

   Key data1 data2
0   b    0    1
1   b    1    1
2   b    6    1
3   a    2    0
4   a    4    0
5   a    5    0

#Concat
# df2 dataframe is appended at the bottom of df1 

pd.concat([df1, df2])

   Key data1 data2
0   b   0     NaN
1   b   1     NaN
2   a   2     NaN
3   c   3     NaN
4   a   4     NaN
5   a   5     NaN
6   b   6     NaN
0   a   Nan   0
1   b   Nan   1
2   d   Nan   2

Answer 2

À un niveau élevé :

• .concat() empile simplement plusieurs DataFrame ensemble soit verticalement, ou des points horizontaux après alignement sur l'index.
• .merge() aligne d'abord deux DataFrame ' colonne(s) commune(s) sélectionnée(s) ou puis reprendre les colonnes restantes dans les lignes alignées de chaque colonne commune. DataFrame .

Plus précisément, .concat() :

• Est une fonction pandas de haut niveau
• Combine deux ou plusieurs pandas DataFrame verticalement ou horizontalement
• Alignements uniquement sur l'indice lors de la combinaison horizontale
• Des erreurs se produisent lorsque l'un des DataFrame contient un index en double.
• Par défaut, il s'agit d'une jointure externe avec l'option de jointure interne.

Et .merge() :

• Existe à la fois en tant que fonction pandas de haut niveau et en tant que fonction DataFrame (à partir de pandas 1.0)
• Combine exactement deux DataFrame horizontalement
• Aligne l'appel DataFrame avec la ou les colonnes ou l'index de l'autre fichier DataFrame de la ou des colonnes ou de l'index
• Poignées valeurs en double sur les colonnes ou l'index de jonction par en effectuant un produit cartésien
• La valeur par défaut est la jointure interne avec des options pour la gauche, l'extérieur et la droite.

Notez que lorsque vous effectuez pd.merge(left, right) si left a deux lignes contenant les mêmes valeurs des colonnes ou de l'index de jonction, chaque ligne se combinera avec right Le résultat est un produit cartésien. Par contre, si .concat() est utilisé pour combiner des colonnes, nous devons nous assurer qu'aucun index dupliqué n'existe dans l'un ou l'autre des éléments suivants DataFrame .

En pratique :

• Pensez à .concat() d'abord lors de la combinaison de produits homogènes DataFrame tandis que considérer .merge() d'abord lorsqu'il s'agit de combiner des DataFrame .
• Si vous avez besoin de fusionner verticalement, optez pour .concat() . Si vous avez besoin de fusionner horizontalement via des colonnes, utilisez .merge() qui, par défaut, fusionnent sur les colonnes communes.

Référence : Livre de recettes Pandas 1.x

Answer 3

pd.concat prend un Iterable comme argument. Par conséquent, il ne peut pas prendre DataFrame directement comme argument. Aussi Dimension de la DataFrame doit correspondre à l'axe lors de la concaténation.

pd.merge peut prendre DataFrame en tant qu'argument, et est utilisé pour associer deux DataFrame avec les mêmes colonnes ou index, ce qui ne peut pas être fait avec pd.concat car il affichera la colonne répétée dans le DataFrame.

Alors que join peut être utilisé pour joindre deux DataFrame avec des indices différents.

Answer 4

J'essaie actuellement de comprendre la ou les différences essentielles entre pd.DataFrame.merge() y pd.concat() .

Bonne question. La principale différence :

pd.concat fonctionne sur les deux axes.

L'autre différence, c'est que pd.concat a intérieur par défaut y extérieur se joint uniquement, tandis que pd.DataFrame.merge() a gauche , droite , extérieur , intérieur par défaut rejoint.

La troisième autre différence notable est : pd.DataFrame.merge() a l'option de définir les suffixes des colonnes lors de la fusion de colonnes ayant le même nom, tandis que pour pd.concat ce n'est pas possible.

---

Avec pd.concat par défaut, vous êtes en mesure d'empiler des lignes de plusieurs dataframes ( axis=0 ) et lorsque vous définissez le axis=1 alors vous imitez le pd.DataFrame.merge() fonction.

Quelques exemples utiles de pd.concat :

df2=pd.concat([df]*2, ignore_index=True) #double the rows of a dataframe

df2=pd.concat([df, df.iloc[[0]]]) # add first row to the end

df3=pd.concat([df1,df2], join='inner', ignore_index=True) # concat two df's

Answer 5

La principale différence entre la fusion et la concat est que la fusion vous permet d'effectuer une "jointure" plus structurée de tables, alors que l'utilisation de la concat est plus large et moins structurée.

Fusionner

En se référant à la documentation , pd.DataFrame.merge prend droite en tant qu'argument obligatoire, ce qui peut être considéré comme une jointure entre la table de gauche et la table de droite selon une opération de jointure structurée prédéfinie. Notez la définition du paramètre droite .

Paramètres requis

• droite : DataFrame ou série nommée

Paramètres facultatifs

• comment : {'left', 'right', 'outer', 'inner'} default 'inner'
• sur : étiquette ou liste
• left_on : étiquette ou liste, ou tableau
• right_on : étiquette ou liste, ou tableau
• index_gauche : bool, default False
• index_droit : bool, default False
• trier : bool, default False
• suffixes : tuple de (str, str), par défaut ('_x', '_y')
• copie : bool, default True
• indicateur : bool ou str, par défaut False
• valider : str, facultatif

Important : pd.DataFrame.merge exige le droit d'être un pd.DataFrame ou nommé pd.Series objet.

Sortie

• Renvoie à : DataFrame

En outre, si nous vérifions la documentation relative à l'opération de fusion sur pandas, elle est la suivante :

Effectuer une opération de fusion de base de données (SQL) entre deux DataFrame ou Séries en utilisant soit les colonnes comme clés, soit leurs index de ligne.

Concat

Se référer à documentation de pd.concat il faut d'abord noter que le paramètre n'est nommé dans aucune des catégories suivantes table, data_frame, série, matrice etc., mais Objets à la place. En d'autres termes, vous pouvez passer plusieurs "conteneurs de données", qui sont définis comme suit :

Iterable[FrameOrSeriesUnion], Mapping[Optional[Hashable], FrameOrSeriesUnion]

Paramètres requis

• Objets : une séquence ou un mappage d'objets Series ou DataFrame

Paramètres facultatifs

• axe : {0/'index', 1/'colonnes'}, par défaut 0
• rejoindre : {'inner', 'outer'}, par défaut 'outer'.
• ignore_index : bool, default False
• clés : séquence, par défaut None
• niveaux : liste de séquences, par défaut None
• noms : liste, par défaut None
• vérifier_intégrité : bool, default False
• trier : bool, default False
• copie : bool, default True

Sortie

• Renvoie à : objet, type d'objets

Exemple

Code

import pandas as pd

v1 = pd.Series([1, 5, 9, 13])
v2 = pd.Series([10, 100, 1000, 10000])
v3 = pd.Series([0, 1, 2, 3])

df_left = pd.DataFrame({
    "v1": v1,
    "v2": v2,
    "v3": v3
    })
df_right = pd.DataFrame({
    "v4": [5, 5, 5, 5],
    "v5": [3, 2, 1, 0]
    })

df_concat = pd.concat([v1, v2, v3])

# Performing operations on default

merge_result = df_left.merge(df_right, left_index=True, right_index=True)
concat_result = pd.concat([df_left, df_right], sort=False)
print(merge_result)
print('='*20)
print(concat_result)

Sortie du code

   v1     v2  v3  v4  v5
0   1     10   0   5   3
1   5    100   1   5   2
2   9   1000   2   5   1
3  13  10000   3   5   0
====================
     v1       v2   v3   v4   v5
0   1.0     10.0  0.0  NaN  NaN
1   5.0    100.0  1.0  NaN  NaN
2   9.0   1000.0  2.0  NaN  NaN
3  13.0  10000.0  3.0  NaN  NaN
0   NaN      NaN  NaN  5.0  3.0
1   NaN      NaN  NaN  5.0  2.0
2   NaN      NaN  NaN  5.0  1.0

Vous pouvez toutefois obtenir la première sortie (fusion) avec concat en modifiant l'attribut axe paramètre

concat_result = pd.concat([df_left, df_right], sort=False, axis=1)

Observez le comportement suivant,

concat_result = pd.concat([df_left, df_right, df_left, df_right], sort=False)

sorties ;

     v1       v2   v3   v4   v5
0   1.0     10.0  0.0  NaN  NaN
1   5.0    100.0  1.0  NaN  NaN
2   9.0   1000.0  2.0  NaN  NaN
3  13.0  10000.0  3.0  NaN  NaN
0   NaN      NaN  NaN  5.0  3.0
1   NaN      NaN  NaN  5.0  2.0
2   NaN      NaN  NaN  5.0  1.0
3   NaN      NaN  NaN  5.0  0.0
0   1.0     10.0  0.0  NaN  NaN
1   5.0    100.0  1.0  NaN  NaN
2   9.0   1000.0  2.0  NaN  NaN
3  13.0  10000.0  3.0  NaN  NaN
0   NaN      NaN  NaN  5.0  3.0
1   NaN      NaN  NaN  5.0  2.0
2   NaN      NaN  NaN  5.0  1.0
3   NaN      NaN  NaN  5.0  0.0

Vous ne pouvez pas effectuer une opération similaire avec la fusion, car elle ne permet qu'un seul DataFrame ou une seule série nommée.

merge_result = df_left.merge([df_right, df_left, df_right], left_index=True, right_index=True)

sorties ;

TypeError: Can only merge Series or DataFrame objects, a <class 'list'> was passed

Conclusion

Comme vous l'avez peut-être déjà remarqué, les entrées et les sorties peuvent être différentes entre "merge" et "concat".

Comme je l'ai mentionné au début, la toute première (principale) différence est que "merge" effectue une jointure plus structurée avec un ensemble restreint d'objets et de paramètres alors que "concat" effectue une jointure moins stricte/plus large avec un ensemble plus vaste d'objets et de paramètres.

Dans l'ensemble, merge est moins tolérant aux changements/(l'entrée) et "concat" est plus lâche/moins sensible aux changements/(l'entrée). Vous pouvez réaliser la "fusion" en utilisant la "concat", mais l'inverse n'est pas toujours vrai.

L'opération "Fusionner" utilise les colonnes du cadre de données (ou le nom de la colonne). pd.Series ) ou des indices de ligne, et puisqu'il utilise uniquement ces entités, il effectue une fusion horizontale des cadres de données ou des séries, et n'applique pas d'opération verticale en conséquence.

Si vous voulez en voir plus, vous pouvez plonger un peu dans le code source ;

• Code source pour concat
• Code source pour fusionner