Supprimer les lignes en double par colonne dans R

Pour conserver une ligne pour chaque clé sélectionnée dans un data frame R, utilisez distinct() de dplyr avec .keep_all = TRUE lorsque vous avez besoin des autres colonnes. Chaque méthode ci-dessous conserve la ligne correspondante la plus ancienne dans l’ordre actuel des données ; triez donc d’abord lorsqu’un autre enregistrement doit avoir la priorité. Les exemples utilisent un petit data frame avec les colonnes id, group et score.

Utilisez la fonction distinct du package dplyr pour supprimer les lignes en double par colonne dans R

Utilisez distinct(df, id, .keep_all = TRUE) lorsque id définit un enregistrement unique et que vous voulez toutes les colonnes d’origine dans le résultat. distinct() compare les colonnes clés sélectionnées et conserve la première ligne pour chaque valeur de clé. Avec .keep_all = TRUE, les autres colonnes sont reportées dans le résultat, mais n’affectent pas la correspondance entre deux lignes. Sans cet argument, le résultat ne contient que les colonnes sélectionnées.

Pour une clé composite, listez chaque colonne : distinct(df, id, group, .keep_all = TRUE). Les lignes ayant le même id mais des valeurs de group différentes restent alors distinctes. L’exemple complet suivant utilise les mêmes données d’exemple et montre les deux choix de clé. Il nécessite que dplyr soit installé ; ses résultats sont décrits ci-dessous, et cet exemple n’est accompagné d’aucune sortie d’exécution.

df <- data.frame(
  id = c(1, 2, 2, 3, 3),
  group = c("A", "A", "B", "A", "B"),
  score = c(8, 5, 9, 4, 7)
)

if (requireNamespace("dplyr", quietly = TRUE)) {
  unique_by_id <- dplyr::distinct(df, id, .keep_all = TRUE)
  unique_by_pair <- dplyr::distinct(df, id, group, .keep_all = TRUE)
  print(unique_by_id)
  print(unique_by_pair)
} else {
  cat("Install dplyr to run these distinct() examples.\n")
}

Le résultat à clé unique conserve (1, A, 8), (2, A, 5) et (3, A, 4). Le résultat à clé composite conserve ces lignes ainsi que (2, B, 9) et (3, B, 7), car chaque paire id et group est unique. L’exemple séparé suivant en R de base imprime les deux résultats.

df <- data.frame(
  id = c(1, 2, 2, 3, 3),
  group = c("A", "A", "B", "A", "B"),
  score = c(8, 5, 9, 4, 7)
)

unique_by_id <- df[!duplicated(df$id), ]
unique_by_pair <- df[!duplicated(df[c("id", "group")]), ]

cat("By id:\n")
cat(paste(unique_by_id$id, unique_by_id$group, unique_by_id$score, sep = ":"), sep = "\n")
cat("\nBy id and group:\n")
cat(paste(unique_by_pair$id, unique_by_pair$group, unique_by_pair$score, sep = ":"), sep = "\n")

By id:
1:A:8
2:A:5
3:A:4

By id and group:
1:A:8
2:A:5
2:B:9
3:A:4
3:B:7

Ici, !duplicated(df$id) marque les occurrences ultérieures de chaque id ; passer un data frame de colonnes clés à duplicated() applique la même règle de première occurrence à leur combinaison. Les deux sélections conservent toutes les colonnes de chaque ligne choisie.

Utilisez les fonctions group_by, filter et duplicated pour supprimer les lignes en double par colonne dans R

Pour une seule clé globale id, filter(!duplicated(id)) conserve sa première occurrence. Si l’entrée peut déjà être groupée, appelez d’abord ungroup() afin que filter() évalue le contrôle des doublons sur l’ensemble des données :

df %>% ungroup() %>% filter(!duplicated(id))

Le pipe %>% transmet la valeur à sa gauche comme premier argument à la fonction à sa droite. Grouper par id avant filter(!duplicated(id)) ne supprime pas les lignes ultérieures : au sein de chaque groupe id, cette clé est constante, donc duplicated(id) ne trouve aucune occurrence ultérieure. Grouper par une autre colonne est utile lorsque les ID peuvent se répéter indépendamment au sein de chaque groupe ; alors duplicated(id) conserve la première occurrence de chaque ID dans chaque groupe. Pour une seule clé globale, l’expression non groupée a le même comportement de première ligne que la sélection en R de base ci-dessus.

Par exemple, grouper par group applique le même contrôle séparément au sein de chaque groupe :

df %>%
  group_by(group) %>%
  filter(!duplicated(id)) %>%
  ungroup()

Ce pipeline conserve la première ligne pour chaque id au sein de chaque group, selon l’ordre actuel des lignes. Dans les données d’exemple, chaque paire id et group n’apparaît qu’une seule fois, donc chaque ligne est la première occurrence de son id au sein de son groupe et les cinq lignes sont conservées ; une ligne supplémentaire répétant un id déjà vu dans le même groupe serait supprimée.

Utilisez les fonctions group_by et slice pour supprimer les lignes en double par colonne dans R

Le pipeline dplyr df %>% group_by(id) %>% slice(1) %>% ungroup() sélectionne la position 1 dans chaque groupe id. L’ordre actuel des lignes détermine quel enregistrement est le premier ; slice(1) ne sélectionne pas automatiquement le score le plus élevé ni l’enregistrement le plus récent. Triez les données selon la préférence souhaitée avant de grouper et de trancher, puis dégroupez lorsque les opérations ultérieures doivent traiter le résultat comme un data frame ordinaire.

Pour les données d’exemple, cette méthode conserve les mêmes lignes que les approches distinct() et duplicated() à clé unique : la première ligne pour les ID 1, 2 et 3. Utilisez distinct() lorsque la tâche consiste à sélectionner des combinaisons de clés uniques ; utilisez slice(1) lorsque la sélection d’une ligne par sa position au sein de chaque groupe fait partie d’un flux de travail groupé plus large. Ces expressions dplyr sont illustratives et nécessitent le package dplyr ; l’exemple en R de base ci-dessus s’exécute sans cette dépendance.