Parcourir les aide-mémoire · Python
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
- Problème
- Réponse rapide
- Code / commandes
- 1. Jointure interne
- 2. Jointure gauche
- 3. Jointure droite
- 4. Jointure externe complète
- 5. Valider la cardinalité de la jointure
- 6. Vérifier l’unicité des clés avant le merge
- 7. Joindre sur plusieurs colonnes
- 8. Joindre lorsque les noms de clés diffèrent
- 9. Inspecter les lignes sans correspondance
- 10. Rapprocher les pourcentages de correspondance
- 11. Détecter la multiplication des lignes
- 12. Comprendre l’expansion plusieurs-à-plusieurs
- 13. Protéger les totaux en aval contre une duplication accidentelle
- 14. Gérer les noms de colonnes en commun
- 15. Ne sélectionner que les colonnes nécessaires avant la jointure
- 16. Joindre à l’aide des index
- 17. Semi-jointure : conserver les lignes de gauche qui ont une correspondance
- 18. Anti-jointure : conserver les lignes de gauche sans correspondance
- 19. Joindre avec des clés nulles : comprendre le comportement de pandas
- 20. Vérifier la compatibilité des dtypes des clés de jointure
- 21. Normaliser les clés de type chaîne avec prudence
- 22. Éviter les noms de colonnes en double accidentels avant le merge
- 23. Fusionner sur des correspondances temporelles triées avec merge_asof
- 24. Faire une jointure croisée intentionnellement
- Interpréter le résultat
- Points à vérifier
- La jointure gauche augmente le nombre de lignes
- La jointure interne perd plus de lignes que prévu
- Les totaux augmentent après l’enrichissement
- De nombreuses lignes sans correspondance
- Des colonnes _x et _y apparaissent partout
- Des clés nulles correspondent de manière inattendue
- Notes de production
- Toujours valider la cardinalité attendue
- Le rapprochement du nombre de lignes doit être la norme
- Rapprocher les mesures importantes
- Sélectionner les colonnes avant la jointure
- Les jointures plusieurs-à-plusieurs peuvent faire exploser la mémoire
- Les jointures pandas s’exécutent en mémoire
- Ne pas utiliser le résultat du merge comme substitut aux contrôles de qualité des clés
- Erreurs fréquentes
- 1. Faire un merge sans vérifier l’unicité des clés
- 2. Utiliser many_to_many pour faire passer la validation
- 3. Supposer qu’une jointure gauche préserve le nombre de lignes
- 4. Supprimer les doublons après un mauvais merge
- 5. Joindre sur des clés métier incomplètes
- 6. Ignorer les clés de jointure nulles
- 7. Compter sur _x et _y
- 8. Joindre avant de filtrer ou de projeter
- 9. Se fier à des noms de dtype identiques sans vérifier les valeurs
- Étape suivante
- 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.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Restez au courant
Recevez uniquement les nouvelles de Javi Builds qui vous intéressent.
Consultez votre boîte de réception
Je vous ai envoyé un lien de confirmation. Votre abonnement sera actif après confirmation.