R Academy · Lezione

Join tra più tabelle in dplyr

Padroneggi inner_join, left_join, right_join, full_join e anti_join.

Lezione 3 di 413 passaggi

Join tra più tabelle in dplyr è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento R Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso R Academy include 4 lezioni in totale.

Perché unire le tabelle

I dati reali raramente si trovano in un'unica tabella. I database relazionali suddividono le informazioni in più tabelle per evitare ripetizioni. Le join consentono di combinare le tabelle in base a chiavi condivise. dplyr offre funzioni di join in stile SQL con una sintassi chiara e leggibile.

library(dplyr)

# Two related tables
orders <- data.frame(
  order_id = 1:4,
  customer_id = c(1, 2, 1, 3),
  amount = c(250, 180, 320, 90)
)

customers <- data.frame(
  customer_id = 1:3,
  name = c('Alice','Bob','Carol'),
  city = c('NYC','LA','Chicago')
)

print(orders)
print(customers)

inner_join() — Solo righe corrispondenti

inner_join(x, y, by='key') restituisce solo le righe in cui la chiave esiste in entrambe le tabelle. Le righe senza corrispondenza nell'altra tabella vengono eliminate. È il tipo di join più comune.

library(dplyr)

orders <- data.frame(
  order_id = 1:4,
  customer_id = c(1, 2, 1, 99),
  amount = c(250, 180, 320, 90)
)

customers <- data.frame(
  customer_id = c(1, 2, 3),
  name = c('Alice','Bob','Carol')
)

# customer_id = 99 in orders has no match => dropped
# customer_id = 3 in customers has no match => dropped
inner_join(orders, customers, by = 'customer_id')

left_join() — Mantiene tutte le righe a sinistra

left_join(x, y, by='key') mantiene tutte le righe di x e inserisce i dati corrispondenti di y. Le righe di x senza corrispondenza in y ricevono NA nelle colonne di y. È la tabella a sinistra a determinare il risultato.

library(dplyr)

orders <- data.frame(
  order_id = 1:4,
  customer_id = c(1, 2, 1, 99),
  amount = c(250, 180, 320, 90)
)

customers <- data.frame(
  customer_id = c(1, 2, 3),
  name = c('Alice','Bob','Carol')
)

# Order with customer_id=99 is kept, name = NA
left_join(orders, customers, by = 'customer_id')

right_join() — Mantiene tutte le righe a destra

right_join(x, y, by='key') mantiene tutte le righe di y. Le righe di y senza corrispondenza in x ricevono NA nelle colonne di x. È l'equivalente speculare di left_join() — meno comune, poiché è possibile invertire l'ordine delle tabelle.

library(dplyr)

orders <- data.frame(
  order_id = c(1, 2),
  customer_id = c(1, 2),
  amount = c(250, 180)
)

customers <- data.frame(
  customer_id = c(1, 2, 3),
  name = c('Alice','Bob','Carol')
)

# Carol (customer_id=3) has no orders => NA for order columns
right_join(orders, customers, by = 'customer_id')

full_join() — Mantiene tutte le righe

full_join(x, y, by='key') mantiene ogni riga di entrambe le tabelle. Le righe senza corrispondenza su uno dei due lati ricevono NA nelle colonne dell'altra tabella. Lo utilizzi quando non può permettersi di perdere alcun dato.

library(dplyr)

q1 <- data.frame(product = c('A','B','C'), q1_sales = c(100, 200, 150))
q2 <- data.frame(product = c('A','C','D'), q2_sales = c(120, 160, 90))

# D appears only in q2, B only in q1 => both kept
full_join(q1, q2, by = 'product')

anti_join() — Trova le righe senza corrispondenza

anti_join(x, y, by='key') restituisce le righe di x che non hanno corrispondenza in y. Non include alcuna colonna di y. È perfetto per trovare record orfani, ordini senza corrispondenza o elementi mancanti in una tabella di riferimento.

library(dplyr)

all_employees <- data.frame(
  id = 1:5,
  name = c('Alice','Bob','Carol','Dave','Eve')
)

trained <- data.frame(id = c(1, 3, 5))

# Who has NOT completed training?
anti_join(all_employees, trained, by = 'id')

semi_join() — Filtra in base alla corrispondenza

semi_join(x, y, by='key') restituisce le righe di x che hanno una corrispondenza in y, ma NON aggiunge le colonne di y. È simile a inner_join(), ma restituisce solo le colonne di x — utile come fase di filtraggio.

library(dplyr)

products <- data.frame(
  id = 1:5,
  name = c('Widget','Gadget','Donut','Gizmo','Sprocket'),
  price = c(9.99, 24.99, 1.99, 14.99, 4.99)
)

ordered_products <- data.frame(id = c(1, 3, 5))

# Products that appear in at least one order
semi_join(products, ordered_products, by = 'id')

Unire colonne con nomi diversi

Quando le colonne chiave hanno nomi diversi in x e y, utilizzi la sintassi by = c('x_col' = 'y_col'). In questo modo il nome della colonna nella tabella a sinistra viene associato alla colonna corrispondente nella tabella a destra.

library(dplyr)

orders <- data.frame(
  order_id = 1:3,
  user_id = c(10, 20, 10),
  amount = c(100, 200, 150)
)

users <- data.frame(
  id = c(10, 20, 30),
  username = c('alice','bob','carol')
)

# orders.user_id matches users.id
left_join(orders, users, by = c('user_id' = 'id'))

Unire usando più chiavi

È possibile unire le tabelle usando più colonne passando un vettore a by. Tutte le colonne specificate devono corrispondere affinché una riga venga unita. Questo consente di gestire chiavi composite, quando nessuna singola colonna è univoca.

library(dplyr)

actual <- data.frame(
  year = c(2023, 2023, 2024, 2024),
  quarter = c('Q1','Q2','Q1','Q2'),
  sales = c(100, 120, 130, 150)
)

target <- data.frame(
  year = c(2023, 2023, 2024, 2024),
  quarter = c('Q1','Q2','Q1','Q2'),
  target = c(110, 115, 125, 145)
)

inner_join(actual, target, by = c('year', 'quarter'))

Concatenare più join

È possibile concatenare più join in un'unica pipeline usando l'operatore pipe. Costruisca una vista denormalizzata aggiungendo, un passaggio alla volta, informazioni provenienti da diverse tabelle di ricerca.

library(dplyr)

orders <- data.frame(order_id=1:3, cust_id=c(1,2,1), prod_id=c(10,10,20))
customers <- data.frame(cust_id=1:2, name=c('Alice','Bob'))
products <- data.frame(prod_id=c(10,20), product=c('Widget','Gadget'))

orders %>%
  left_join(customers, by = 'cust_id') %>%
  left_join(products, by = 'prod_id')

Gestire le colonne duplicate

Quando entrambe le tabelle hanno colonne con lo stesso nome, oltre alla chiave di join, dplyr aggiunge i suffissi .x e .y. Può personalizzarli con l'argomento suffix, quindi selezionare o rinominare le colonne secondo necessità.

library(dplyr)

current <- data.frame(id=1:3, value=c(10,20,30), date=Sys.Date())
historic <- data.frame(id=1:3, value=c(8,22,28), date=Sys.Date()-365)

# Both have 'value' and 'date' columns
result <- inner_join(current, historic, by='id',
                     suffix=c('_current','_historic'))
print(names(result))

Verifica rapida

Quale join di dplyr restituisce solo le righe della tabella a sinistra che non hanno una riga corrispondente nella tabella a destra?

Rispondi nella lezione interattiva

Riepilogo: join di dplyr

Punti chiave sui join tra più tabelle in dplyr:

inner_join() — solo le righe corrispondenti di entrambe le tabelle
left_join() — tutte le righe della tabella a sinistra; NA quando non c'è corrispondenza a destra
right_join() — tutte le righe della tabella a destra; NA quando non c'è corrispondenza a sinistra
full_join() — tutte le righe di entrambe le tabelle; NA quando non c'è corrispondenza
anti_join() — righe in x SENZA corrispondenza in y (strumento di filtraggio)
semi_join() — righe in x CON una corrispondenza in y (strumento di filtraggio)
Utilizzi by = c('x_col' = 'y_col') per nomi di colonna diversi
Utilizzi un vettore per le chiavi composite: by = c('year', 'quarter')

library(dplyr)

# Chain of joins: the typical real-world pattern
orders <- data.frame(oid=1:3, cid=c(1,2,1), pid=c(10,20,10))
customers <- data.frame(cid=1:2, name=c('Alice','Bob'))
products <- data.frame(pid=c(10,20), name=c('Widget','Gadget'), price=c(9.99,19.99))

orders %>%
  inner_join(customers, by='cid') %>%
  inner_join(products, by='pid', suffix=c('','_product')) %>%
  select(oid, name, name_product, price)

Gratis per iniziare

Impara R con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 43
Lezioni: 159

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Join tra più tabelle in dplyr» è gratuita?

Sì — il testo completo di «Join tra più tabelle in dplyr» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso R Academy, passa a CoddyKit PRO. Il corso R Academy include 4 lezioni in totale.

Cosa imparerò in «Join tra più tabelle in dplyr»?

Padroneggi inner_join, left_join, right_join, full_join e anti_join. Eserciti R Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare R Academy?

Non è richiesta alcuna esperienza precedente. R Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Join tra più tabelle in dplyr»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione R Academy?

Sì. Ogni lezione R Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a R Academy