dplyr in R Tutorial: Daten zusammenführen und verknüpfen mit Beispielen
Evelyn Clarke
⚡ Intelligente Zusammenfassung
dplyr verknüpft und verbindet Dataframes in R mit vier Funktionen: left_join(), right_join(), inner_join() und full_join(). Das zugehörige Paket tidyr formt das Ergebnis anschließend mit gather(), spread(), separat() und unite() um.
Einführung in die Datenanalyse
Vor jedem Beitritt oder Reshaping Das Verb ist sinnvoll, es hilft zu erkennen, wo Datenmanipulation ihren Platz hat. Datenanalyse lässt sich in drei Teile unterteilen:
- Extrahierung: Zuerst müssen wir die Daten aus vielen Quellen sammeln und kombinieren.
- Transformieren: Dieser Schritt beinhaltet die Datenmanipulation. Sobald wir alle Datenquellen konsolidiert haben, können wir mit der Bereinigung der Daten beginnen.
- Visualize: Der letzte Schritt besteht darin, unsere Daten zu visualisieren, um Unregelmäßigkeiten zu überprüfen.
Das folgende Diagramm zeigt, wie die drei Phasen miteinander verbunden sind.
Eine der größten Herausforderungen für Data Scientists ist die Datenmanipulation. Daten liegen nie im gewünschten Format vor. Data Scientists müssen daher mindestens die Hälfte ihrer Arbeitszeit mit der Bereinigung und Manipulation der Daten verbringen. Dies ist eine der wichtigsten Aufgaben in ihrem Beruf. Ist die Datenmanipulation nicht vollständig, präzise und sorgfältig, funktioniert das Modell nicht korrekt.
R dplyr
R verfügt über das Paket dplyr zur Datentransformation. Es basiert auf wenigen Kernfunktionen – filter(), select(), arrange(), mutate() und summarise() – sowie einer Reihe von Join-Funktionen. Sobald die Daten aufbereitet sind, können sie mit ggplot2 visualisiert werden.
Wir werden lernen, wie man das dplyr-Paket verwendet, um ein DatenrahmenFalls R noch nicht installiert ist, folgen Sie den Anweisungen. Einrichtungsschritte für R und RStudioFühren Sie anschließend install.packages(“dplyr”) aus.
Daten mit dplyr zusammenführen
dplyr bietet eine schöne und bequeme Möglichkeit, Datensätze zu kombinieren. Möglicherweise haben wir viele Eingabedatenquellen und irgendwann müssen wir diese kombinieren. Ein Join mit dplyr fügt Variablen rechts vom Originaldatensatz hinzu.
dplyr tritt bei
Im Folgenden werden vier wichtige Join-Typen beschrieben, die in dplyr zum Zusammenführen zweier Datensätze verwendet werden. Alle vier benötigen dieselben Argumente – die beiden Tabellen und den Schlüssel – und unterscheiden sich nur darin, welche nicht übereinstimmenden Zeilen erhalten bleiben:
| Funktion | Ziel | Argumente | Mehrere Schlüssel |
|---|---|---|---|
| left_join() | Zwei Datensätze zusammenführen. Behalten Sie alle Beobachtungen aus der Ursprungstabelle bei | x, y, by = “ID” | x, y, by = c(“ID”, “ID2”) |
| right_join() | Zwei Datensätze zusammenführen. Behalten Sie alle Beobachtungen aus der Zieltabelle | x, y, by = “ID” | x, y, by = c(“ID”, “ID2”) |
| inner_join() | Zwei Datensätze zusammenführen. Alle nicht übereinstimmenden Zeilen ausschließen. | x, y, by = “ID” | x, y, by = c(“ID”, “ID2”) |
| full_join() | Zwei Datensätze zusammenführen. Alle Beobachtungen beibehalten. | x, y, by = “ID” | x, y, by = c(“ID”, “ID2”) |
Diese vier Verben entsprechen den Verknüpfungen LINKS, RECHTS, INNER und VOLLSTÄNDIG OUTER. SQLBase R erzielt dieselben Ergebnisse durch die Argumente all, all.x und all.y von verschmelzen().
Wir werden alle Join-Typen anhand eines einfachen Beispiels untersuchen.
Zunächst erstellen wir zwei Datensätze. Tabelle 1 enthält die beiden Variablen ID und y, während Tabelle 2 die Variablen ID und z erfasst. In jedem Fall benötigen wir eine Schlüsselpaar Variable. In unserem Fall ist ID unser Haupt Die Funktion sucht in beiden Tabellen nach identischen Werten und fügt die zurückgegebenen Werte rechts neben Tabelle 1 ein. Die Abbildung unten zeigt die beiden Tabellen nebeneinander.
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()
Die gebräuchlichste Methode zum Zusammenführen zweier Datensätze ist die Verwendung der Funktion `left_join()`. Die Abbildung unten zeigt, dass die Schlüsselpaare den Zeilen A, B, C und D zugeordnet sind, während E und F übrig bleiben. Mit `left_join()` werden alle Zeilen der ursprünglichen Tabelle beibehalten und die Zeilen ohne zugehöriges Schlüsselpaar in der Zieltabelle ignoriert. In unserem Beispiel existiert der Wert E nicht in Tabelle 1, daher wird diese Zeile entfernt. Der Wert F stammt aus der ursprünglichen Tabelle, wird daher nach dem `left_join()` beibehalten und in der Spalte z als NA (nicht verfügbar) angezeigt.
Beispiel für dplyr left_join()
Das folgende Diagramm veranschaulicht, was bei einem left_join() passiert.
left_join(df_primary, df_secondary, by ='ID')
Ausgang:
## # 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
Beachten Sie, dass dplyr Tabellen, die eine Spalte mit dem gleichen Namen enthalten, mithilfe der oben gezeigten Suffixe .x und .y unterscheidet.
dplyr right_join()
Die Funktion right_join() funktioniert genau wie left_join(). Der einzige Unterschied besteht darin, dass die Zeile gelöscht wurde. Der im Zieldatenrahmen verfügbare Wert E ist in der neuen Tabelle vorhanden und nimmt für die Spalte y den Wert NA an.
Beispiel für dplyr right_join()
Das untenstehende Diagramm zeigt das Spiegelbild.
right_join(df_primary, df_secondary, by = 'ID')
Ausgang:
## # 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()
Wenn nicht übereinstimmende Beobachtungen völlig nutzlos sind, können wir zurückkehren einzige die Zeilen, die in beide Datensätze. Dies ist die richtige Wahl, wenn wir einen vollständigen Datensatz benötigen und fehlende Werte nicht durch den Mittelwert oder Median ersetzen möchten.
Die Funktion inner_join() ist hier hilfreich. Sie schließt die nicht übereinstimmenden Zeilen auf beiden Seiten aus.
Beispiel für dplyr inner_join()
Das folgende Diagramm hebt die vier IDs hervor, die den Join überstehen.
inner_join(df_primary, df_secondary, by ='ID')
Ausgang:
## # 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()
Schließlich behält die Funktion full_join() alle Beobachtungen bei und ersetzt fehlende Werte durch NA.
Beispiel für dplyr full_join()
Das folgende Diagramm zeigt alle IDs aus beiden Tabellen, die den Join überstehen.
full_join(df_primary, df_secondary, by = 'ID')
Ausgang:
## # 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
Mehrere Schlüsselpaare
Zu guter Letzt können unsere Datensätze mehrere Schlüssel enthalten. Betrachten Sie den folgenden Datensatz mit Jahreszahlen und einer Liste der vom Kunden gekauften Produkte. Der Screenshot unten zeigt die beiden Tabellen sowie die Spalten „ID“ und „Jahr“, die zusammen eine Zeile identifizieren.
Wenn wir beide Tabellen nur über die ID verknüpfen, wird jedes Jahr mit jedem anderen Jahr abgeglichen, und die Zeilenanzahl explodiert. Um dies zu beheben, können wir zwei Schlüsselpaare übergeben: ID und Jahr, die in beiden Datensätzen vorkommen. Wir können den folgenden Code verwenden, um Tabelle 1 und Tabelle 2 zusammenzuführen:
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'))
Ausgang:
## # 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
Seit dplyr 1.1.0 (Januar 2023) kann derselbe Schlüssel als join_by(ID, Jahr) geschrieben werden, und dplyr warnt nun vor unerwarteten Viele-zu-Viele-Beziehungen. dplyr 1.1.0 tritt der Ankündigung bei erklärt.
Datenbereinigungsfunktionen in R
Das Zusammenführen löst nur die Hälfte des Problems, da die kombinierte Tabelle noch umstrukturiert werden muss. Im Folgenden werden die vier wichtigsten Funktionen zur Datenbereinigung aufgeführt:
| Funktion | Ziel | Argumente |
|---|---|---|
| versammeln() | Transformieren Sie die Daten von breit nach lang | (Daten, Schlüssel, Wert, na.rm = FALSE) |
| verbreiten() | Transformieren Sie die Daten von lang nach breit | (Daten, Schlüssel, Wert) |
| separate() | Teile eine Variable in zwei auf | (data, col, into, sep = “”, remove = TRUE) |
| Vereinen() | Vereinige zwei Variablen zu einer | (data, col, conc, sep = “”, remove = TRUE) |
Versionshinweis: Die Funktionen `gather()` und `spread()` wurden in tidyr 1.0.0 durch `pivot_longer()` und `pivot_wider()` ersetzt, und `separate()` wurde in tidyr 1.3.0 durch die Funktionsfamilie `separate_wider_delim()` ersetzt. Die ersetzten Funktionen funktionieren weiterhin, daher sind alle unten stehenden Beispiele gültig. Neuer Code sollte jedoch die neueren, in der Dokumentation gezeigten Funktionsfamilien bevorzugen. Tidyr-Drehvignette.unite() bleibt aktuell.
Wir verwenden das tidyr-Paket, das Teil der tidyverse-Sammlung ist, um Daten zu bearbeiten, zu bereinigen und zu visualisieren. Wenn R mit Anaconda installiert wurde, ist das Paket bereits verfügbar. https://anaconda.org/r/r-tidyr.
Falls es noch nicht installiert ist, geben Sie den folgenden Befehl ein, um tidyr zu installieren:
install.packages("tidyr")
versammeln()
Ziel der gather()-Funktion ist es, die Daten vom breiten ins lange Format zu transformieren.
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
Beispiel
Im Folgenden können wir das Konzept von Resha visualisieren.ping Von breit zu lang. Wir möchten eine einzelne Spalte namens „Wachstum“ erstellen, die mit den Zeilen der Quartalsvariablen gefüllt wird. Die Abbildung unten zeigt links die breite und rechts die umgestaltete lange Tabelle.
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
Ausgang:
## 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
Ausgang:
## 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
In der Funktion `gather()` erstellen wir zwei neue Variablen, `quarter` und `growth`, da unser ursprünglicher Datensatz eine Gruppenvariable, `country`, und die Schlüssel-Wert-Paare enthält. In tidyr 1.0.0 und späteren Versionen wird die gleiche Umformung als `pivot_longer(messy, cols = q1_2017:q4_2017, names_to = “quarter”, values_to = “growth”)` geschrieben.
verbreiten()
Die Funktion spread() bewirkt das Gegenteil von 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
Beispiel
Mit spread() können wir den übersichtlicheren Datensatz wieder in einen unübersichtlichen umwandeln.
# Reshape the data
messy_1 <- tidier %>%
spread(quarter, growth)
messy_1
Ausgang:
## 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
Das moderne Äquivalent ist pivot_wider(tidier, names_from = quarter, values_from = growth).
separate()
Die Funktion `separate()` teilt eine Spalte anhand eines Trennzeichens in zwei Spalten auf. Diese Funktion ist hilfreich, wenn die Variable ein Datum ist. Unsere Analyse kann die Betrachtung von Monat und Jahr erfordern, und wir möchten die Spalte in zwei neue Variablen aufteilen.
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.
Beispiel
Wir können das Quartal vom Jahr im übersichtlicheren Datensatz trennen, indem wir die Funktion „separate()“ anwenden.
separate_tidier <-tidier %>% separate(quarter, c("Qrt", "year"), sep ="_") head(separate_tidier)
Ausgang:
## 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
Vereinen()
Die Funktion unite() verknüpft zwei Spalten zu einer einzigen.
Syntax
unite(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
Beispiel
Im obigen Beispiel haben wir Quartal und Jahr getrennt. Was aber, wenn wir sie zusammenführen möchten? Dazu verwenden wir folgenden Code:
unit_tidier <- separate_tidier %>%
unite(Quarter, Qrt, year, sep ="_")
head(unit_tidier)
Ausgang:
## 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
Der umstrukturierte Datenrahmen ist nun bereit für die im restlichen Teil beschriebenen Modellierungsschritte. R-Tutorialreihe.
