Python Pandas : fusionner des DataFrames avec merge()

La fonction Pandas DataFrame.merge() sert à fusionner deux DataFrames en utilisant des clés communes (keys). Cela permet de combiner efficacement des données provenant de différentes sources afin d’effectuer des analyses plus complètes.

Syntaxe de la fonction Pandas merge()

La méthode Python Pandas DataFrame merge() peut prendre en compte toute une série de paramètres différents qui influencent la manière dont les DataFrames sont combinés. La syntaxe générale de la fonction merge() est la suivante :

DataFrame.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)

Paramètres pertinents

En utilisant les différents paramètres que Pandas merge() accepte, vous spécifiez non seulement les Pandas DataFrames à combiner, mais aussi le type de jointure et d’autres détails.

Application de Pandas merge()

Plusieurs exemples peuvent aider à comprendre comment fonctionne la fonction Pandas merge().

INNER JOIN (jointure interne)

SQL INNER JOIN relie deux Pandas DataFrames et ne renvoie que les lignes dont les clés correspondent dans les deux DataFrames. Toutes les autres lignes sont exclues du résultat. Pour cela, deux DataFrames sont créés avec des données d’exemple :

import pandas as pd
# DataFrames d'exemple
df1 = pd.DataFrame({
    'Clé': ['A', 'B', 'C'],
    'Valeur1': [1, 2, 3]
})
df2 = pd.DataFrame({
    'Clé': ['B', 'C', 'D'],
    'Valeur2': [4, 5, 6]
})
print(df1)
print(df2)

Les deux DataFrames résultants se présentent comme suit :

Clé    Valeur1
0     A                1
1     B                2
2     C                3
    Clé    Valeur2
0     B                4
1     C                5
2     D                6

On peut maintenant effectuer un INNER JOIN en utilisant la fonction merge() :

# Jointure interne (INNER JOIN)
result = pd.merge(df1, df2, how='inner', on='Clé')
print(result)

La sortie montre que dans cet exemple, seules les lignes avec les clés B et C sont incluses dans le DataFrame final, car elles sont présentes dans les deux DataFrames d’origine.

Clé    Valeur1    Valeur2
0     B                2                4
1     C                3                5

OUTER JOIN

Un OUTER JOIN fusionne deux DataFrames en conservant toutes les lignes des deux ensembles. Si une clé ne correspond pas dans l’un des DataFrames, les valeurs manquantes sont remplacées par NaN.

# Jointure externe (OUTER JOIN)
résultat = pd.merge(df1, df2, how='outer', on='Clé')
print(résultat)

Comme prévu, le DataFrame issu de la fusion inclut toutes les lignes des deux DataFrames. Pour la clé A, qui n’existe que dans df1, et la clé D, qui n’existe que dans df2, les valeurs manquantes sont insérées comme NaN.

Clé    Valeur1    Valeur2
0     A            1.0            NaN
1     B            2.0            4.0
2     C            3.0            5.0
3     D            NaN            6.0

Utilisation de left_on et right_on

Parfois, les deux DataFrames ont des noms de colonnes clés différents. Dans ce cas, vous pouvez utiliser les paramètres left_on et right_on pour indiquer quelles colonnes doivent être utilisées. Pour ce faire, deux nouveaux DataFrames sont d’abord créés :

import pandas as pd
# Création des DataFrames d'exemple
df3 = pd.DataFrame({
    'Clé': ['A', 'B', 'C'],
    'Valeur1': [1, 2, 3]
})
df4 = pd.DataFrame({
    'Clé2': ['B', 'C', 'D'],
    'Valeur2': [4, 5, 6]
})
print(df3)
print(df4)

Les deux DataFrames se présentent comme suit :

Clé    Valeur1
0     A                1
1     B                2
2     C                3
    Clé2    Valeur2
0        B                4
1        C                5
2        D                6

Pour effectuer l’opération JOIN avec différentes clés, les paramètres left_on et right_on sont maintenant spécifiés :

# Jointure avec des noms de colonnes de clés différents
result = pd.merge(df3, df4, how='inner', left_on='Clé', right_on='Clé2')
print(result)

En utilisant explicitement left_on='Clé' et right_on='Clé2', les colonnes de clés correspondantes sont utilisées pour la connexion.

Clé    Valeur1 Clé2    Valeur2
0    B                2                     B                4
1    C                3                     C                5

Utilisation des index comme clés

Vous pouvez également utiliser les indices des DataFrames comme clés de connexion en définissant les paramètres left_index et right_index à True. Deux nouveaux DataFrames avec des index sont d’abord créés :

df5 = pd.DataFrame({
    'Valeur1': [1, 2, 3]
}, index=['A', 'B', 'C'])
df6 = pd.DataFrame({
    'Valeur2': [4, 5, 6]
}, index=['B', 'C', 'D'])
print(df5)
print(df6)

Les DataFrames créées dans le code ci-dessus sont les suivants :

Valeur1
A          1
B          2
C          3
    Valeur2
B          4
C          5
D          6

Une opération JOIN peut maintenant être effectuée sur la base des index :

# Jointure avec les index
result = pd.merge(df5, df6, how='inner', left_index=True, right_index=True)
print(result)

Sans surprise, le résultat est un JOIN basé sur les index des DataFrames :

Valeur1  Valeur2
B          2          4
C          3          5

La fonction merge() est un outil essentiel pour combiner efficacement des DataFrames en fonction de différentes règles de jointure. Elle s’inspire des jointures SQL et permet une flexibilité optimale pour manipuler des jeux de données en Python.