Rimuovi righe duplicate per colonna in R

Per mantenere una riga per ciascuna chiave selezionata in un data frame R, usa distinct() di dplyr con .keep_all = TRUE quando ti servono le altre colonne. Ciascun metodo seguente mantiene la riga corrispondente più antica nell’ordine attuale dei dati, quindi ordina prima quando un altro record deve avere la priorità. Gli esempi usano un piccolo data frame con le colonne id, group e score.

Usa la funzione distinct del pacchetto dplyr per rimuovere le righe duplicate per colonna in R

Usa distinct(df, id, .keep_all = TRUE) quando id definisce un record univoco e vuoi ogni colonna originale nel risultato. distinct() confronta le colonne chiave selezionate e mantiene la prima riga per ciascun valore di chiave. Con .keep_all = TRUE, le altre colonne vengono riportate nel risultato, ma non influiscono sul fatto che due righe corrispondano. Senza tale argomento, il risultato contiene solo le colonne selezionate.

Per una chiave composita, elenca ciascuna colonna: distinct(df, id, group, .keep_all = TRUE). Le righe con lo stesso id ma valori di group diversi rimangono quindi separate. L’esempio completo seguente usa gli stessi dati di esempio e mostra entrambe le scelte di chiave. Richiede che dplyr sia installato; i suoi risultati sono descritti di seguito e questo esempio non è accompagnato da output di runtime.

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")
}

Il risultato a chiave singola mantiene (1, A, 8), (2, A, 5) e (3, A, 4). Il risultato a chiave composita mantiene quelle righe più (2, B, 9) e (3, B, 7), perché ciascuna coppia di id e group è univoca. Il seguente esempio separato in R base stampa entrambi i risultati.

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

Qui, !duplicated(df$id) contrassegna le occorrenze successive di ciascun id; passare un data frame di colonne chiave a duplicated() applica la stessa regola della prima occorrenza alla loro combinazione. Entrambe le selezioni mantengono tutte le colonne di ciascuna riga scelta.

Usa le funzioni group_by, filter e duplicated per rimuovere le righe duplicate per colonna in R

Per una singola chiave globale id, filter(!duplicated(id)) mantiene la sua prima occorrenza. Se l’input potrebbe essere già raggruppato, chiama prima ungroup() in modo che filter() valuti il controllo dei duplicati sull’intero set di dati:

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

La pipe %>% passa il valore alla sua sinistra come primo argomento alla funzione alla sua destra. Raggruppare per id prima di filter(!duplicated(id)) non rimuove le righe successive: all’interno di ciascun gruppo id, tale chiave è costante, quindi duplicated(id) non trova alcuna occorrenza successiva. Raggruppare per un’altra colonna è utile quando gli ID possono ripetersi in modo indipendente all’interno di ciascun gruppo; allora duplicated(id) mantiene la prima occorrenza di ciascun ID in ogni gruppo. Per una singola chiave globale, l’espressione non raggruppata ha lo stesso comportamento sulla prima riga della selezione in R base precedente.

Ad esempio, raggruppare per group applica lo stesso controllo separatamente all’interno di ciascun gruppo:

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

Questa pipeline mantiene la prima riga per ciascun id all’interno di ciascun group, in base all’ordine attuale delle righe. Nei dati di esempio, ciascuna coppia di id e group compare una sola volta, quindi ogni riga è la prima occorrenza del suo id all’interno del suo gruppo e tutte e cinque le righe vengono mantenute; un’ulteriore riga che ripetesse un id già visto nello stesso gruppo verrebbe scartata.

Usa le funzioni group_by e slice per rimuovere le righe duplicate per colonna in R

La pipeline dplyr df %>% group_by(id) %>% slice(1) %>% ungroup() seleziona la posizione 1 da ciascun gruppo id. L’ordine attuale delle righe determina quale record è il primo; slice(1) non seleziona automaticamente il punteggio più alto o il record più recente. Disponi i dati in base alla preferenza desiderata prima di raggruppare e tagliare, quindi rimuovi il raggruppamento quando le operazioni successive devono trattare il risultato come un normale data frame.

Per i dati di esempio, questo metodo mantiene le stesse righe degli approcci distinct() e duplicated() a chiave singola: la prima riga per gli ID 1, 2 e 3. Usa distinct() quando il compito è selezionare combinazioni di chiavi univoche; usa slice(1) quando selezionare una riga in base alla sua posizione all’interno di ciascun gruppo fa parte di un flusso di lavoro raggruppato più ampio. Queste espressioni dplyr sono illustrative e richiedono il pacchetto dplyr; l’esempio in R base precedente viene eseguito senza tale dipendenza.