Python

Joindre et fusionner des DataFrames avec pandas

Joignez des DataFrames pandas en toute sécurité avec une cardinalité explicite, le contrôle des clés sans correspondance, des indicateurs et le rapprochement du nombre de lignes.

Par JaviPublié 12 min de lectureIntermédiaire

Deux tables DataFrame jointes par une clé commune en un seul résultat

Les jointures sont l’un des endroits où il est le plus facile de produire des données crédibles mais fausses. Une jointure interne peut supprimer en silence des transactions sans correspondance ; des clés de référence en double peuvent multiplier des montants ; et un merge qui réussit peut malgré tout violer la granularité prévue.

Problème

Vous devez enrichir les commandes avec le nom, le pays et le segment du client. La plupart des identifiants clients correspondent, mais deux lignes de commande utilisent des identifiants absents du fichier clients. Le fichier clients contient aussi un doublon exact, qui peut transformer une relation attendue de plusieurs à un en comportement de plusieurs à plusieurs.

Jeux de données utilisés

Utilisez le Customer Dataset et l’Orders Dataset :

Les imperfections sont volontaires, pour que la jointure produise des éléments qui méritent d’être examinés.

Code : inspecter les clés avant le merge

Python
from pathlib import Path

import pandas as pd

data = Path("data")
customers = pd.read_csv(data / "customers.csv")
orders = pd.read_csv(data / "orders.csv", parse_dates=["order_date"])

print("customer rows:", len(customers))
print("unique customer IDs:", customers["customer_id"].nunique())
print("order rows:", len(orders))

duplicate_customer_keys = customers.loc[
    customers.duplicated(subset=["customer_id"], keep=False)
].sort_values("customer_id")
print(duplicate_customer_keys)
Python16 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.

La ligne client en double doit être résolue avant d’affirmer que le côté clients est unique. Comme il s’agit d’un doublon exact dans ce fichier d’apprentissage, supprimer les doublons exacts est défendable. En production, des versions contradictoires exigent une règle de survie fondée sur des horodatages, la priorité des sources ou la gouvernance.

Code : jointure gauche avec validation de cardinalité

Python
customer_dimension = (
    customers
    .drop_duplicates()
    [["customer_id", "customer_name", "country", "segment"]]
)

enriched_orders = orders.merge(
    customer_dimension,
    on="customer_id",
    how="left",
    validate="many_to_one",
    indicator=True,
)

print(enriched_orders["_merge"].value_counts())
assert len(enriched_orders) == len(orders)
Python16 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.

La jointure gauche conserve toutes les commandes. validate="many_to_one" indique que plusieurs commandes peuvent référencer un même client, tandis que chaque clé client doit apparaître au plus une fois à droite. Si ce contrat n’est pas respecté, pandas lève une erreur au lieu de multiplier les lignes en silence.

Résultat

L’indicateur du merge distingue les lignes avec et sans correspondance :

Valeur de _merge Signification
both L’ID client existe dans les deux DataFrames
left_only La commande est conservée, mais aucun client ne correspond
right_only Possible avec une jointure externe ou droite, pas avec cette jointure gauche

Examinez les exceptions au lieu de renseigner immédiatement les attributs client.

Python
unmatched_orders = enriched_orders.loc[
    enriched_orders["_merge"].eq("left_only"),
    ["order_id", "customer_id", "order_date", "status"],
]

print(unmatched_orders)
Python6 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.

Les identifiants clients sans correspondance sont des références erronées contrôlées. Selon le pipeline, vous pouvez mettre ces commandes en quarantaine, les conserver avec un membre de dimension Unknown ou faire échouer le chargement au-delà d’un seuil de tolérance. Une jointure interne masquerait le problème et réduirait le nombre de commandes.

Explication : choisir la jointure selon la sortie attendue

Utilisez une jointure gauche lorsque toute la population de gauche doit être préservée, par exemple pour conserver chaque commande tout en enrichissant les clients disponibles. Utilisez une jointure interne lorsque seules les paires avec correspondance sont explicitement requises. Une jointure externe est utile pour les rapprochements, car elle expose les clés présentes d’un côté ou de l’autre.

pandas prend aussi en charge les jointures sur des clés de noms différents :

Python
result = orders.merge(
    customer_dimension,
    left_on="customer_id",
    right_on="customer_id",
    how="left",
    validate="many_to_one",
)
Python7 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.

Pour les clés composites, passez des listes à on, left_on et right_on. Vérifiez que les types de données concordent avant le merge. Un identifiant numérique d’un côté et un identifiant textuel de l’autre peuvent provoquer un échec ou une coercition risquée. Conservez les zéros initiaux lorsqu’ils font partie d’un identifiant plutôt que d’un nombre.

Après un merge, rapprochez le nombre de lignes, les clés métier distinctes, le taux de correspondance et les mesures importantes. Le nombre de lignes seul ne suffit pas : une référence en double peut multiplier un sous-ensemble pendant qu’un autre est perdu.

Python
match_rate = enriched_orders["_merge"].eq("both").mean()
print(f"customer match rate: {match_rate:.1%}")
print("distinct orders before:", orders["order_id"].nunique())
print("distinct orders after:", enriched_orders["order_id"].nunique())
Python4 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.

Erreurs fréquentes

  • Utiliser par défaut une jointure interne et écarter en silence les faits sans correspondance.
  • Faire le merge avant de vérifier l’unicité des clés.
  • Omettre validate alors que la cardinalité est connue.
  • Renseigner les champs de dimension manquants avant de mesurer la qualité de la correspondance.
  • Joindre des colonnes aux types incompatibles ou à la normalisation incohérente.
  • Sélectionner toutes les colonnes de droite et créer des suffixes ambigus.
  • Ne vérifier que le nombre final de lignes sans rapprocher les clés ni les mesures.

À vous de jouer

Tentez d’abord le merge de plusieurs à un sans supprimer la ligne client en double et observez l’erreur de validation. Résolvez ensuite uniquement les doublons exacts et relancez-le. Produisez un rapport de deux lignes sur les clients sans correspondance et calculez le pourcentage de correspondance.

Téléchargez ensuite le Products Dataset et enrichissez les commandes avec le nom et la catégorie du produit par une autre jointure gauche de plusieurs à un validée. Trouvez la clé produit volontairement sans correspondance. Enfin, comparez le nombre de lignes de la jointure interne et de la jointure gauche, et expliquez quel résultat est acceptable pour le reporting du chiffre d’affaires et lequel sert à la supervision de la qualité des données. GroupBy et agrégations avec pandas utilise cet enrichissement pour résumer le chiffre d’affaires par catégorie.

Notes de production

Les métriques de jointure méritent une supervision de premier ordre. Enregistrez les lignes de gauche, les lignes de droite, les lignes en sortie, les lignes avec correspondance, les clés sans correspondance de chaque côté et le nombre de clés en double avant l’exécution. Comparez ces valeurs à une plage normale. Un merge qui se termine sans exception peut tout de même révéler une dérive grave en amont si le taux de correspondance passe de 99,9 % à 80 %.

Ne normalisez les clés avant la jointure qu’au moyen d’une règle approuvée. Supprimer les espaces ou harmoniser la casse peut convenir pour des codes, mais peut aussi fusionner des identifiants réellement distincts. Conservez les clés d’origine lorsque vous introduisez des versions normalisées, afin de pouvoir remonter des exceptions jusqu’aux enregistrements sources.

Les grandes jointures peuvent consommer beaucoup de mémoire temporaire. Ne sélectionnez que les colonnes nécessaires, résolvez tôt l’unicité du côté droit et estimez la granularité de la sortie. Si les deux côtés contiennent des clés répétées, calculez la multiplication potentielle avant le merge. Pour les pipelines qui doivent conserver les enregistrements erronés, écrivez les lignes sans correspondance dans une sortie de revue avec l’identifiant d’exécution et le motif, plutôt que de vous contenter de les afficher dans une console éphémère.

Étiquettes

  • Python
  • pandas
  • DataFrames
  • CSV
  • Jeu de données