Parcourir les aide-mémoire · Python
Trier, classer et dédoublonner des données
Triez, classez et dédoublonnez des données pandas en toute sécurité en définissant un ordre déterministe, des clés métier, le traitement des ex aequo et la ligne exacte à conserver.
Sur cette page
- Problème
- Réponse rapide
- Code / commandes
- 1. Trier selon une colonne
- 2. Trier selon plusieurs colonnes
- 3. Rendre le départage des ex aequo explicite
- 4. Préserver l’ordre d’origine lorsque le tri des ex aequo compte
- 5. Placer les valeurs nulles en premier ou en dernier
- 6. Trier avec une transformation grâce à key=
- 7. Trouver les lignes en double
- 8. Trouver les clés métier en double
- 9. Compter la fréquence des clés en double
- 10. Conserver le premier doublon selon l’ordre actuel des lignes
- 11. Conserver le dernier doublon selon l’ordre actuel des lignes
- 12. Supprimer toutes les clés dupliquées
- 13. Conserver la ligne la plus récente de chaque clé métier
- 14. Conserver la ligne la plus prioritaire de chaque clé
- 15. Conserver la ligne ayant la valeur maximale de chaque groupe
- 16. Conserver les N premières lignes de chaque groupe
- 17. Classer globalement
- 18. Classer au sein d’un groupe
- 19. Comprendre les méthodes de classement
- 20. Classer avec un départage déterministe
- 21. Reproduire ROW_NUMBER() de SQL avec pandas
- 22. Reproduire le comportement de RANK() en SQL
- 23. Reproduire le comportement de DENSE_RANK() en SQL
- 24. Conserver toutes les lignes ex aequo à la première place
- 25. Ne dédoublonner après un merge que si la relation est comprise
- 26. Comparer le nombre de lignes avant et après le dédoublonnage
- 27. Conserver la trace des doublons avant de supprimer des lignes
- 28. Valider l’unicité après le dédoublonnage
- 29. Vérifier si le dédoublonnage modifie un total important
- 30. Utiliser nlargest() lorsque vous n’avez besoin que des premières lignes
- Interpréter le résultat
- Points à vérifier
- Des lignes différentes sont conservées d’une exécution ou d’un fichier source à l’autre
- drop_duplicates() supprime plus de lignes que prévu
- Le nombre de doublons augmente après une jointure
- Les rangs présentent des trous
- Trop de lignes ont le rang 1
- La ligne « la plus récente » est incorrecte
- Notes de production
- Le dédoublonnage est une règle métier
- Ne vous fiez pas à l’ordre des lignes sources
- Le départage doit être déterministe
- Trier de grands DataFrames peut être coûteux
- Le dédoublonnage peut masquer des défauts de qualité des données
- Les valeurs nulles dans les clés exigent une sémantique explicite
- Les catégories ordonnées sont utiles pour la priorité métier
- Erreurs fréquentes
- 1. Appeler drop_duplicates() sans sous-ensemble
- 2. Conserver first sans trier
- 3. Utiliser l’horodatage seul comme critère de départage
- 4. Dédoublonner après une mauvaise jointure
- 5. Utiliser rank() alors que des numéros de ligne uniques sont nécessaires
- 6. Supposer que max() renvoie la ligne complète la plus récente ou la plus élevée
- 7. Ignorer le comportement de tri des valeurs nulles
- 8. Supprimer des doublons sans mesurer l’impact
- Étape suivante
- Pour aller plus loin
Problème
Vous devez ordonner des enregistrements, classer des valeurs au sein de groupes ou ne conserver qu’une ligne parmi un ensemble de doublons.
Exemples typiques :
- conserver l’enregistrement le plus récent de chaque client
- classer les produits par chiffre d’affaires au sein de chaque catégorie
- conserver l’événement le plus prioritaire pour chaque clé métier
- supprimer les lignes sources en double
- repérer les clés en double avant de charger une cible
- mettre en place une logique déterministe « top 1 par groupe »
Le risque ne tient pas à la syntaxe.
Le risque est de conserver silencieusement la mauvaise ligne parce que :
- l’ordre de tri est incomplet
- les ex aequo ne sont pas traités de façon délibérée
- les clés en double sont mal comprises
- l’ordre des lignes est considéré comme significatif alors qu’il ne l’est pas
- le dédoublonnage a lieu avant que la granularité métier soit définie
Réponse rapide
Pour la ligne la plus récente de chaque client :
latest = (
df.sort_values(
["customer_id", "event_time"],
ascending=[True, False],
)
.drop_duplicates(
subset=["customer_id"],
keep="first",
)
)
Pour un classement top-N au sein d’un groupe :
df["revenue_rank"] = (
df.groupby("category")["revenue"]
.rank(
method="dense",
ascending=False,
)
)
Pour analyser les doublons :
duplicates = df.loc[
df.duplicated(
subset=["customer_id", "event_time"],
keep=False,
)
]
La règle essentielle :
Définissez la clé métier et l’ordre de départage avant d’appeler
drop_duplicates().
Code / commandes
1. Trier selon une colonne
sorted_df = df.sort_values(
"revenue",
ascending=False,
)
Utilisez cette approche lorsqu’un seul champ détermine entièrement l’ordre souhaité.
2. Trier selon plusieurs colonnes
sorted_df = df.sort_values(
["customer_id", "event_time"],
ascending=[True, False],
)
Cela signifie :
- client par ordre croissant
- événement le plus récent en premier pour chaque client
Utilisez plusieurs colonnes lorsque l’ordre métier dépend de plus d’un attribut.
3. Rendre le départage des ex aequo explicite
Supposons que deux événements puissent avoir le même horodatage.
Ajoutez une autre clé déterministe :
sorted_df = df.sort_values(
[
"customer_id",
"event_time",
"event_id",
],
ascending=[
True,
False,
False,
],
)
Puis dédoublonnez :
latest = sorted_df.drop_duplicates(
subset=["customer_id"],
keep="first",
)
Sans critère de départage, la ligne « la plus récente » peut rester ambiguë.
4. Préserver l’ordre d’origine lorsque le tri des ex aequo compte
pandas prend en charge un algorithme de tri stable.
sorted_df = df.sort_values(
"priority",
kind="stable",
)
Utilisez un tri stable lorsque des clés de tri égales doivent conserver leur ordre précédent.
Pour les tris sur plusieurs colonnes, appuyez-vous sur la clé de tri complète plutôt que d’utiliser la stabilité comme substitut à des règles de départage explicites.
5. Placer les valeurs nulles en premier ou en dernier
Par défaut, les valeurs nulles sont placées en dernier.
sorted_df = df.sort_values(
"event_time",
na_position="last",
)
Pour les placer en premier :
sorted_df = df.sort_values(
"event_time",
na_position="first",
)
Choisissez en fonction de la règle métier.
Ne laissez pas le positionnement par défaut des valeurs nulles décider quelle ligne en double est conservée.
6. Trier avec une transformation grâce à key=
Tri insensible à la casse :
sorted_df = df.sort_values(
"customer_name",
key=lambda s: s.str.casefold(),
)
Cela modifie le comportement du tri sans altérer définitivement la colonne d’origine.
7. Trouver les lignes en double
duplicate_rows = df.loc[
df.duplicated(
keep=False,
)
]
Cela trouve les lignes entièrement dupliquées sur toutes les colonnes.
N’utilisez cette approche que lorsque la duplication de lignes complètes a un sens.
8. Trouver les clés métier en double
key_cols = [
"customer_id",
"order_id",
]
duplicates = df.loc[
df.duplicated(
subset=key_cols,
keep=False,
)
].sort_values(key_cols)
C’est généralement plus utile que la détection de doublons sur des lignes complètes.
La clé doit correspondre à la granularité métier visée.
9. Compter la fréquence des clés en double
duplicate_counts = (
df.groupby(
["customer_id", "order_id"],
dropna=False,
)
.size()
.reset_index(name="row_count")
.loc[lambda x: x["row_count"] > 1]
.sort_values(
"row_count",
ascending=False,
)
)
Utilisez cette approche pour savoir si la duplication est isolée ou systématique.
10. Conserver le premier doublon selon l’ordre actuel des lignes
deduped = df.drop_duplicates(
subset=["customer_id"],
keep="first",
)
Ce n’est sûr que si l’ordre actuel des lignes a déjà été rendu significatif.
Ne l’utilisez pas sur un ordre d’ingestion arbitraire.
11. Conserver le dernier doublon selon l’ordre actuel des lignes
deduped = df.drop_duplicates(
subset=["customer_id"],
keep="last",
)
Là encore, le résultat dépend entièrement de l’ordre existant des lignes.
En général, triez d’abord.
12. Supprimer toutes les clés dupliquées
unique_only = df.loc[
~df.duplicated(
subset=["customer_id"],
keep=False,
)
]
Cela ne conserve que les clés qui apparaissent exactement une fois.
Utilisez cette approche pour isoler les exceptions ou pour des contrôles de qualité stricts.
Ce n’est pas la même chose que « conserver une ligne par clé ».
13. Conserver la ligne la plus récente de chaque clé métier
latest = (
df.sort_values(
["customer_id", "event_time"],
ascending=[True, False],
)
.drop_duplicates(
subset=["customer_id"],
keep="first",
)
)
C’est l’un des modèles de dédoublonnage les plus courants en production.
Ajoutez un critère de départage déterministe si les horodatages peuvent se répéter.
14. Conserver la ligne la plus prioritaire de chaque clé
Supposons que la priorité soit :
critical > high > medium > low
Définissez une catégorie ordonnée :
from pandas.api.types import CategoricalDtype
priority_type = CategoricalDtype(
categories=[
"low",
"medium",
"high",
"critical",
],
ordered=True,
)
df["priority"] = (
df["priority"]
.astype(priority_type)
)
Puis triez et dédoublonnez :
best = (
df.sort_values(
["customer_id", "priority"],
ascending=[True, False],
)
.drop_duplicates(
subset=["customer_id"],
keep="first",
)
)
C’est plus sûr qu’un tri alphabétique.
15. Conserver la ligne ayant la valeur maximale de chaque groupe
idx = (
df.groupby("customer_id")["revenue"]
.idxmax()
)
top_rows = df.loc[idx]
Cela conserve la ligne réellement associée à la valeur maximale.
Utilisez cette approche lorsqu’un seul champ numérique désigne la ligne retenue.
Soyez prudent lorsqu’un groupe ne contient que des valeurs nulles dans la colonne cible.
16. Conserver les N premières lignes de chaque groupe
Triez d’abord :
top_3 = (
df.sort_values(
["category", "revenue"],
ascending=[True, False],
)
.groupby(
"category",
group_keys=False,
)
.head(3)
)
Cela renvoie jusqu’à trois lignes par catégorie.
Si tous les ex aequo doivent être conservés, un classement est généralement préférable.
17. Classer globalement
df["revenue_rank"] = (
df["revenue"]
.rank(
method="dense",
ascending=False,
)
)
Le chiffre d’affaires le plus élevé obtient le plus petit numéro de rang.
18. Classer au sein d’un groupe
df["category_rank"] = (
df.groupby("category")["revenue"]
.rank(
method="dense",
ascending=False,
)
)
Utilisez cette approche pour :
- le rang des produits par catégorie
- le rang des marchands par région
- le rang des clients par segment
19. Comprendre les méthodes de classement
Exemples de valeurs :
100
100
90
80
method="min" :
1
1
3
4
method="dense" :
1
1
2
3
method="first" :
1
2
3
4
method="average" :
1.5
1.5
3
4
Choisissez en fonction de la signification métier des ex aequo.
20. Classer avec un départage déterministe
Si des ex aequo ne doivent pas partager le même rang, triez d’abord explicitement.
ranked = df.sort_values(
[
"category",
"revenue",
"product_id",
],
ascending=[
True,
False,
True,
],
).copy()
ranked["row_number"] = (
ranked.groupby("category")
.cumcount()
.add(1)
)
Cela se comporte davantage comme ROW_NUMBER() en SQL que comme rank().
Utilisez cette approche lorsque chaque ligne a besoin d’un numéro de séquence unique.
21. Reproduire ROW_NUMBER() de SQL avec pandas
ranked = df.sort_values(
[
"customer_id",
"event_time",
"event_id",
],
ascending=[
True,
False,
False,
],
).copy()
ranked["row_number"] = (
ranked.groupby("customer_id")
.cumcount()
.add(1)
)
Puis :
latest = ranked.loc[
ranked["row_number"] == 1
]
Cela rend la logique de sélection de la ligne retenue explicite et facile à déboguer.
22. Reproduire le comportement de RANK() en SQL
df["rank"] = (
df.groupby("category")["revenue"]
.rank(
method="min",
ascending=False,
)
)
Les ex aequo reçoivent le même rang et créent des trous ensuite.
23. Reproduire le comportement de DENSE_RANK() en SQL
df["dense_rank"] = (
df.groupby("category")["revenue"]
.rank(
method="dense",
ascending=False,
)
)
Les ex aequo partagent un rang, mais il n’y a pas de trous dans les rangs.
24. Conserver toutes les lignes ex aequo à la première place
df["rank"] = (
df.groupby("category")["revenue"]
.rank(
method="min",
ascending=False,
)
)
leaders = df.loc[
df["rank"] == 1
]
Utilisez cette approche lorsque les ex aequo sont légitimes et que tous les gagnants doivent être conservés.
25. Ne dédoublonner après un merge que si la relation est comprise
Mauvais modèle :
result = (
left.merge(
right,
on="customer_id",
how="left",
)
.drop_duplicates()
)
Cela peut masquer une jointure un-à-plusieurs incorrecte.
Validez plutôt la relation avant le merge :
result = left.merge(
right,
on="customer_id",
how="left",
validate="many_to_one",
)
Corrigez le problème de jointure plutôt que de dédoublonner le symptôme.
26. Comparer le nombre de lignes avant et après le dédoublonnage
before = len(df)
deduped = df.drop_duplicates(
subset=["customer_id", "order_id"],
)
after = len(deduped)
print("Rows before:", before)
print("Rows after:", after)
print("Rows removed:", before - after)
Sachez toujours combien de lignes votre règle a supprimées.
27. Conserver la trace des doublons avant de supprimer des lignes
key_cols = [
"customer_id",
"order_id",
]
duplicates = df.loc[
df.duplicated(
subset=key_cols,
keep=False,
)
].copy()
Puis dédoublonnez séparément :
deduped = (
df.sort_values(
key_cols + ["event_time"],
ascending=[True, True, False],
)
.drop_duplicates(
subset=key_cols,
keep="first",
)
)
Les éléments restent ainsi disponibles pour le diagnostic.
28. Valider l’unicité après le dédoublonnage
key_cols = [
"customer_id",
"order_id",
]
assert not deduped.duplicated(
subset=key_cols
).any()
Pour du code de production, une validation structurée peut être préférable à assert, en particulier si les paramètres d’optimisation de Python ou la gestion des erreurs du pipeline comptent.
29. Vérifier si le dédoublonnage modifie un total important
before_total = df["amount"].sum()
deduped = df.drop_duplicates(
subset=["order_id"],
keep="first",
)
after_total = deduped["amount"].sum()
print("Before:", before_total)
print("After:", after_total)
Un total modifié peut être attendu.
L’important est de comprendre pourquoi.
30. Utiliser nlargest() lorsque vous n’avez besoin que des premières lignes
top_10 = df.nlargest(
10,
"revenue",
)
Pour les plus petites valeurs :
bottom_10 = df.nsmallest(
10,
"revenue",
)
C’est souvent plus clair que de trier tout le DataFrame lorsque seul un petit sous-ensemble de valeurs les plus élevées ou les plus basses est nécessaire.
Interpréter le résultat
| Opération | Signification |
|---|---|
sort_values() |
Ordonne les lignes selon une ou plusieurs colonnes. |
drop_duplicates() |
Supprime les lignes répétées ou les combinaisons de clés répétées selon l’ordre actuel. |
duplicated() |
Marque les lignes/clés répétées sans les supprimer. |
rank() |
Produit des valeurs de rang numériques avec un traitement des ex aequo configurable. |
cumcount() |
Produit une séquence commençant à zéro au sein de chaque groupe. |
idxmax() |
Renvoie l’étiquette d’index de la valeur maximale par groupe/Series. |
head(n) après un tri par groupe |
Conserve les N premières lignes triées de chaque groupe. |
nlargest() |
Sélectionne les valeurs les plus élevées sans nécessiter un modèle de tri complet explicite. |
La distinction essentielle :
rang != numéro de ligne
En présence d’ex aequo :
rank()peut attribuer le même rang à plusieurs lignescumcount()après un tri déterministe donne à chaque ligne une position unique
Points à vérifier
Des lignes différentes sont conservées d’une exécution ou d’un fichier source à l’autre
Votre ordre de dédoublonnage est probablement incomplet.
Ajoutez des colonnes de départage déterministes.
drop_duplicates() supprime plus de lignes que prévu
Vérifiez si le sous-ensemble représente la véritable clé métier.
Vous dédoublonnez peut-être à une granularité trop large.
Le nombre de doublons augmente après une jointure
La jointure a peut-être introduit une multiplication un-à-plusieurs ou plusieurs-à-plusieurs.
Ne corrigez pas cela avec drop_duplicates() tant que la relation n’est pas comprise.
Les rangs présentent des trous
C’est le comportement attendu avec des méthodes de classement telles que :
method="min"
Utilisez dense si vous avez besoin de rangs sans trous.
Trop de lignes ont le rang 1
Il y a des ex aequo.
Décidez s’il faut :
- conserver tous les ex aequo
- utiliser un critère de départage
- utiliser une sémantique de numéro de ligne
La ligne « la plus récente » est incorrecte
Vérifiez :
- le dtype de l’horodatage
- la gestion des fuseaux horaires
- la position des valeurs nulles
- les horodatages ex aequo
- le sens du tri
Notes de production
Le dédoublonnage est une règle métier
Il n’existe pas de définition universelle d’un doublon.
Les granularités possibles incluent :
une ligne par commande
une ligne par client et par jour
une ligne par ID d’événement
une ligne par marchand + site + date
Définissez d’abord la granularité.
Ne vous fiez pas à l’ordre des lignes sources
L’ordre d’un fichier CSV, d’une réponse d’API, d’un résultat de base de données ou d’ingestion peut changer.
Si la ligne conservée compte, triez explicitement.
Le départage doit être déterministe
Si deux lignes ont le même horodatage principal ou le même score, utilisez un autre champ métier stable, par exemple :
- un numéro de séquence
- un ID d’événement
- une version
- un horodatage d’ingestion
- une priorité de source
Évitez toute résolution arbitraire des ex aequo.
Trier de grands DataFrames peut être coûteux
Un tri complet est généralement plus coûteux qu’un simple filtrage.
Sur de gros volumes :
- filtrez d’abord
- sélectionnez les colonnes nécessaires
- évitez les tris répétés
- utilisez
nlargest()/nsmallest()lorsque c’est approprié - déportez le classement/dédoublonnage vers SQL/Spark lorsque les données dépassent les limites de mémoire raisonnables
Le dédoublonnage peut masquer des défauts de qualité des données
Ne considérez pas le dédoublonnage comme un nettoyage par défaut.
Déterminez d’abord si les doublons sont :
- des événements répétés légitimes
- des nouvelles tentatives côté source
- des fichiers rejoués
- de mauvaises jointures
- des défauts du système source
- des lignes versionnées intentionnellement
Les valeurs nulles dans les clés exigent une sémantique explicite
Deux lignes dont des composantes de clé sont nulles peuvent être considérées comme des doublons par pandas selon les valeurs du sous-ensemble.
Décidez si les lignes dont la clé est manquante sont même éligibles au dédoublonnage.
Les catégories ordonnées sont utiles pour la priorité métier
Le tri alphabétique représente rarement la priorité réelle.
Définissez explicitement l’ordre des catégories lorsque le métier utilise des libellés hiérarchisés.
Erreurs fréquentes
1. Appeler drop_duplicates() sans sous-ensemble
Cela dédoublonne des lignes complètes, ce qui peut ne pas correspondre à la clé métier.
2. Conserver first sans trier
first signifie premier dans l’ordre actuel des lignes, et non le plus ancien ou le plus récent dans le temps.
3. Utiliser l’horodatage seul comme critère de départage
Les horodatages peuvent se répéter.
Ajoutez une autre colonne déterministe.
4. Dédoublonner après une mauvaise jointure
Cela peut masquer le véritable problème de cardinalité et éliminer des lignes valides.
Corrigez d’abord la relation du merge.
5. Utiliser rank() alors que des numéros de ligne uniques sont nécessaires
Des ex aequo peuvent partager le même rang.
Utilisez groupby().cumcount() + 1 après un tri pour obtenir un comportement de numéro de ligne.
6. Supposer que max() renvoie la ligne complète la plus récente ou la plus élevée
Agréger chaque colonne indépendamment peut combiner des valeurs provenant de lignes différentes.
Sélectionnez la ligne réellement retenue.
7. Ignorer le comportement de tri des valeurs nulles
Les valeurs nulles peuvent devenir de manière inattendue la ligne conservée ou supprimée si l’ordre de tri n’est pas délibéré.
8. Supprimer des doublons sans mesurer l’impact
Indiquez toujours le nombre de lignes supprimées et validez les totaux ou comptages importants.
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.