Dplyr Tutorial: Slå samman och sammanfoga data i R med exempel
Evelyn Clarke
Introduktion till dataanalys
Dataanalys kan delas in i tre delar:
- Extraktion: Först måste vi samla in data från många källor och kombinera dem.
- Förvandla: Det här steget innefattar datamanipulation. När vi har konsoliderat alla datakällor kan vi börja rensa data.
- visualisera: Det sista steget är att visualisera våra data för att kontrollera oegentligheter.
En av de viktigaste utmaningarna för datavetare är datamanipulation. Data är aldrig tillgänglig i önskat format. Dataforskare måste lägga minst hälften av sin tid på att rensa och manipulera data. Det är ett av de mest kritiska uppdragen i jobbet. Om datamanipulationsprocessen inte är komplett, exakt och rigorös kommer modellen inte att fungera korrekt.
R Dplyr
R har ett bibliotek som heter dplyr för att hjälpa till vid datatransformation. Dplyr-biblioteket är i grunden skapat kring fyra funktioner för att manipulera data och fem verb för att rensa data. Efter det kan vi använda ggplot-biblioteket för att analysera och visualisera data.
Vi kommer att lära oss hur man använder dplyr-biblioteket för att manipulera en Dataram.
Slå samman data med R Dplyr
dplyr ger ett trevligt och bekvämt sätt att kombinera datauppsättningar. Vi kan ha många källor till indata, och någon gång måste vi kombinera dem. En koppling med dplyr lägger till variabler till höger om den ursprungliga datamängden.
Dplyr går med
Följande är fyra viktiga typer av kopplingar som används i dplyr för att slå samman två datamängder:
| Funktion | Mål | Argument | Flera tangenter |
|---|---|---|---|
| left_join() | Slå samman två datauppsättningar. Behåll alla observationer från ursprungstabellen | data, ursprung, destination, by = "ID" | ursprung, destination, by = c(“ID”, “ID2”) |
| right_join() | Slå samman två datauppsättningar. Spara alla observationer från destinationstabellen | data, ursprung, destination, by = "ID" | ursprung, destination, by = c(“ID”, “ID2”) |
| inre koppling() | Slå samman två datauppsättningar. Exkluderar alla omatchade rader | data, ursprung, destination, by = "ID" | ursprung, destination, by = c(“ID”, “ID2”) |
| full_join() | Slå samman två datauppsättningar. Behåller alla observationer | data, ursprung, destination, by = "ID" | ursprung, destination, by = c(“ID”, “ID2”) |
Vi kommer att studera alla typer av kopplingar via ett enkelt exempel.
Först och främst bygger vi två datamängder. Tabell 1 innehåller två variabler, ID och y, medan Tabell 2 samlar ID och z. I varje situation måste vi ha en nyckel-par variabel. I vårt fall är ID vår nyckel variabel. Funktionen letar efter identiska värden i båda tabellerna och binder de returnerande värdena till höger om tabell 1.
library(dplyr) df_primary <- tribble( ~ID, ~y, "A", 5, "B", 5, "C", 8, "D", 0, "F", 9) df_secondary <- tribble( ~ID, ~z, "A", 30, "B", 21, "C", 22, "D", 25, "E", 29)
Dplyr left_join()
Det vanligaste sättet att slå samman två datauppsättningar är att använda funktionen left_join(). Vi kan se från bilden nedan att nyckelparet perfekt matchar raderna A, B, C och D från båda datamängderna. E och F är dock över. Hur behandlar vi dessa två observationer? Med left_join() kommer vi att behålla alla variabler i den ursprungliga tabellen och tar inte hänsyn till de variabler som inte har ett nyckelpar i destinationstabellen. I vårt exempel finns inte variabeln E i tabell 1. Därför kommer raden att tas bort. Variabeln F kommer från ursprungstabellen; den kommer att behållas efter left_join() och returnerar NA i kolumnen z. Figuren nedan återger vad som kommer att hända med en left_join().
Exempel på dplyr left_join()
left_join(df_primary, df_secondary, by ='ID')
Produktion:
## # A tibble: 5 x 3 ## ID y.x y.y ## <chr> <dbl> <dbl> ## 1 A 5 30 ## 2 B 5 21 ## 3 C 8 22 ## 4 D 0 25 ## 5 F 9 NA
Dplyr right_join()
Funktionen right_join() fungerar precis som left_join(). Den enda skillnaden är att raden tappas. Värdet E, tillgängligt i destinationsdataramen, finns i den nya tabellen och tar värdet NA för kolumnen y.
Exempel på dplyr right_join()
right_join(df_primary, df_secondary, by = 'ID')
Produktion:
## # A tibble: 5 x 3 ## ID y.x y.y ## <chr> <dbl> <dbl> ## 1 A 5 30 ## 2 B 5 21 ## 3 C 8 22 ## 4 D 0 25 ## 5 E NA 29
Dplyr inner_join()
När vi är 100 % säkra på att de två datamängderna inte kommer att matcha, kan vi överväga att återvända endast rader som finns i båda dataset. Detta är möjligt när vi behöver en ren datauppsättning eller när vi inte vill tillskriva saknade värden med medelvärdet eller medianen.
Inner_join() kommer för att hjälpa. Den här funktionen exkluderar de omatchade raderna.
Exempel på dplyr inner_join()
inner_join(df_primary, df_secondary, by ='ID')
Produktion:
## # A tibble: 4 x 3 ## ID y.x y.y ## <chr> <dbl> <dbl> ## 1 A 5 30 ## 2 B 5 21 ## 3 C 8 22 ## 4 D 0 25
Dplyr full_join()
Slutligen behåller funktionen full_join() alla observationer och ersätter saknade värden med NA.
Exempel på dplyr full_join()
full_join(df_primary, df_secondary, by = 'ID')
Produktion:
## # A tibble: 6 x 3 ## ID y.x y.y ## <chr> <dbl> <dbl> ## 1 A 5 30 ## 2 B 5 21 ## 3 C 8 22 ## 4 D 0 25 ## 5 F 9 NA ## 6 E NA 29
Flera nyckelpar
Sist men inte minst kan vi ha flera nycklar i vår datauppsättning. Tänk på följande dataset där vi har årtal eller en lista över produkter köpta av kunden.
Om vi försöker slå samman båda tabellerna ger R ett fel. För att råda bot på situationen kan vi skicka två nyckelparsvariabler. Det vill säga ID och år som visas i båda datamängderna. Vi kan använda följande kod för att slå samman tabell1 och tabell 2
df_primary <- tribble(
~ID, ~year, ~items,
"A", 2015,3,
"A", 2016,7,
"A", 2017,6,
"B", 2015,4,
"B", 2016,8,
"B", 2017,7,
"C", 2015,4,
"C", 2016,6,
"C", 2017,6)
df_secondary <- tribble(
~ID, ~year, ~prices,
"A", 2015,9,
"A", 2016,8,
"A", 2017,12,
"B", 2015,13,
"B", 2016,14,
"B", 2017,6,
"C", 2015,15,
"C", 2016,15,
"C", 2017,13)
left_join(df_primary, df_secondary, by = c('ID', 'year'))
Produktion:
## # A tibble: 9 x 4 ## ID year items prices ## <chr> <dbl> <dbl> <dbl> ## 1 A 2015 3 9 ## 2 A 2016 7 8 ## 3 A 2017 6 12 ## 4 B 2015 4 13 ## 5 B 2016 8 14 ## 6 B 2017 7 6 ## 7 C 2015 4 15 ## 8 C 2016 6 15 ## 9 C 2017 6 13
Datarensningsfunktioner i R
Följande är de fyra viktiga funktionerna för att städa (rensa) data:
| Funktion | Mål | Argument |
|---|---|---|
| samla() | Förvandla data från bred till lång | (data, nyckel, värde, na.rm = FALSE) |
| sprida() | Förvandla data från lång till bred | (data, nyckel, värde) |
| separat() | Dela en variabel i två | (data, col, into, sep= “”, remove = TRUE) |
| enhet() | Förena två variabler till en | (data, kol, konc ,sep= “”, remove = TRUE) |
Vi använder tidyrbiblioteket. Detta bibliotek tillhör bibliotekets samling för att manipulera, rengöra och visualisera data. Om vi installerar R med anaconda är biblioteket redan installerat. Vi hittar biblioteket här, https://anaconda.org/r/r-tidyr.
Om det inte redan är installerat, skriv in följande kommando för att installera tidyr:
install tidyr : install.packages("tidyr")
samla()
Syftet med funktionen gather() är att omvandla data från bred till lång.
syntax
gather(data, key, value, na.rm = FALSE) Arguments: -data: The data frame used to reshape the dataset -key: Name of the new column created -value: Select the columns used to fill the key column -na.rm: Remove missing values. FALSE by default
Exempelvis
Nedan kan vi visualisera konceptet att omforma bred till lång. Vi vill skapa en enda kolumn med namnet tillväxt, fylld av raderna med kvartalsvariablerna.
library(tidyr)
# Create a messy dataset
messy <- data.frame(
country = c("A", "B", "C"),
q1_2017 = c(0.03, 0.05, 0.01),
q2_2017 = c(0.05, 0.07, 0.02),
q3_2017 = c(0.04, 0.05, 0.01),
q4_2017 = c(0.03, 0.02, 0.04))
messy
Produktion:
## country q1_2017 q2_2017 q3_2017 q4_2017 ## 1 A 0.03 0.05 0.04 0.03 ## 2 B 0.05 0.07 0.05 0.02 ## 3 C 0.01 0.02 0.01 0.04
# Reshape the data tidier <-messy %>% gather(quarter, growth, q1_2017:q4_2017) tidier
Produktion:
## country quarter growth ## 1 A q1_2017 0.03 ## 2 B q1_2017 0.05 ## 3 C q1_2017 0.01 ## 4 A q2_2017 0.05 ## 5 B q2_2017 0.07 ## 6 C q2_2017 0.02 ## 7 A q3_2017 0.04 ## 8 B q3_2017 0.05 ## 9 C q3_2017 0.01 ## 10 A q4_2017 0.03 ## 11 B q4_2017 0.02 ## 12 C q4_2017 0.04
I funktionen gather() skapar vi två nya variabler kvartal och tillväxt eftersom vår ursprungliga datauppsättning har en gruppvariabel: dvs land och nyckel-värdeparen.
sprida()
Funktionen spread() gör motsatsen till gather.
syntax
spread(data, key, value) arguments: data: The data frame used to reshape the dataset key: Column to reshape long to wide value: Rows used to fill the new column
Exempelvis
Vi kan omforma den snyggare datamängden tillbaka till rörig med spread()
# Reshape the data messy_1 <- tidier %>% spread(quarter, growth) messy_1
Produktion:
## country q1_2017 q2_2017 q3_2017 q4_2017 ## 1 A 0.03 0.05 0.04 0.03 ## 2 B 0.05 0.07 0.05 0.02 ## 3 C 0.01 0.02 0.01 0.04
separat()
Funktionen separate() delar upp en kolumn i två enligt en separator. Den här funktionen är användbar i vissa situationer där variabeln är ett datum. Vår analys kan kräva fokus på månad och år och vi vill dela upp kolumnen i två nya variabler.
syntax
separate(data, col, into, sep= "", remove = TRUE) arguments: -data: The data frame used to reshape the dataset -col: The column to split -into: The name of the new variables -sep: Indicates the symbol used that separates the variable, i.e.: "-", "_", "&" -remove: Remove the old column. By default sets to TRUE.
Exempelvis
Vi kan dela upp kvartalet från året i den snyggare datamängden genom att använda separat()-funktionen.
separate_tidier <-tidier %>%
separate(quarter, c("Qrt", "year"), sep ="_")
head(separate_tidier)
Produktion:
## country Qrt year growth ## 1 A q1 2017 0.03 ## 2 B q1 2017 0.05 ## 3 C q1 2017 0.01 ## 4 A q2 2017 0.05 ## 5 B q2 2017 0.07 ## 6 C q2 2017 0.02
förena()
Funktionen unite() sammanfogar två kolumner till en.
syntax
unit(data, col, conc ,sep= "", remove = TRUE) arguments: -data: The data frame used to reshape the dataset -col: Name of the new column -conc: Name of the columns to concatenate -sep: Indicates the symbol used that unites the variable, i.e: "-", "_", "&" -remove: Remove the old columns. By default, sets to TRUE
Exempelvis
I exemplet ovan skilde vi kvartal från år. Tänk om vi vill slå ihop dem. Vi använder följande kod:
unit_tidier <- separate_tidier %>% unite(Quarter, Qrt, year, sep ="_") head(unit_tidier)
Produktion:
## country Quarter growth ## 1 A q1_2017 0.03 ## 2 B q1_2017 0.05 ## 3 C q1_2017 0.01 ## 4 A q2_2017 0.05 ## 5 B q2_2017 0.07 ## 6 C q2_2017 0.02
Sammanfattning
- Dataanalys kan delas in i tre delar: Extraktion, Transformera och Visualisera.
- R har ett bibliotek som heter dplyr för att hjälpa till vid datatransformation. Dplyr-biblioteket är i grunden skapat kring fyra funktioner för att manipulera data och fem verb för att rensa data.
- dplyr ger ett trevligt och bekvämt sätt att kombinera datauppsättningar. En koppling med dplyr lägger till variabler till höger om den ursprungliga datamängden.
- Det fina med dplyr är att den hanterar fyra typer av sammanfogningar som liknar SQL:
- left_join() – Att slå samman två datamängder och behålla alla observationer från ursprungstabellen.
- right_join() – Att slå samman två datauppsättningar och behålla alla observationer från destinationstabellen.
- inre koppling() – För att slå samman två datauppsättningar och exkludera alla omatchade rader.
- full_join() – Att slå samman två datamängder och behålla alla observationer.
- Med hjälp av tidyr-biblioteket kan du transformera en datauppsättning med hjälp av följande funktioner:
- samla(): Förvandla data från bred till lång.
- sprida(): Förvandla data från lång till bred.
- separat(): Dela en variabel i två.
- enhet(): Förena två variabler till en.
