# 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 : ```python 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) ``` Note La fonction Pandas `merge()` est similaire à l’opération SQL JOIN dans les bases de données relationnelles. Par conséquent, si vous connaissez déjà les langages de base de données tels que [SQL](https://www.ionos.com/fr-be/digitalguide/serveur/know-how/definition-de-sql/), vous aurez peut-être plus de facilités à comprendre le fonctionnement de la méthode Pandas DataFrame `merge()`. Notez cependant que le comportement peut varier : si les deux colonnes de clés contiennent des valeurs nulles, celles-ci seront également fusionnées. ### Paramètres pertinents En utilisant les différents paramètres que Pandas `merge()` accepte, vous spécifiez non seulement les [Pandas DataFrames](https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/python-pandas-dataframe/) à combiner, mais aussi le type de jointure et d’autres détails.
Paramètre Description Valeur par défaut
`left` Premier DataFrame à connecter
`right` Deuxième DataFrame à connecter
`how` Type d’opération de jointure à effectuer (`inner`, `outer`, `left` ou `right`) `inner`
`on` Colonne ou niveau d’index à utiliser comme clé ; doit être présente dans les deux DataFrames
`left_on` Colonne ou niveau d’index du DataFrame de gauche, utilisée comme clé
`right_on` Colonne ou niveau d’index du DataFrame de droite, utilisée comme clé
`left_index` Si `True`, l’index du DataFrame de gauche sera utilisé comme clé `False`
`right_index` Si `True`, l’index du DataFrame de droite sera utilisé comme clé `False`
`sort` Si `True`, les clés de DataFrame résultantes seront triées lexicographiquement. `False`
`suffixes` Suffixes utilisés pour rendre uniques les colonnes de même nom `("_x", "_y")`
`copy` Si `False`, la copie est évitée `True`
`indicator` Ajoute une colonne indiquant la provenance des lignes après fusion (`both`, `left_only`, `right_only`) `False`
## 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 : ```python 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 : ```none 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()` : ```python # 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. ```none 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`. ```python # 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`. ```none 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 ``` Note Toutes les autres variantes connues de `JOIN` fonctionnent quasiment de la même manière. ### 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 : ```python 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 : ```none 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 : ```python # 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. ```none 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 : ```python 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 : ```none 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 : ```python # 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 : ```none 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. This is a markdown version of: [https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/python-pandas-dataframe-merge/](https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/python-pandas-dataframe-merge/) for AI/LLM consumption.