OUJOOD.COM
Pourquoi fusionner des DataFrames
Les données réelles sont rarement dans un seul tableau. Vous avez souvent un DataFrame de commandes et un autre de clients, un DataFrame de produits et un autre de prix, un DataFrame de résultats et un autre de métadonnées. merge() relie ces tables entre elles en faisant correspondre les valeurs d'une colonne commune — exactement comme un JOIN en SQL.
Fusion de base : inner join
Par défaut, merge() effectue un inner join : il ne conserve que les lignes qui ont une correspondance dans les deux DataFrames. Les lignes sans correspondance sont supprimées.
import pandas as pd
clients = pd.DataFrame({
"id_client": [1, 2, 3, 4],
"nom": ["Alice", "Bob", "Clara", "David"]
})
commandes = pd.DataFrame({
"id_commande": [101, 102, 103, 104],
"id_client": [1, 2, 1, 5], # 5 n'existe pas dans clients
"montant": [89.0, 145.0, 230.0, 67.0]
})
# Inner join : seulement les clients qui ont des commandes ET vice versa
df = pd.merge(clients, commandes, on="id_client")
print(df)
Le client 3 (Clara) n'a aucune commande → il disparaît. La commande 104 référence l'id_client 5 qui n'existe pas → elle disparaît aussi. Seules les lignes avec correspondance dans les deux tables restent. C'est le comportement le plus strict.
Left join et right join
Le left join conserve toutes les lignes du DataFrame de gauche, même sans correspondance à droite. Les colonnes du DataFrame droit sont remplies par NaN pour les lignes sans correspondance.
import pandas as pd
clients = pd.DataFrame({
"id_client": [1, 2, 3, 4],
"nom": ["Alice", "Bob", "Clara", "David"]
})
commandes = pd.DataFrame({
"id_commande": [101, 102, 103, 104],
"id_client": [1, 2, 1, 5],
"montant": [89.0, 145.0, 230.0, 67.0]
})
# Left join : tous les clients, même sans commande
df_left = pd.merge(clients, commandes, on="id_client", how="left")
print(df_left)
# Clara et David apparaissent avec NaN pour id_commande et montant
# Right join : toutes les commandes, même sans client connu
df_right = pd.merge(clients, commandes, on="id_client", how="right")
print(df_right)
# La commande 104 (id_client=5) apparaît avec NaN pour nom
Le left join est le plus utilisé en pratique : vous partez de votre table principale (gauche) et vous enrichissez avec des informations complémentaires (droite), sans perdre aucune ligne de la table principale. Les NaN signalent les lignes sans correspondance — utiles à investiguer.
Outer join : tout conserver
Le outer join (ou full join) conserve toutes les lignes des deux DataFrames, avec NaN là où il n'y a pas de correspondance.
import pandas as pd
clients = pd.DataFrame({
"id_client": [1, 2, 3, 4],
"nom": ["Alice", "Bob", "Clara", "David"]
})
commandes = pd.DataFrame({
"id_commande": [101, 102, 103, 104],
"id_client": [1, 2, 1, 5],
"montant": [89.0, 145.0, 230.0, 67.0]
})
# Outer join : tout garder, NaN là où il n'y a pas de correspondance
df_outer = pd.merge(clients, commandes, on="id_client", how="outer")
print(df_outer)
# Repérer les lignes sans correspondance des deux côtés
sans_commande = df_outer[df_outer["id_commande"].isnull()]
sans_client = df_outer[df_outer["nom"].isnull()]
print("Clients sans commande :", len(sans_commande))
print("Commandes sans client :", len(sans_client))
L'outer join sert souvent à l'audit : combien de lignes n'ont pas de correspondance de chaque côté ? C'est un bon outil de contrôle qualité avant d'intégrer deux sources de données.
Fusionner sur des colonnes avec des noms différents
Les deux DataFrames n'ont pas toujours la même clé de jointure. left_on et right_on permettent de préciser les colonnes correspondantes de chaque côté.
import pandas as pd
clients = pd.DataFrame({
"client_id": [1, 2, 3], # nom différent de l'autre table
"nom": ["Alice", "Bob", "Clara"]
})
commandes = pd.DataFrame({
"order_id": [101, 102, 103],
"id_client": [1, 2, 1], # nom différent de l'autre table
"montant": [89.0, 145.0, 230.0]
})
# Jointure sur des noms de colonnes différents
df = pd.merge(
clients, commandes,
left_on="client_id",
right_on="id_client"
)
print(df)
Quand les deux colonnes ont des noms différents, le résultat contient les deux colonnes. Vous pouvez ensuite supprimer le doublon avec df.drop(columns=["id_client"]) pour ne garder qu'un seul identifiant dans le DataFrame final.
Par carabde | Mis à jour le 26 avril 2026