0Pricing
R Academy · Lekcja

Łączenie wielu tabel w dplyr

Opanuj inner_join, left_join, right_join, full_join i anti_join.

Łączenie wielu tabel w dplyr to bezpłatna lekcja R Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej R Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs R Academy zawiera 4 lekcji w sumie.

Dlaczego łączyć tabele?

Rzeczywiste dane rzadko mieszczą się w jednej tabeli. Relacyjne bazy danych dzielą informacje na wiele tabel, aby uniknąć powtórzeń. Złączenia pozwalają łączyć tabele na podstawie wspólnych kluczy. Pakiet dplyr udostępnia funkcje złączeń w stylu SQL, z przejrzystą i czytelną składnią.

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() — tylko pasujące wiersze

inner_join(x, y, by='key') zwraca tylko te wiersze, dla których klucz istnieje w obu tabelach. Wiersze bez odpowiednika w drugiej tabeli są pomijane. Jest to najczęściej używany typ złączenia.

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() — zachowanie wszystkich wierszy z lewej tabeli

left_join(x, y, by='key') zachowuje wszystkie wiersze z x i uzupełnia je pasującymi danymi z y. W wierszach x, które nie mają odpowiednika w y, w kolumnach y pojawi się NA. Tabela po lewej stronie wyznacza wynik.

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() — zachowanie wszystkich wierszy z prawej tabeli

right_join(x, y, by='key') zachowuje wszystkie wiersze z y. W wierszach y, które nie mają odpowiednika w x, w kolumnach x pojawi się NA. Jest to lustrzane odbicie left_join() — używa się go rzadziej, ponieważ można zamienić kolejność tabel.

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() — zachowanie wszystkich wierszy

full_join(x, y, by='key') zachowuje każdy wiersz z obu tabel. W niedopasowanych wierszach z dowolnej strony w kolumnach drugiej tabeli pojawi się NA. Użyj tej funkcji, gdy nie możesz pozwolić sobie na utratę żadnych danych.

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() — wyszukiwanie niedopasowanych wierszy

anti_join(x, y, by='key') zwraca wiersze z x, które nie mają odpowiednika w y. Nie są dołączane żadne kolumny z y. Funkcja świetnie nadaje się do znajdowania osieroconych rekordów, niedopasowanych zamówień lub elementów brakujących w tabeli referencyjnej.

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() — filtrowanie na podstawie dopasowania

semi_join(x, y, by='key') zwraca wiersze z x, które mają odpowiednik w y, ale NIE dodaje kolumn z y. Działa podobnie jak inner_join(), lecz zwraca tylko kolumny z x — jest przydatna jako etap filtrowania.

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')

Łączenie kolumn o różnych nazwach

Gdy kolumny kluczy mają różne nazwy w x i y, użyj składni by = c('x_col' = 'y_col'). Mapuje ona nazwę kolumny w lewej tabeli na odpowiadającą jej nazwę kolumny w prawej tabeli.

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'))

Łączenie na podstawie wielu kluczy

Możesz łączyć tabele na podstawie wielu kolumn, przekazując wektor do by. Wszystkie określone kolumny muszą się zgadzać, aby wiersz został połączony. Pozwala to obsługiwać klucze złożone, w przypadku których żadna pojedyncza kolumna nie jest unikatowa.

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'))

Łączenie wielu złączeń w łańcuch

Możesz połączyć wiele złączeń w jednym potoku za pomocą operatora potoku. Twórz zdenormalizowany widok, dodając krok po kroku informacje z kilku tabel słownikowych.

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')

Obsługa zduplikowanych kolumn

Gdy obie tabele mają kolumny o tej samej nazwie (poza kluczem złączenia), dplyr dodaje przyrostki .x i .y. Możesz je dostosować za pomocą argumentu suffix, a następnie wybrać lub zmienić nazwy kolumn zgodnie z potrzebami.

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

Szybkie sprawdzenie

Które złączenie dplyr zwraca tylko te wiersze z lewej tabeli, które nie mają pasującego wiersza w prawej tabeli?

Podsumowanie: złączenia dplyr

Najważniejsze informacje o złączeniach wielu tabel w dplyr:

  • inner_join() — tylko pasujące wiersze z obu tabel
  • left_join() — wszystkie wiersze z lewej tabeli; NA w przypadku braku dopasowania w prawej
  • right_join() — wszystkie wiersze z prawej tabeli; NA w przypadku braku dopasowania w lewej
  • full_join() — wszystkie wiersze z obu tabel; NA w przypadku braku dopasowania
  • anti_join() — wiersze z x BEZ dopasowania w y (narzędzie filtrowania)
  • semi_join() — wiersze z x Z dopasowaniem w y (narzędzie filtrowania)
  • Użyj by = c('x_col' = 'y_col') dla różnych nazw kolumn
  • Użyj wektora dla kluczy złożonych: 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)

Często zadawane pytania

Czy lekcja „Łączenie wielu tabel w dplyr” jest bezpłatna?

Tak — pełny tekst „Łączenie wielu tabel w dplyr” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu R Academy, przejdź na CoddyKit PRO. Kurs R Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Łączenie wielu tabel w dplyr”?

Opanuj inner_join, left_join, right_join, full_join i anti_join. Ćwiczysz R Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć R Academy?

Nie wymagamy żadnego doświadczenia. R Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Łączenie wielu tabel w dplyr”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji R Academy?

Tak. Każda lekcja R Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Podsumowania grupowane i group_by()
  2. Funkcje okna: lag, lead, cumsum
  3. Łączenie wielu tabel w dplyr
  4. Ewaluacja tidy: {{ }} i .data
← Powrót do R Academy