Parcourir les aide-mémoire · Python

Technologie: PythonCatégorie: Nettoyage des donnéesNiveau: IntermédiaireMis à jour

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
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Trier selon une colonne
  5. 2. Trier selon plusieurs colonnes
  6. 3. Rendre le départage des ex aequo explicite
  7. 4. Préserver l’ordre d’origine lorsque le tri des ex aequo compte
  8. 5. Placer les valeurs nulles en premier ou en dernier
  9. 6. Trier avec une transformation grâce à key=
  10. 7. Trouver les lignes en double
  11. 8. Trouver les clés métier en double
  12. 9. Compter la fréquence des clés en double
  13. 10. Conserver le premier doublon selon l’ordre actuel des lignes
  14. 11. Conserver le dernier doublon selon l’ordre actuel des lignes
  15. 12. Supprimer toutes les clés dupliquées
  16. 13. Conserver la ligne la plus récente de chaque clé métier
  17. 14. Conserver la ligne la plus prioritaire de chaque clé
  18. 15. Conserver la ligne ayant la valeur maximale de chaque groupe
  19. 16. Conserver les N premières lignes de chaque groupe
  20. 17. Classer globalement
  21. 18. Classer au sein d’un groupe
  22. 19. Comprendre les méthodes de classement
  23. 20. Classer avec un départage déterministe
  24. 21. Reproduire ROW_NUMBER() de SQL avec pandas
  25. 22. Reproduire le comportement de RANK() en SQL
  26. 23. Reproduire le comportement de DENSE_RANK() en SQL
  27. 24. Conserver toutes les lignes ex aequo à la première place
  28. 25. Ne dédoublonner après un merge que si la relation est comprise
  29. 26. Comparer le nombre de lignes avant et après le dédoublonnage
  30. 27. Conserver la trace des doublons avant de supprimer des lignes
  31. 28. Valider l’unicité après le dédoublonnage
  32. 29. Vérifier si le dédoublonnage modifie un total important
  33. 30. Utiliser nlargest() lorsque vous n’avez besoin que des premières lignes
  34. Interpréter le résultat
  35. Points à vérifier
  36. Des lignes différentes sont conservées d’une exécution ou d’un fichier source à l’autre
  37. drop_duplicates() supprime plus de lignes que prévu
  38. Le nombre de doublons augmente après une jointure
  39. Les rangs présentent des trous
  40. Trop de lignes ont le rang 1
  41. La ligne « la plus récente » est incorrecte
  42. Notes de production
  43. Le dédoublonnage est une règle métier
  44. Ne vous fiez pas à l’ordre des lignes sources
  45. Le départage doit être déterministe
  46. Trier de grands DataFrames peut être coûteux
  47. Le dédoublonnage peut masquer des défauts de qualité des données
  48. Les valeurs nulles dans les clés exigent une sémantique explicite
  49. Les catégories ordonnées sont utiles pour la priorité métier
  50. Erreurs fréquentes
  51. 1. Appeler drop_duplicates() sans sous-ensemble
  52. 2. Conserver first sans trier
  53. 3. Utiliser l’horodatage seul comme critère de départage
  54. 4. Dédoublonner après une mauvaise jointure
  55. 5. Utiliser rank() alors que des numéros de ligne uniques sont nécessaires
  56. 6. Supposer que max() renvoie la ligne complète la plus récente ou la plus élevée
  57. 7. Ignorer le comportement de tri des valeurs nulles
  58. 8. Supprimer des doublons sans mesurer l’impact
  59. Étape suivante
  60. 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 lignes
  • cumcount() 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.

Étape suivante

Utilisez le modèle pour décider de la suite.

  • Besoin de la ligne la plus récente par clé → triez par clé + horodatage + critère de départage, puis conservez la première ligne.
  • Besoin du top-N par groupe → triez et utilisez head() par groupe, ou classez si les ex aequo comptent.
  • Besoin du comportement de ROW_NUMBER() en SQL → triez de façon déterministe et utilisez cumcount() + 1.
  • Besoin du comportement de RANK() / DENSE_RANK() en SQL → utilisez rank(method="min") ou rank(method="dense").
  • Des doublons inattendus sont apparus après un merge → inspectez la cardinalité de la jointure au lieu de dédoublonner.
  • La suppression des doublons modifie les totaux → rapprochez les lignes supprimées avant de continuer.
  • Le traitement des ex aequo est ambigu → définissez un critère de départage métier déterministe.
  • Le tri est trop coûteux en mémoire → réduisez le jeu de données plus tôt ou déplacez l’opération vers un moteur d’exécution plus puissant.

← Tous les aide-mémoire