Merge e join di data frame in R (merge, left_join)

Due tabelle, una chiave

I dati reali raramente stanno in una sola tabella. I clienti stanno in un data frame, i loro ordini in un altro, e la domanda "quanto ha speso ogni cliente?" ha bisogno di entrambi. Ciò che li collega è una chiave: una colonna presente in ciascuna tabella che identifica la stessa entità. Combinare tabelle su una chiave si chiama join (il termine di SQL) o merge (il termine di R base); l'operazione è la stessa.

Ecco la coppia di tabelle usata nel resto della pagina. Nota che il cliente 5 ha fatto un ordine ma non è nella tabella dei clienti, e i clienti 2 e 4 non hanno mai ordinato:

customers <- data.frame(
    id   = c(1, 2, 3, 4),
    name = c("Ana", "Ben", "Chen", "Dana")
)
orders <- data.frame(
    id     = c(1, 1, 3, 5),
    amount = c(250, 40, 120, 60)
)

print(customers)
print(orders)

Le mancate corrispondenze sono volute: ciò che un join fa con le righe senza corrispondenza è proprio ciò che distingue i tipi di join.

merge(): inner join di default

merge(x, y, by = "key") abbina le righe con chiavi uguali e ne unisce le colonne. Di default mantiene solo le chiavi presenti in entrambe le tabelle: un inner join.

customers <- data.frame(
    id   = c(1, 2, 3, 4),
    name = c("Ana", "Ben", "Chen", "Dana")
)
orders <- data.frame(
    id     = c(1, 1, 3, 5),
    amount = c(250, 40, 120, 60)
)

print(merge(customers, orders, by = "id"))

Tornano tre righe. Ana compare due volte: ha due ordini, e un join produce una riga di output per ogni coppia che corrisponde. Ben e Dana sono spariti (nessun ordine), e così anche l'ordine misterioso del cliente 5 (nessun cliente). Un inner join scarta in silenzio le righe senza corrispondenza di entrambe le tabelle: esattamente ciò che serve quando ti interessano solo le coppie complete, e un bug silenzioso di perdita di dati quando non è così.

Left, right e full join: all.x, all.y, all

Per mantenere le righe senza corrispondenza, di' quale tabella ha righe intoccabili. all.x = TRUE mantiene ogni riga della prima tabella: è il left join, il join più usato nella pratica.

customers <- data.frame(
    id   = c(1, 2, 3, 4),
    name = c("Ana", "Ben", "Chen", "Dana")
)
orders <- data.frame(
    id     = c(1, 1, 3, 5),
    amount = c(250, 40, 120, 60)
)

print(merge(customers, orders, by = "id", all.x = TRUE))

Ora Ben e Dana sopravvivono, con NA in amount, cioè "questo cliente esiste, ma nessun ordine corrisponde". Quegli NA sono informativi, non spazzatura: is.na(result$amount) è esattamente l'elenco dei clienti che non hanno mai ordinato (la guida ai valori mancanti spiega come lavorarci). Le altre varianti sono la stessa idea puntata altrove: all.y = TRUE mantiene ogni riga della seconda tabella (right join: l'ordine del cliente sconosciuto 5 sopravvivrebbe con NA in name), e all = TRUE mantiene tutto da entrambi i lati (full join).

Scegli chiedendoti: di chi sono le righe che non posso permettermi di perdere? Arricchire una tabella principale con dati di consultazione: left join, con la tabella principale per prima. Verificare in entrambe le direzioni: full join.

Chiavi con nomi diversi: by.x e by.y

Le tabelle raramente si mettono d'accordo sui nomi: id in una, customer_id nell'altra. Non rinominare; indica a merge() entrambi i nomi:

customers <- data.frame(
    id   = c(1, 2, 3),
    name = c("Ana", "Ben", "Chen")
)
orders <- data.frame(
    customer_id = c(1, 3, 3),
    amount      = c(250, 120, 60)
)

print(merge(customers, orders, by.x = "id", by.y = "customer_id"))

L'output mantiene per la chiave il nome della prima tabella. Una cosa collegata: se le due tabelle condividono nomi di colonna non chiave (per esempio entrambe hanno una date), merge aggiunge i suffissi date.x e date.y; rinominale subito, si leggono malissimo.

I join di dplyr

dplyr dà a ogni tipo di join il suo verbo, così l'intenzione sta nel nome della funzione invece che negli argomenti flag (statico; la sandbox esegue solo R base):

library(dplyr)

left_join(customers, orders, by = "id")
inner_join(customers, orders, by = "id")
full_join(customers, orders, by = "id")
left_join(customers, orders, by = c("id" = "customer_id"))  # different names

Oltre alla leggibilità, left_join() conserva l'ordine delle righe della prima tabella (merge() riordina per chiave) e avvisa in modo chiaro in caso di corrispondenze molti a molti; vedi l'introduzione a dplyr per la famiglia dei verbi.

Il membro sottovalutato è anti_join(): restituisce le righe della prima tabella che non hanno corrispondenza nella seconda, senza aggiungere colonne, solo gli avanzi:

anti_join(customers, orders, by = "id")   # customers who never ordered

Quella domanda, "quali righe non hanno trovato corrispondenza?", salta fuori di continuo nella pulizia dei dati (ID senza corrispondenza, record orfani, ricerche fallite), e anti_join() risponde in una sola chiamata dove R base ha bisogno di customers[!(customers$id %in% orders$id), ].

Impilare righe: rbind()

Un join combina le colonne di due tabelle. Quando invece hai due lotti dello stesso tipo di righe, per esempio gli ordini di gennaio e quelli di febbraio, li impili con rbind():

jan <- data.frame(id = c(1, 2), amount = c(250, 40))
feb <- data.frame(id = c(3, 4), amount = c(120, 60))

print(rbind(jan, feb))

Il requisito è rigido: entrambi i data frame devono avere gli stessi nomi di colonna (in qualsiasi ordine, perché rbind abbina per nome). Una colonna mancante o in più è un errore, non un riempimento con NA. Quando le colonne dei lotti sono cambiate nel tempo, bind_rows() di dplyr è più tollerante: allinea per nome e riempie i buchi con NA.

L'esplosione delle chiavi duplicate

Il classico incidente da join: chiavi che credevi uniche ma non lo sono, in entrambe le tabelle. Ogni corrispondenza si accoppia con ogni corrispondenza, moltiplicando le righe:

a <- data.frame(id = c(1, 1), x = c("a1", "a2"))
b <- data.frame(id = c(1, 1), y = c("b1", "b2"))

merged <- merge(a, b, by = "id")
print(merged)
cat("rows:", nrow(merged), "\n")

Due righe unite a due righe danno quattro righe: ogni x accoppiata con ogni y. Sui dati reali è così che una tabella da 10,000 righe diventa di 3 milioni di righe e un totale di ricavi raddoppia. merge() lo fa in silenzio. La difesa è un'abitudine: prima del join, controlla la chiave che presumi unica (anyDuplicated(customers$id) dovrebbe dare 0), e dopo il join verifica che nrow() corrisponda a quello che ti aspettavi.

Cosa ti porti a casa

• merge(x, y, by = "key") è un inner join: le righe senza corrispondenza spariscono in silenzio.
• all.x = TRUE (left), all.y = TRUE (right), all = TRUE (full) mantengono le righe senza corrispondenza, riempiendole con NA.
• Chiavi con nomi diversi: by.x / by.y in R base, by = c("a" = "b") in dplyr.
• dplyr dà un nome a ogni join; anti_join(), cioè le righe che non hanno trovato corrispondenza, è quello sottovalutato.
• rbind() impila tabelle con la stessa forma; le colonne devono corrispondere per nome.
• Le chiavi duplicate moltiplicano le righe in silenzio: controlla anyDuplicated() prima, nrow() dopo.

Prossimo passo: trasformare i dati tra formato largo e lungo con pivot_longer() e pivot_wider().