Python Pandas : fusionner des Da­ta­Frames avec merge()

La fonction Pandas DataFrame.merge() sert à fusionner deux Da­ta­Frames en utilisant des clés communes (keys). Cela permet de combiner ef­fi­ca­ce­ment des données provenant de dif­fé­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 pa­ra­mètres dif­fé­rents qui in­fluen­cent la manière dont les Da­ta­Frames 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)

Pa­ra­mètres per­ti­nents

En utilisant les dif­fé­rents pa­ra­mètres que Pandas merge() accepte, vous spécifiez non seulement les Pandas Da­ta­Frames à combiner, mais aussi le type de jointure et d’autres détails.

Ap­pli­ca­tion de Pandas merge()

Plusieurs exemples peuvent aider à com­prendre comment fonc­tionne la fonction Pandas merge().

INNER JOIN (jointure interne)

SQL INNER JOIN relie deux Pandas Da­ta­Frames et ne renvoie que les lignes dont les clés cor­res­pon­dent dans les deux Da­ta­Frames. Toutes les autres lignes sont exclues du résultat. Pour cela, deux Da­ta­Frames 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 Da­ta­Frames ré­sul­tants se pré­sen­tent 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 main­te­nant 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 Da­ta­Frames d’origine.

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

OUTER JOIN

Un OUTER JOIN fusionne deux Da­ta­Frames en con­ser­vant toutes les lignes des deux ensembles. Si une clé ne cor­res­pond pas dans l’un des Da­ta­Frames, les valeurs man­quantes sont rem­pla­cé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 Da­ta­Frames. Pour la clé A, qui n’existe que dans df1, et la clé D, qui n’existe que dans df2, les valeurs man­quantes 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

Uti­li­sa­tion de left_on et right_on

Parfois, les deux Da­ta­Frames ont des noms de colonnes clés dif­fé­rents. Dans ce cas, vous pouvez utiliser les pa­ra­mètres left_on et right_on pour indiquer quelles colonnes doivent être utilisées. Pour ce faire, deux nouveaux Da­ta­Frames 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 Da­ta­Frames se pré­sen­tent 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 dif­fé­rentes clés, les pa­ra­mètres left_on et right_on sont main­te­nant 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 ex­pli­ci­te­ment left_on='Clé' et right_on='Clé2', les colonnes de clés cor­res­pon­dantes sont utilisées pour la connexion.

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

Uti­li­sa­tion des index comme clés

Vous pouvez également utiliser les indices des Da­ta­Frames comme clés de connexion en dé­fi­nis­sant les pa­ra­mètres left_index et right_index à True. Deux nouveaux Da­ta­Frames 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 Da­ta­Frames 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 main­te­nant ê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 Da­ta­Frames :

Valeur1  Valeur2
B          2          4
C          3          5

La fonction merge() est un outil essentiel pour combiner ef­fi­ca­ce­ment des Da­ta­Frames en fonction de dif­fé­rentes règles de jointure. Elle s’inspire des jointures SQL et permet une flexi­bi­lité optimale pour manipuler des jeux de données en Python.