Trouver et supprimer les lignes en double d’un data frame — base R et dplyr, même résultat
Trouvez et supprimez les lignes en double en R avec duplicated() et unique() de base R, ou distinct() de dplyr. Supprimez les doublons sur toutes les colonnes ou par une seule colonne clé, conservez la première ou la dernière occurrence, et comptez le nombre de doublons — les deux moteurs, côte à côte.
26 juin 2026
7 juillet 2026
duplicated(df) renvoie un vecteur TRUE/FALSE signalant chaque ligne répétée.unique(df) ou df[!duplicated(df), ] ; dplyr : distinct(df).df[!duplicated(df$id), ] (base R) ou distinct(df, id, .keep_all = TRUE) (dplyr).duplicated() conserve la première occurrence ; passez fromLast = TRUE pour conserver la dernière à la place.Vous avez fusionné deux fichiers de données, extrait un tableau ou ajouté de nouveaux enregistrements, et maintenant certaines lignes apparaissent plusieurs fois. Les lignes en double gonflent les comptages, biaisent les résumés et faussent les jointures : les supprimer est donc une première étape de nettoyage courante.
Il existe deux approches, et vous verrez les deux dans du code réel :
duplicated() signale les répétitions, unique() les supprime ; aucun package nécessaire.distinct() conserve les lignes uniques en un seul appel lisible.Cette leçon montre les deux, côte à côte, pour trouver les doublons, les supprimer sur toutes les colonnes, les supprimer par une colonne clé, et choisir quelle copie conserver. Les deux donnent le même résultat.
Nous allons construire un petit data frame avec des doublons délibérés pour que la sortie soit facile à suivre :
id group score
1 1 a 10
2 2 b 20
3 2 b 20
4 3 c 30
5 3 c 30
6 3 d 40Les lignes 2–3 sont identiques, tout comme les lignes 4–5. La ligne 6 partage l’id 3 mais a un group et un score différents.
Avant de supprimer quoi que ce soit, regardez ce qui est en double. duplicated() renvoie un vecteur logique : TRUE pour chaque ligne qui est une répétition d’une ligne antérieure.
La première fois qu’une ligne apparaît elle vaut FALSE ; la deuxième fois (et les suivantes) elle vaut TRUE. Les lignes 3 et 5 sont signalées parce qu’elles répètent les lignes 2 et 4.
Pour voir les lignes en double, faites un sous-ensemble avec ce vecteur :
Pour compter le nombre de doublons que vous avez, additionnez le vecteur logique — TRUE compte pour 1 :
Deux lignes en double. table() est pratique lorsque vous voulez le comptage par valeur répétée d’une seule colonne :
L’id 2 apparaît deux fois et l’id 3 apparaît trois fois.
Une ligne compte comme un doublon lorsque chaque colonne correspond à une ligne antérieure.
unique() ou !duplicated()unique() est l’outil le plus direct : il renvoie le data frame avec les lignes en double supprimées.
df[!duplicated(df), ] fait la même chose — conserver les lignes qui ne sont pas signalées comme doublons. Le ! inverse le vecteur logique :
Les deux suppriment les lignes 3 et 5 et conservent la première copie de chacune. unique() est le raccourci ; !duplicated() est l’approche à privilégier lorsque vous voulez dédoublonner sur certaines des colonnes (section suivante).
distinct()distinct() conserve les lignes uniques. Sans argument de colonne, il examine toutes les colonnes :
Les mêmes quatre lignes. distinct() se lit clairement et s’intègre dans un pipeline.
Souvent « doublon » signifie le même id, même si d’autres colonnes diffèrent. Ici vous choisissez quelle(s) colonne(s) définissent un doublon.
!duplicated() sur la colonne cléAppliquez duplicated() à la colonne clé uniquement, puis faites un sous-ensemble :
Cela conserve la première ligne pour chaque id — notez que l’id 3 conserve la ligne 4 (group c), et les lignes 5 et 6 sont supprimées même si la ligne 6 avait des valeurs différentes. Dédoublonner par une clé jette toujours l’information des lignes supprimées, alors assurez-vous que la clé est bien ce que vous voulez.
distinct(.keep_all = TRUE)Nommez la (les) colonne(s) clé dans distinct(). Par défaut, distinct() renvoie uniquement les colonnes que vous nommez, alors ajoutez .keep_all = TRUE pour conserver toutes les autres colonnes de la première ligne correspondante :
Même résultat que l’approche base R — une ligne par id, en conservant la première occurrence et toutes ses colonnes.
Par défaut, les deux moteurs conservent la première occurrence de chaque doublon. Pour conserver la dernière à la place, signalez les doublons à partir de la fin avec fromLast = TRUE :
Maintenant l’id 3 conserve la ligne 6 (group d) — la dernière ligne pour cet id — au lieu de la première. Utilisez ceci lorsque l’enregistrement le plus récent est celui que vous voulez conserver. En dplyr, triez les données pour que la ligne souhaitée vienne en premier, puis distinct().
Les blocs ci-dessus ont été exécutés au moment de la compilation. Modifiez celui-ci et appuyez sur Run pour supprimer les doublons par vous-même — il s’exécute dans votre navigateur via webR (sans installation).
Collez un data frame en désordre avec des enregistrements répétés et demandez à Prova « supprime les lignes en double, en conservant la plus récente par client » — elle écrit l’appel distinct() ou duplicated(fromLast = TRUE), et parce que le runtime est juste ici, vous l’exécutez pour confirmer que les bonnes lignes ont survécu sur vos données. Demander à Prova →
Vous travaillez en Python ? Un guide pandas drop_duplicates arrive bientôt dans la série Python.
Les doublons ne sont pas supprimés alors que les lignes « semblent » identiques. Une ligne n’est un doublon que lorsque chaque colonne correspond exactement. Des espaces en fin de chaîne ("a" contre "a "), une casse différente ("A" contre "a"), ou un niveau de facteur égaré rendent toutes les lignes distinctes. Nettoyez d’abord la colonne fautive (par ex. trimws(), tolower()), puis dédoublonnez.
Des nombres qui s’affichent de manière identique mais ne sont pas égaux. Des valeurs à virgule flottante calculées de façons différentes (0.1 + 0.2 contre 0.3) s’affichent de manière identique mais diffèrent à la 16e décimale, donc duplicated() les traite comme distinctes. Arrondissez la colonne clé avec round(x, 6) avant de dédoublonner si « quasi égal » doit compter comme un doublon.
distinct(df, id) a supprimé mes autres colonnes. C’est le comportement par défaut — distinct() avec des colonnes nommées ne renvoie que ces colonnes. Ajoutez .keep_all = TRUE pour conserver le reste de chaque première ligne correspondante.
Utilisez unique(df) ou df[!duplicated(df), ] de base R, ou distinct(df) de dplyr. Les trois conservent la première copie de chaque ligne entièrement dupliquée et suppriment le reste, donnant le même résultat.
duplicated(df) renvoie un vecteur TRUE/FALSE signalant chaque ligne répétée. Faites un sous-ensemble avec — df[duplicated(df), ] — pour voir les doublons, ou sum(duplicated(df)) pour les compter.
Appliquez le test à cette colonne : df[!duplicated(df$id), ] (base R) ou distinct(df, id, .keep_all = TRUE) (dplyr). Les deux conservent la première ligne pour chaque valeur de la colonne clé et toutes ses autres colonnes.
Ils produisent les mêmes lignes pour la déduplication sur la ligne entière. unique() est de base R et ne nécessite aucun package ; distinct() est de dplyr, se lit clairement, et permet de dédoublonner par colonnes nommées avec .keep_all = TRUE. Utilisez celui qui convient à votre base de code.
Passez fromLast = TRUE à duplicated() : df[!duplicated(df$id, fromLast = TRUE), ] conserve la dernière ligne pour chaque clé. En dplyr, triez pour que la ligne souhaitée vienne en premier, puis appelez distinct().
Le data frame ci-dessous a des lignes entièrement dupliquées et des valeurs d’id répétées. Supprimez d’abord uniquement les lignes qui sont dupliquées sur toutes les colonnes (base R), puis conservez seulement une ligne par id avec toutes les colonnes (dplyr) — et vérifiez combien de lignes chacune laisse.
library(dplyr)
orders <- data.frame(
id = c(1, 1, 2, 2, 3),
item = c("pen", "pen", "ink", "pad", "pen"),
qty = c(2, 2, 1, 5, 3)
)
no_dupes <- orders[!duplicated(orders), ] # drops the duplicated pen row -> 4 rows
one_per_id <- distinct(orders, id, .keep_all = TRUE) # one row per id -> 3 rows
c(no_dupes = nrow(no_dupes), one_per_id = nrow(one_per_id))
library(dplyr)
orders <- data.frame(
id = c(1, 1, 2, 2, 3),
item = c("pen", "pen", "ink", "pad", "pen"),
qty = c(2, 2, 1, 5, 3)
)
no_dupes <- orders[!duplicated(orders), ] # drops the duplicated pen row -> 4 rows
one_per_id <- distinct(orders, id, .keep_all = TRUE) # one row per id -> 3 rows
c(no_dupes = nrow(no_dupes), one_per_id = nrow(one_per_id))Vous avez un data frame df avec une colonne id et vous voulez une ligne par id, en conservant la dernière occurrence. Laquelle est correcte ?
A. df[!duplicated(df$id), ] B. df[!duplicated(df$id, fromLast = TRUE), ] C. distinct(df, id)
Afficher la réponse
B. fromLast = TRUE signale les doublons de bas en haut, donc la dernière ligne pour chaque id est celle qui est conservée. A conserve la première occurrence ; C conserve la première occurrence et supprime toutes les colonnes sauf id (il faudrait .keep_all = TRUE).
Supprimer les doublons revient à deux ensembles d’outils équivalents : unique() / df[!duplicated(df), ] de base R ou distinct() de dplyr. Utilisez duplicated() pour trouver et compter les répétitions d’abord, dédoublonnez par une colonne clé avec df[!duplicated(df$key), ] ou distinct(df, key, .keep_all = TRUE), et faites appel à fromLast = TRUE lorsque le dernier enregistrement est celui à conserver.
arrange()/order() (souvent l’étape avant le dédoublonnage). · Filtrer les lignes en R — filtrer les observations par condition. · Sélectionner les colonnes en R — conserver ou supprimer des colonnes. · Renommer les colonnes en R — nettoyer les noms de colonnes.Prouvez que vous savez le faire. Maîtrisez toute la série Manipulation de données en R et Python — suivez votre parcours, construisez des projets et obtenez un certificat.
Passez à Pro — Prova illimité sur vos propres données et un certificat vérifiable qui atteste la compétence.
dès 15 $/mois facturé annuellement
✓ Vous êtes Pro — continuez. The runtime is the judge.
Recevez les nouvelles leçons R & Python par e-mail
Pratique, reproductible, sans spam. Désinscription à tout moment.
Double opt-in. Nous ne partageons jamais votre e-mail.
Cette leçon est reproductible : chaque résultat de cette page a été produit par le code affiché — modifiez n’importe quel bloc et appuyez sur Run pour le reproduire dans votre navigateur. The runtime is the judge.
@online{2026,
author = {},
title = {Supprimer les doublons en R : duplicated, unique \& distinct},
date = {2026-06-26},
url = {https://www.datanovia.com/learn/programming/data-wrangling/remove-duplicates-in-r},
langid = {fr}
}