Parcourir les aide-mémoire · Python

Technologie: PythonCatégorie: Analyse de donnéesNiveau: IntermédiaireMis à jour

Joindre et fusionner des DataFrames

Joignez des DataFrames pandas en toute sécurité en validant les clés, la cardinalité, le comportement des valeurs nulles, la multiplication due aux doublons et l’évolution du nombre de lignes avant de vous fier au résultat.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Jointure interne
  5. 2. Jointure gauche
  6. 3. Jointure droite
  7. 4. Jointure externe complète
  8. 5. Valider la cardinalité de la jointure
  9. 6. Vérifier l’unicité des clés avant le merge
  10. 7. Joindre sur plusieurs colonnes
  11. 8. Joindre lorsque les noms de clés diffèrent
  12. 9. Inspecter les lignes sans correspondance
  13. 10. Rapprocher les pourcentages de correspondance
  14. 11. Détecter la multiplication des lignes
  15. 12. Comprendre l’expansion plusieurs-à-plusieurs
  16. 13. Protéger les totaux en aval contre une duplication accidentelle
  17. 14. Gérer les noms de colonnes en commun
  18. 15. Ne sélectionner que les colonnes nécessaires avant la jointure
  19. 16. Joindre à l’aide des index
  20. 17. Semi-jointure : conserver les lignes de gauche qui ont une correspondance
  21. 18. Anti-jointure : conserver les lignes de gauche sans correspondance
  22. 19. Joindre avec des clés nulles : comprendre le comportement de pandas
  23. 20. Vérifier la compatibilité des dtypes des clés de jointure
  24. 21. Normaliser les clés de type chaîne avec prudence
  25. 22. Éviter les noms de colonnes en double accidentels avant le merge
  26. 23. Fusionner sur des correspondances temporelles triées avec merge_asof
  27. 24. Faire une jointure croisée intentionnellement
  28. Interpréter le résultat
  29. Points à vérifier
  30. La jointure gauche augmente le nombre de lignes
  31. La jointure interne perd plus de lignes que prévu
  32. Les totaux augmentent après l’enrichissement
  33. De nombreuses lignes sans correspondance
  34. Des colonnes _x et _y apparaissent partout
  35. Des clés nulles correspondent de manière inattendue
  36. Notes de production
  37. Toujours valider la cardinalité attendue
  38. Le rapprochement du nombre de lignes doit être la norme
  39. Rapprocher les mesures importantes
  40. Sélectionner les colonnes avant la jointure
  41. Les jointures plusieurs-à-plusieurs peuvent faire exploser la mémoire
  42. Les jointures pandas s’exécutent en mémoire
  43. Ne pas utiliser le résultat du merge comme substitut aux contrôles de qualité des clés
  44. Erreurs fréquentes
  45. 1. Faire un merge sans vérifier l’unicité des clés
  46. 2. Utiliser many_to_many pour faire passer la validation
  47. 3. Supposer qu’une jointure gauche préserve le nombre de lignes
  48. 4. Supprimer les doublons après un mauvais merge
  49. 5. Joindre sur des clés métier incomplètes
  50. 6. Ignorer les clés de jointure nulles
  51. 7. Compter sur _x et _y
  52. 8. Joindre avant de filtrer ou de projeter
  53. 9. Se fier à des noms de dtype identiques sans vérifier les valeurs
  54. Étape suivante
  55. Pour aller plus loin

Problème

Vous devez combiner deux DataFrames pandas à l’aide d’une ou plusieurs clés métier.

Exemples courants :

  • commandes + clients
  • transactions + métadonnées des commerçants
  • faits + dimensions
  • événements + tables de correspondance
  • données actuelles + données d’enrichissement

La syntaxe est simple.

Le vrai risque est d’obtenir un résultat qui semble valide mais dont le nombre de lignes est faux ou dont les valeurs métier sont dupliquées.

Avant de vous fier à une jointure, vous devez répondre aux questions suivantes :

  • Les clés de jointure sont-elles uniques d’un côté ou de l’autre ?
  • S’agit-il d’une relation un-à-un, un-à-plusieurs, plusieurs-à-un ou plusieurs-à-plusieurs ?
  • Combien de lignes le résultat doit-il contenir ?
  • Les clés nulles se sont-elles comportées comme prévu ?
  • Des clés en double ont-elles multiplié les lignes ?
  • Certaines lignes sources n’ont-elles trouvé aucune correspondance ?
  • Les noms de colonnes en commun ont-ils été traités de façon délibérée ?

Réponse rapide

Utilisez pd.merge() et validez la cardinalité attendue.

result = pd.merge(
    orders,
    customers,
    on="customer_id",
    how="left",
    validate="many_to_one",
)

Rapprochez ensuite le résultat :

print("orders:", len(orders))
print("result:", len(result))

assert len(result) == len(orders)

Si le côté droit doit contenir une ligne par customer_id, validez-le avant le merge :

assert not customers["customer_id"].duplicated().any()

Le réflexe le plus important en production est le suivant :

Ne considérez jamais un merge qui réussit comme la preuve que ce merge est logiquement correct.

Code / commandes

1. Jointure interne

Ne conservez que les clés présentes dans les deux DataFrames.

result = pd.merge(
    left,
    right,
    on="customer_id",
    how="inner",
)

Utilisez-la lorsque les enregistrements sans correspondance doivent être exclus.

Attention : le nombre de lignes peut diminuer.


2. Jointure gauche

Conservez toutes les lignes du DataFrame de gauche.

result = pd.merge(
    orders,
    customers,
    on="customer_id",
    how="left",
)

C’est courant pour l’enrichissement.

Si la clé du côté droit est unique, le nombre de lignes de gauche devrait normalement être préservé.

Validez-le explicitement :

assert len(result) == len(orders)

Si le résultat contient plus de lignes que orders, la clé du côté droit n’était pas unique pour au moins une partie des valeurs ayant une correspondance.


3. Jointure droite

result = pd.merge(
    left,
    right,
    on="customer_id",
    how="right",
)

Utilisez-la lorsque le DataFrame de droite définit la population qui doit être préservée.

Dans la plupart du code de données métier, une jointure gauche est souvent plus facile à raisonner, car le jeu de données principal reste à gauche.


4. Jointure externe complète

result = pd.merge(
    left,
    right,
    on="customer_id",
    how="outer",
)

Utilisez-la pour un rapprochement lorsque vous avez besoin :

  • des lignes avec correspondance
  • des lignes présentes uniquement à gauche
  • des lignes présentes uniquement à droite

Ajoutez un indicateur :

result = pd.merge(
    left,
    right,
    on="customer_id",
    how="outer",
    indicator=True,
)

Inspectez ensuite :

print(result["_merge"].value_counts())

Valeurs possibles :

both
left_only
right_only

C’est l’un des meilleurs modèles pour contrôler la qualité d’une jointure.


5. Valider la cardinalité de la jointure

pandas peut échouer immédiatement lorsque la forme des clés ne correspond pas à ce que vous attendez.

Un-à-un :

result = pd.merge(
    left,
    right,
    on="customer_id",
    how="inner",
    validate="one_to_one",
)

Plusieurs-à-un :

result = pd.merge(
    orders,
    customers,
    on="customer_id",
    how="left",
    validate="many_to_one",
)

Un-à-plusieurs :

result = pd.merge(
    customers,
    orders,
    on="customer_id",
    how="left",
    validate="one_to_many",
)

Plusieurs-à-plusieurs :

result = pd.merge(
    left,
    right,
    on="key",
    how="inner",
    validate="many_to_many",
)

N’utilisez pas many_to_many simplement pour faire disparaître une erreur.

Si une relation plusieurs-à-plusieurs est inattendue, arrêtez-vous et investiguez.


6. Vérifier l’unicité des clés avant le merge

Côté gauche :

print(left["customer_id"].is_unique)

Côté droit :

print(right["customer_id"].is_unique)

Inspecter les doublons :

duplicate_right_keys = right.loc[
    right["customer_id"].duplicated(keep=False)
].sort_values("customer_id")

print(duplicate_right_keys.head(50))

Pour les clés composites :

key_cols = ["merchant_id", "site_id"]

duplicate_keys = right.loc[
    right.duplicated(subset=key_cols, keep=False)
].sort_values(key_cols)

Faites-le avant de décider de la valeur de validate=.


7. Joindre sur plusieurs colonnes

result = pd.merge(
    sales,
    merchant_map,
    on=["merchant_id", "site_id"],
    how="left",
    validate="many_to_one",
)

Utilisez des clés composites lorsqu’une seule colonne ne suffit pas à identifier de manière unique l’entité métier.

Ne simplifiez pas une véritable clé métier composite uniquement pour raccourcir la syntaxe du merge.


8. Joindre lorsque les noms de clés diffèrent

result = pd.merge(
    left,
    right,
    left_on="customer_id",
    right_on="client_id",
    how="left",
    validate="many_to_one",
)

Après avoir validé le résultat, envisagez de supprimer la clé redondante du côté droit :

result = result.drop(columns=["client_id"])

Ne le faites que si les deux colonnes représentent réellement la même clé métier.


9. Inspecter les lignes sans correspondance

Pour une jointure gauche :

result = pd.merge(
    orders,
    customers,
    on="customer_id",
    how="left",
    indicator=True,
    validate="many_to_one",
)

unmatched = result.loc[
    result["_merge"] == "left_only"
]

print(unmatched.head(50))

C’est préférable à la recherche d’une colonne d’enrichissement nulle, car des valeurs légitimes du côté droit peuvent elles-mêmes être nulles.


10. Rapprocher les pourcentages de correspondance

merge_counts = result["_merge"].value_counts()

match_rate = (
    result["_merge"].eq("both").mean() * 100
)

print(merge_counts)
print(f"Match rate: {match_rate:.2f}%")

N’inventez pas de seuil universel de taux de correspondance acceptable.

Le taux attendu dépend du processus métier.


11. Détecter la multiplication des lignes

Avant :

before = len(left)

Merge :

result = pd.merge(
    left,
    right,
    on="customer_id",
    how="left",
)

Après :

after = len(result)

print("Before:", before)
print("After:", after)
print("Added rows:", after - before)

Si une jointure gauche d’enrichissement augmente le nombre de lignes de manière inattendue, inspectez les clés en double du côté droit.


12. Comprendre l’expansion plusieurs-à-plusieurs

Exemple :

left = pd.DataFrame(
    {
        "key": [1, 1],
        "left_value": ["A", "B"],
    }
)

right = pd.DataFrame(
    {
        "key": [1, 1, 1],
        "right_value": ["X", "Y", "Z"],
    }
)

Ce merge :

result = left.merge(
    right,
    on="key",
    how="inner",
)

produit :

2 lignes de gauche × 3 lignes de droite = 6 lignes en résultat

C’est le comportement relationnel correct.

C’est aussi une source fréquente de double comptage accidentel.


13. Protéger les totaux en aval contre une duplication accidentelle

Supposons que ce soit le total initial des commandes :

source_total = orders["amount"].sum()

Après la jointure des données clients :

result = orders.merge(
    customers,
    on="customer_id",
    how="left",
    validate="many_to_one",
)

Rapprochez :

result_total = result["amount"].sum()

assert source_total == result_total

Pour des valeurs monétaires en virgule flottante, une égalité exacte peut être inappropriée selon leur représentation.

Préférez une modélisation sûre en décimal pour les calculs financiers.


14. Gérer les noms de colonnes en commun

Par défaut, pandas ajoute des suffixes tels que _x et _y.

Utilisez des suffixes explicites :

result = pd.merge(
    left,
    right,
    on="customer_id",
    how="left",
    suffixes=("_order", "_customer"),
)

C’est bien plus clair que de laisser des colonnes ambiguës comme :

status_x
status_y

15. Ne sélectionner que les colonnes nécessaires avant la jointure

Au lieu de :

result = orders.merge(
    customers,
    on="customer_id",
    how="left",
)

utilisez :

customer_lookup = customers[
    ["customer_id", "country", "segment"]
]

result = orders.merge(
    customer_lookup,
    on="customer_id",
    how="left",
    validate="many_to_one",
)

Cela réduit :

  • l’utilisation de la mémoire
  • les collisions de noms de colonnes
  • les dépendances accidentelles
  • les déplacements de données inutiles

16. Joindre à l’aide des index

Si les deux DataFrames sont volontairement indexés sur la même clé :

result = left.join(
    right,
    how="left",
)

Ou :

result = left.join(
    right,
    how="left",
    validate="many_to_one",
)

Utilisez .join() lorsque la jointure sur l’index fait réellement partie de la conception du DataFrame.

Ne définissez pas d’index uniquement pour imiter la syntaxe de jointure SQL.


17. Semi-jointure : conserver les lignes de gauche qui ont une correspondance

Appartenance simple à un ensemble de clés :

valid_customer_ids = customers["customer_id"]

matched_orders = orders.loc[
    orders["customer_id"].isin(valid_customer_ids)
]

Pour plusieurs colonnes ou une logique relationnelle plus riche, utilisez plutôt un merge.


18. Anti-jointure : conserver les lignes de gauche sans correspondance

Utilisez indicator=True :

check = orders.merge(
    customers[["customer_id"]],
    on="customer_id",
    how="left",
    indicator=True,
)

unmatched_orders = check.loc[
    check["_merge"] == "left_only"
].drop(columns="_merge")

C’est un modèle utile pour la qualité des données et le rapprochement.


19. Joindre avec des clés nulles : comprendre le comportement de pandas

Le comportement du merge pandas diffère de SQL sur un point important :

Des valeurs de clé nulles peuvent correspondre à d’autres valeurs de clé nulles.

Exemple :

left = pd.DataFrame(
    {
        "id": [1, None],
        "left_value": ["A", "B"],
    }
)

right = pd.DataFrame(
    {
        "id": [1, None],
        "right_value": ["X", "Y"],
    }
)

result = left.merge(
    right,
    on="id",
    how="inner",
)

Les lignes dont les clés de jointure sont nulles peuvent correspondre entre elles.

Si vos règles métier doivent suivre la sémantique des valeurs nulles de SQL, traitez explicitement les clés nulles avant le merge.

Exemple :

left_valid = left.loc[left["id"].notna()]
right_valid = right.loc[right["id"].notna()]

Effectuez ensuite le merge des sous-ensembles aux clés valides selon la logique voulue.


20. Vérifier la compatibilité des dtypes des clés de jointure

Avant le merge :

print(left["customer_id"].dtype)
print(right["customer_id"].dtype)

Normalisez délibérément lorsque c’est nécessaire.

Exemple :

left_key = left["customer_id"].astype("string")
right_key = right["customer_id"].astype("string")

Pendant l’investigation, préférez valider des Series converties plutôt que de modifier les colonnes sources.

Problèmes de clés courants :

  • entier ou chaîne de caractères
  • chaînes complétées par des caractères de remplissage
  • identifiants mêlant valeurs numériques et texte
  • différences de fuseau horaire
  • zéros initiaux

21. Normaliser les clés de type chaîne avec prudence

left_key = (
    left["customer_code"]
    .astype("string")
    .str.strip()
)

right_key = (
    right["customer_code"]
    .astype("string")
    .str.strip()
)

Si la casse n’a pas de signification :

left_key = left_key.str.casefold()
right_key = right_key.str.casefold()

Ne normalisez pas les identifiants à l’aveugle.

Pour certains systèmes :

ABC123
abc123

peuvent être des clés distinctes.


22. Éviter les noms de colonnes en double accidentels avant le merge

Vérifiez :

overlap = (
    set(left.columns)
    & set(right.columns)
    - {"customer_id"}
)

print(overlap)

Si ce recouvrement est inattendu, résolvez-le avant le merge.

Le schéma du résultat sera ainsi plus facile à raisonner.


23. Fusionner sur des correspondances temporelles triées avec merge_asof

Pour les séries temporelles où vous avez besoin de l’enregistrement antérieur ou suivant le plus proche plutôt que d’une égalité exacte des horodatages :

events = events.sort_values("event_time")
prices = prices.sort_values("effective_time")

result = pd.merge_asof(
    events,
    prices,
    left_on="event_time",
    right_on="effective_time",
    direction="backward",
)

Utilisez-le dans des cas tels que :

  • données de référence datées d’effet
  • prix en vigueur au moment de l’événement
  • échantillon de télémétrie antérieur le plus proche

Les deux entrées doivent être triées sur la clé du merge.

Ajoutez by= lorsque la correspondance doit aussi rester au sein d’une même entité :

result = pd.merge_asof(
    events.sort_values(["merchant_id", "event_time"]),
    prices.sort_values(["merchant_id", "effective_time"]),
    left_on="event_time",
    right_on="effective_time",
    by="merchant_id",
    direction="backward",
)

24. Faire une jointure croisée intentionnellement

result = left.merge(
    right,
    how="cross",
)

Une jointure croisée produit :

len(left) × len(right)

lignes.

Ne l’utilisez que lorsque l’expansion cartésienne est explicitement voulue.

N’utilisez jamais une jointure croisée pour contourner l’absence de clés de jointure.

Interpréter le résultat

Concept Signification
inner Ne conserve que les clés avec correspondance.
left Conserve chaque ligne de gauche et y rattache les correspondances de droite.
right Conserve chaque ligne de droite et y rattache les correspondances de gauche.
outer Conserve toutes les clés des deux côtés.
indicator=True Ajoute _merge indiquant left_only, right_only ou both.
validate="one_to_one" Les deux ensembles de clés de jointure doivent être uniques.
validate="one_to_many" Clés de gauche uniques ; celles de droite peuvent se répéter.
validate="many_to_one" Clés de droite uniques ; celles de gauche peuvent se répéter.
validate="many_to_many" Doublons autorisés des deux côtés.
suffixes= Contrôle les noms des colonnes non-clés en commun.
merge_asof() Fait correspondre selon la clé ordonnée la plus proche, généralement des horodatages.

Points à vérifier

La jointure gauche augmente le nombre de lignes

C’est l’un des signaux d’alerte les plus importants.

Si vous attendiez un enrichissement plusieurs-à-un, la clé de jointure du côté droit contient probablement des doublons.

Inspectez :

right.loc[
    right["customer_id"].duplicated(keep=False)
]

La jointure interne perd plus de lignes que prévu

Utilisez une jointure externe ou gauche avec indicator=True pour identifier les clés manquantes.

Causes possibles :

  • données de référence manquantes
  • espaces
  • incompatibilités de types
  • perte des zéros initiaux
  • normalisation incohérente
  • mauvaise clé de jointure

Les totaux augmentent après l’enrichissement

Causes probables :

  • jointure un-à-plusieurs
  • clés de dimension en double
  • granularité métier incorrecte

Ne corrigez pas des totaux gonflés en les regroupant à nouveau tant que vous n’avez pas compris pourquoi ils se sont multipliés.

De nombreuses lignes sans correspondance

Investiguez la qualité des clés avant de supposer que la table de référence est incomplète.

Comparez :

  • les dtypes
  • les valeurs nulles
  • les espaces
  • la casse
  • le formatage
  • la définition de la clé métier

Des colonnes _x et _y apparaissent partout

Cela signifie généralement que le recouvrement de schéma n’a pas été traité délibérément.

Utilisez la sélection de colonnes et des suffixes explicites.

Des clés nulles correspondent de manière inattendue

N’oubliez pas que pandas peut faire correspondre des clés nulles entre elles lors d’un merge.

Si cela n’est pas valide pour votre logique métier, excluez les lignes à clé nulle ou traitez-les séparément.

Notes de production

Toujours valider la cardinalité attendue

validate= est l’une des fonctions de sécurité les plus précieuses des jointures pandas.

Utilisez-le chaque fois que vous connaissez la relation.

Exemple :

validate="many_to_one"

transforme un problème silencieux de qualité des données en exception explicite.

Le rapprochement du nombre de lignes doit être la norme

Pour les jointures d’enrichissement, enregistrez :

before_rows = len(left)
after_rows = len(result)

Comparez ensuite.

Ne laissez aucune variation du nombre de lignes inexpliquée.

Rapprocher les mesures importantes

Pour des données de type faits, comparez les totaux importants avant et après le merge.

Exemples :

  • chiffre d’affaires
  • nombre de transactions
  • nombre de commandes
  • nombre d’événements uniques

Un merge structurellement valide peut tout de même violer des invariants métier.

Sélectionner les colonnes avant la jointure

Les grands DataFrames peuvent dupliquer une quantité importante de mémoire pendant les merges.

Réduisez les deux côtés aux colonnes réellement nécessaires.

Les jointures plusieurs-à-plusieurs peuvent faire exploser la mémoire

Si les deux côtés contiennent des clés en double, le nombre de lignes peut croître rapidement.

Estimez la relation avant de fusionner de grands jeux de données.

Les jointures pandas s’exécutent en mémoire

Pour les grands jeux de données :

  • filtrez tôt
  • projetez les colonnes requises
  • utilisez des dtypes appropriés
  • évitez les relations plusieurs-à-plusieurs accidentelles
  • envisagez de déporter la jointure vers SQL, Spark, DuckDB ou un autre moteur lorsque les données ne tiennent plus confortablement en mémoire

Ne pas utiliser le résultat du merge comme substitut aux contrôles de qualité des clés

Un merge peut réussir même avec :

  • des clés sales
  • des doublons inattendus
  • des lignes sans correspondance
  • des correspondances sur valeurs nulles

La validation doit être explicite.

Erreurs fréquentes

1. Faire un merge sans vérifier l’unicité des clés

C’est la cause principale de la multiplication accidentelle des lignes.

Connaissez d’abord la relation.

2. Utiliser many_to_many pour faire passer la validation

Cela désactive un contrôle de sécurité précieux.

Ne l’utilisez que lorsque la relation plusieurs-à-plusieurs est réellement voulue.

3. Supposer qu’une jointure gauche préserve le nombre de lignes

Une jointure gauche préserve les lignes de gauche sur le plan conceptuel, mais une ligne de gauche peut devenir plusieurs lignes si le côté droit présente plusieurs correspondances.

4. Supprimer les doublons après un mauvais merge

Cela peut masquer le véritable problème de jointure et écarter des lignes valides.

Corrigez plutôt le problème de clé ou de cardinalité.

5. Joindre sur des clés métier incomplètes

Si la vraie clé est :

merchant_id + site_id

joindre uniquement sur :

merchant_id

peut créer des correspondances incorrectes.

6. Ignorer les clés de jointure nulles

La correspondance des valeurs nulles dans pandas peut différer de ce qu’on attend en SQL.

Traitez délibérément la sémantique des clés nulles.

7. Compter sur _x et _y

Une sortie ambiguë rend le code en aval sujet aux erreurs.

Utilisez des suffixes explicites ou présélectionnez les colonnes.

8. Joindre avant de filtrer ou de projeter

Cela peut rendre un grand merge bien plus coûteux que nécessaire.

Réduisez d’abord les entrées lorsque c’est possible.

9. Se fier à des noms de dtype identiques sans vérifier les valeurs

Deux colonnes de type chaîne peuvent tout de même différer à cause :

  • des espaces
  • de la casse
  • du formatage
  • des zéros initiaux
  • de caractères invisibles

Inspectez les clés sans correspondance.

Étape suivante

Utilisez le résultat du merge pour décider de la suite.

  • Le nombre de lignes a augmenté de manière inattendue → inspectez les clés en double et la cardinalité de la jointure.
  • Trop de lignes sans correspondance → comparez les dtypes des clés, le formatage, les valeurs nulles et la définition de la clé métier.
  • Les totaux ont changé de manière inattendue → arrêtez-vous et rapprochez avant toute agrégation.
  • Le côté droit doit être unique → ajoutez validate="many_to_one" et corrigez les violations.
  • Besoin d’un rapprochement entre lignes avec et sans correspondance → utilisez indicator=True.
  • Besoin de l’enregistrement daté d’effet le plus proche → utilisez merge_asof().
  • La jointure consomme beaucoup de mémoire → sélectionnez moins de colonnes, préfiltrez ou déplacez la jointure vers un moteur plus puissant.
  • Le merge est correct → passez à l’agrégation, au filtrage ou à la validation en aval.

← Tous les aide-mémoire