Skip to content
Comment Fusionner, Joindre et Concaténer les DataFrames Pandas

Comment Fusionner, Joindre et Concaténer les DataFrames Pandas en Python

Fusionner, joindre et concaténer des DataFrames avec pandas sont des techniques importantes qui vous permettent de combiner plusieurs ensembles de données en un seul. Ces techniques sont essentielles pour nettoyer, transformer et analyser les données. Fusionner, joindre et concaténer sont souvent utilisés indifféremment, mais ils font référence à différentes méthodes de combinaison des données. Dans ce post, nous discuterons en détail de ces trois techniques importantes et fournirons des exemples de leur utilisation en Python.

📚

Fusion des DataFrames avec Pandas

La fusion est le processus de combinaison de deux ou plusieurs DataFrames en un seul DataFrame en reliant les lignes en fonction d'une ou plusieurs clés communes. Les clés communes peuvent être une ou plusieurs colonnes ayant des valeurs correspondantes dans les DataFrames fusionnés.

Différents types de fusions

Il existe quatre types de fusions avec pandas: interne, externe, gauche et droite.

  • Fusion Interne: Renvoie uniquement les lignes ayant des valeurs correspondantes dans les deux DataFrames.
  • Fusion Externe: Renvoie toutes les lignes des deux DataFrames et remplit les valeurs manquantes par NaN là où il n'y a pas de correspondance.
  • Fusion Gauche: Renvoie toutes les lignes du DataFrame de gauche et les lignes correspondantes du DataFrame de droite. Remplit les valeurs manquantes par NaN là où il n'y a pas de correspondance.
  • Fusion Droite: Renvoie toutes les lignes du DataFrame de droite et les lignes correspondantes du DataFrame de gauche. Remplit les valeurs manquantes par NaN là où il n'y a pas de correspondance.

Exemples de réalisation de différents types de fusions

Voyons quelques exemples de réalisation de différents types de fusions avec Pandas.

Exemple 1: Fusion Interne

import pandas as pd
 
# Création de deux DataFrames
df1 = pd.DataFrame({'clé': ['A', 'B', 'C', 'D'],
                    'valeur': [1, 2, 3, 4]})
df2 = pd.DataFrame({'clé': ['B', 'D', 'E', 'F'],
                    'valeur': [5, 6, 7, 8]})
 
# Fusion interne
fusion_interne = pd.merge(df1, df2, on='clé')
 
print(fusion_interne)

Sortie:

  clé  valeur_x  valeur_y
0   B         2         5
1   D         4         6

Exemple 2: Fusion Externe

import pandas as pd
 
# Création de deux DataFrames
df1 = pd.DataFrame({'clé': ['A', 'B', 'C', 'D'],
                    'valeur': [1, 2, 3, 4]})
df2 = pd.DataFrame({'clé': ['B', 'D', 'E', 'F'],
                    'valeur': [5, 6, 7, 8]})
 
# Fusion externe
fusion_externe = pd.merge(df1, df2, on='clé', how='outer')
 
print(fusion_externe)

Sortie:

  clé  valeur_x  valeur_y
0   A       1.0       NaN
1   B       2.0       5.0
2   C       3.0       NaN
3   D       4.0       6.0
4   E       NaN       7.0
5   F       NaN       8.0

Exemple 3: Fusion Gauche

Une fusion gauche renvoie toutes les lignes du DataFrame de gauche et les lignes correspondantes du DataFrame de droite. Toutes les lignes du DataFrame de gauche qui n'ont pas de correspondance dans le DataFrame de droite auront des valeurs NaN dans les colonnes du DataFrame de droite.

import pandas as pd
 
# Création de deux DataFrames
df1 = pd.DataFrame({'clé': ['A', 'B', 'C', 'D'], 'valeur': [1, 2, 3, 4]})
df2 = pd.DataFrame({'clé': ['B', 'D', 'E'], 'valeur': [5, 6, 7]})
 
# Réaliser une fusion gauche
fusion_gauche = pd.merge(df1, df2, on='clé', how='left')
 
# Afficher le DataFrame fusionné
print(fusion_gauche)

Sortie:

  clé  valeur_x  valeur_y
0   A         1       NaN
1   B         2       5.0
2   C         3       NaN
3   D         4       6.0

Exemple 4: Fusion Droite

Une fusion droite renvoie toutes les lignes du DataFrame de droite et les lignes correspondantes du DataFrame de gauche. Toutes les lignes du DataFrame de droite qui n'ont pas de correspondance dans le DataFrame de gauche auront des valeurs NaN dans les colonnes du DataFrame de gauche.

import pandas as pd
 
# Création de deux DataFrames
df1 = pd.DataFrame({'clé': ['A', 'B', 'C'], 'valeur': [1, 2, 3]})
df2 = pd.DataFrame({'clé': ['B', 'D', 'E'], 'valeur': [5, 6, 7]})
 
# Réaliser une fusion droite
fusion_droite = pd.merge(df1, df2, on='clé', how='right')
 
# Afficher le DataFrame fusionné
print(fusion_droite)

Sortie:

  clé  valeur_x  valeur_y
0   B       2.0         5
1   D       NaN         6
2   E       NaN         7

Joindre des DataFrames avec pandas

Joindre est une méthode de combinaison de deux DataFrames en un seul en fonction de leurs index ou de leurs valeurs de colonne.

Il existe quatre types de jointures avec pandas: interne, externe, gauche et droite.

  • Jointure Interne: Renvoie uniquement les lignes ayant des index ou des valeurs de colonne correspondantes dans les deux DataFrames.
  • Jointure Externe: Renvoie toutes les lignes des deux DataFrames et remplit les valeurs manquantes par NaN là où il n'y a pas de correspondance.
  • Jointure Gauche: Renvoie toutes les lignes du DataFrame de gauche et les lignes correspondantes du DataFrame de droite. Remplit les valeurs manquantes par NaN là où il n'y a pas de correspondance.
  • Jointure Droite: Renvoie toutes les lignes du DataFrame de droite et les lignes correspondantes du DataFrame de gauche. Remplit les valeurs manquantes par NaN là où il n'y a pas de correspondance.

Concaténer des DataFrames avec pandas

La concaténation est le processus de jointure de deux ou plusieurs DataFrames soit verticalement, soit horizontalement. Avec pandas, cela peut être réalisé en utilisant la fonction concat(). La fonction concat() vous permet de combiner deux ou plusieurs DataFrames en un seul DataFrame en les empilant soit verticalement, soit horizontalement.

Exemples de concaténation de deux ou plusieurs DataFrames en utilisant pandas

Pour concaténer deux DataFrames ou plus verticalement, vous pouvez utiliser le code suivant :

import pandas as pd
 
# Créer deux DataFrames d'exemple
df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
                    'B': ['B0', 'B1', 'B2', 'B3'],
                    'C': ['C0', 'C1', 'C2', 'C3'],
                    'D': ['D0', 'D1', 'D2', 'D3']})
 
df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
                    'B': ['B4', 'B5', 'B6', 'B7'],
                    'C': ['C4', 'C5', 'C6', 'C7'],
                    'D': ['D4', 'D5', 'D6', 'D7']})
 
# Concaténer les DataFrames verticalement
result = pd.concat([df1, df2])
 
print(result)

Sortie :

    A   B   C   D
0  A0  B0  C0  D0
1  A1  B1  C1  D1
2  A2  B2  C2  D2
3  A3  B3  C3  D3
0  A4  B4  C4  D4
1  A5  B5  C5  D5
2  A6  B6  C6  D6
3  A7  B7  C7  D7

Pour concaténer deux DataFrames ou plus horizontalement, vous pouvez utiliser le code suivant :

import pandas as pd
 
# Créer deux DataFrames d'exemple
df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
                    'B': ['B0', 'B1', 'B2', 'B3'],
                    'C': ['C0', 'C1', 'C2', 'C3'],
                    'D': ['D0', 'D1', 'D2', 'D3']})
 
df2 = pd.DataFrame({'E': ['E0', 'E1', 'E2', 'E3'],
                    'F': ['F0', 'F1', 'F2', 'F3'],
                    'G': ['G0', 'G1', 'G2', 'G3'],
                    'H': ['H0', 'H1', 'H2', 'H3']})
 
# Concaténer les DataFrames horizontalement
result = pd.concat([df1, df2], axis=1)
 
print(result)

Sortie :

    A   B   C   D   E   F   G   H
0  A0  B0  C0  D0  E0  F0  G0  H0
1  A1  B1  C1  D1  E1  F1  G1  H1
2  A2  B2  C2  D2  E2  F2  G2  H2
3  A3  B3  C3  D3  E3  F3  G3  H3

Créer une vue de concaténation pour les DataFrames Pandas

Pour créer des vues de concaténation au sein de Python, il existe une bibliothèque open-source d'analyse de données et de visualisation de données qui peut vous aider : PyGWalker.

PyGWalker peut simplifier votre flux de travail d'analyse de données et de visualisation de données dans Jupyter Notebook. Vous pouvez visualiser votre DataFrame Pandas avec une interface conviviale ! Vous pouvez simplement créer une vue de concaténation en faisant glisser et déposer des variables.

Pour en savoir plus sur PyGWalker, vous pouvez consulter la page GitHub de PyGWalker (opens in a new tab) et lire l'article Towards Data Science (opens in a new tab) à son sujet.

N'oubliez pas de consulter également l'outil d'analyse de données automatisé avancé et alimenté par l'IA : RATH (opens in a new tab). RATH est également open-source et son code source est disponible sur GitHub (opens in a new tab).

FAQ

Comment puis-je joindre deux DataFrames en utilisant PySpark ?

PySpark est un framework de traitement de données open-source pour le big data qui vous permet d'écrire des applications de traitement de données en Python, Java, Scala ou R. Pour joindre deux DataFrames en utilisant PySpark, vous pouvez utiliser la méthode join(), qui prend deux objets DataFrame et une expression de jointure facultative. Vous pouvez spécifier le type de jointure en utilisant le paramètre how.

Comment puis-je fusionner deux DataFrames en utilisant R ?

Pour fusionner deux DataFrames en utilisant R, vous pouvez utiliser la fonction merge(), qui prend deux data frames et un ensemble d'arguments facultatifs qui spécifient comment les données doivent être fusionnées.

Comment puis-je ajouter deux DataFrames ou plus en utilisant pandas ?

Pour ajouter deux DataFrames ou plus en utilisant pandas, vous pouvez utiliser la fonction concat(), qui prend une liste de DataFrames et un paramètre axis facultatif qui spécifie l'axe le long duquel les DataFrames doivent être concaténés.

Comment puis-je joindre deux DataFrames sur une colonne commune en utilisant pandas ?

Pour joindre deux DataFrames sur une colonne commune en utilisant pandas, vous pouvez utiliser la fonction merge(), qui prend deux DataFrames et un ensemble d'arguments facultatifs qui spécifient comment les données doivent être fusionnées. Vous pouvez spécifier la colonne à joindre en utilisant le paramètre on.

Conclusion

En conclusion, la fusion, la jointure et la concaténation de DataFrames sont des opérations essentielles en analyse de données. Grâce à des outils puissants tels que pandas, PySpark et R, ces opérations peuvent être effectuées facilement et efficacement. Que vous traitiez de grands ensembles de données ou de petits ensembles de données, ces outils offrent des moyens flexibles et intuitifs pour manipuler vos données.

📚