R Data Frames meistern mit dplyr – Teil 1
Dieser Artikel ist Teil 1 von 2 aus der Artikelserie R Data Frames meistern mit dplyr.
Data Frames sind das Arbeitspferd von R, wenn Daten in eine Struktur gepackt werden sollen, um sie einzulesen, zu säubern, zu transformieren, zu analysieren und zu visualisieren. Abstrakt gesprochen sind Data Frames nichts anderes als Relationen, also Mengen von Tupels, gebildet aus Elementen von geeigneten Mengen.
Dieses Konzept hat sich auch außerhalb des R-Universums bestens bewährt, umzusammengesetzte Daten, Beobachtungen oder Geschäftsobjekte zu repräsentieren. Der beste Beleg für diese Aussage sind die allgegenwärtigen Relationalen Datenbanksysteme (RDBMS). Dort werden Relationen als Tabellen (Tables) oder Sichten (Views) bezeichnet, und darauf wirkt eine mächtige, imperative Abfrage- und Manipulationssprache namens Structured Query Language, kurz:
SQL.
SQL ist in meiner Wahrnehmung die Lingua Franca der Datenverarbeitung, da sie im Kern über sehr viele Softwareprodukte gleich ist und nach erstaunlich geringem Lernaufwand mächtige Auswerte- und Manipulationsoperationen an den Daten ermöglicht. Hier eine SQL-Anweisung, um eine fiktive Tabelle aller Verkäufe (SALES) nach den Top-10-Kunden in diesem Jahr zu untersuchen:
|
1 2 3 4 5 6 7 |
SELECT customer_id, SUM(sales_amt) AS amount, COUNT(*) AS n_sales, COUNT(DISTINCT product_id) AS n_products FROM sales WHERE sales_date LIKE ’2016-%’ GROUP BY customer_id ORDER BY SUM(sales_amt) DESC LIMIT 10 |
Dieser selbsterklärliche Code aus sieben Zeilen hat einen enormen Effekt: Er fast alle Verkäufe des Jahres 2016 auf Basis der Kundennummer zusammen, berechnet dabei die Summe aller Verkaufsbeträge, zählt die Anzahl der Transaktionen und der verschiedenen vom Kunden gekauften Produkte. Nach Sortierung gemäß absteigenden Umsatzes schneidet der Code nach dem 10. Kunden ab.
SQL kann aber mit der gleichen Eleganz noch viel mehr: Beispielsweise verbinden Joins die Daten mehrerer Tabellen über Fremschlüsselbeziehungen oder analytische Funktionen bestimmen Rankings und laufende Summen. Wäre es nicht toll, wenn R ähnlich effektiv mit Data Frames analoger Struktur umgehen könnte? Natürlich! Aber schon der Versuch, obige SQL-Query auf einem R Data Frame mit den althergebrachten Bordmitteln umzusetzen (subset, aggregate, merge, …), führt zu einem unleserlichen, uneleganten Stück Code.
Genau in diese Bresche springt der von vielen anderen Bibliotheken bekannte Entwickler Hadley Wickham mit seiner Bibliothek dplyr: Sie standardisiert Operationen auf Data Frames analog zu SQL-Operationen und führt zu einer wirklich selbsterklärlichen Syntax, die noch dazu sehr performant abgearbeitet wird. Ganz analog zu ggplot2, das sich an der Grammar of Graphics orientiert, spricht Wickham bei dplyr von einer Grammar of Data Manipulation. Die Funktionen zur Manipulation nennt er folgerichtig Verben.
Dabei treten naturgemäß eine Reihe von Analogien zwischen den Teilen eines SELECT-Statements und dplyr-Funktionen auf:
| SELECT-Operation | dplyr-Funktion |
| Bildung der Spaltenliste | select() |
| Bildung eines Ausdrucks | mutate() |
| WHERE-Klausel | filter() |
| GROUP BY Spaltenliste | group_by() |
| Bildung von Aggregaten wie sum() etc. | summarise() |
| HAVING-Klausel | filter() |
| ORDER BY Spaltenliste | arrange() |
| LIMIT-Klausel | slice() |
Die ersten Schritte
Ich möchte die Anwendung von dplyr mithilfe des Standard-Datensatzes Cars93
aus dem Paket MASS demonstrieren:
|
1 2 3 4 5 6 7 |
> install.packages("dplyr") > library(dplyr) > cars <- MASS::Cars93 > str(cars) ’data.frame’: 93 obs. of 27 variables: $ Manufacturer : Factor w/ 32 levels "Acura","Audi",..: 1 1 2 2 3 ... $ Model : Factor w/ 93 levels "100","190E","240",..: 49 56 ... |
Die erste Aufgabe soll darin bestehen, aus dem Data Frame alle Autos zu selektieren, die vom Hersteller “Audi” stammen und nur Model und Anzahl Passagiere auszugeben. Hier die Lösung in Standard-R und mit dplyr:
|
1 2 3 4 5 6 7 8 9 10 11 |
> # Standard R: Zu allen Audis das Model, Anzahl Insassen > subset(cars,Manufacturer=="Audi")[,c("Model","Passengers")] Model Passengers 3 90 5 4 100 6 > > # Das gleiche mit dplyr > select(filter(cars,Manufacturer=="Audi"),Model,Passengers) Model Passengers 1 90 5 2 100 6 |
Man sieht, dass die neue Funktion filter() der Zeilenselektion, also der Funktion subset() entspricht. Und die Auswahl der Ergebnisspalten, die in Standard-R durch Angabe einer Spaltenliste zwischen [ und ] erfolgt, hat in dplyr das Pendant in der Funktion select().
select() ist sehr mächtig in seinen Möglichkeiten, die Spaltenliste anzugeben. Beispielsweise funktioniert dies über Positionslisten, Namensmuster und ggf. das auch noch negiert:
|
1 2 |
select(cars, -starts_with("L")) |
Die obige Abfrage projiziert aus dem Data Frame sämtliche Spalten, die nicht mit “L” beginnen. Das scheint zunächst ein unscheinbares Feature zu sein, zahlt sich aber aus, wenn analytische Data Frames Dutzende oder Hunderte von Spalten haben, deren Bezeichnung sich nach einem logischen Namensschema richtet.
Soweit ist das noch nicht spektakulär. dplyr hilft uns in obigem Beispiel, als erstes bestimmte Datensätze zu selektieren und als zweites die interessierenden Spalten zu projizieren. dplyr ist aber bezüglich der Verarbeitung von Data Frames sehr intuitiv und funktional, sodass wir früher oder später viele Operationen auf unserem Data Frame verketten werden. So erreichen wir die Mächtigkeit von SQL und mehr. Die funktionale Syntax aus dem letzten Beispiel wird dann ganz schnell unleserlich, da die Verabeitungsreihenfolge (zuerst filter(), dann select()) nur durch Lesen des Codes von innen nach außen und von rechts nach links ersichtlich wird.
Daher geht dplyr einen Schritt weiter, indem es den eleganten Verkettungsoperator %>% aus dem magrittr-Paket importiert und zur Verfügung stellt. Dadurch werden die verschachtelten Ausdrücke in Sequenzen von Operationen gewandelt und somit sehr viel lesbarer und wartbarer:
|
1 2 3 4 5 6 7 8 9 10 11 |
select(filter(cars,Manufacturer=="Audi"),Model,Passengers) Model Passengers 1 90 5 2 100 6 > cars %>% + filter(Manufacturer=="Audi") %>% + select(Model,Passengers) Model Passengers 1 90 5 2 100 6 |
Diese in meinen Augen geniale Syntax durch den neuen Operator %>% erlaubt einen sequenziellen Aufbau der Operationen auf einem Data Frame. Benutzer der Unix-Kommandozeile werden hier leicht die Analogie zu Pipes erkennen. Ganz abstrakt kann man sagen, dass damit folgende Operationen äquivalent sind:
| Traditioneller Funktionsaufruf | Verkettung mit %>% |
| f(a,b) | a %>% f(b) |
| f(a,b,c) | a %>% f(b,c) |
| g(f(a,b),c) | a %>% f(b) %>% g(c) |
Weiteres erklärt die Dokumentation zum %>%-Operator im Paket magrittr mithilfe
des Befehls ?magrittr::‘%>%‘.
Neue Variablen
Durch die Funtionen select() und filter() können wir aus Data Frames Spalten projizieren und Zeilen selektieren. Ergebnisse neuer Ausdrücke entstehen hingegen mit dem Verb mutate():
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
> # Mit Umrechnung der Mileage in Verbrauch und des > # Kaufpreises von USD in EUR > cars2 <- + cars %>% + filter(Manufacturer=="Audi") %>% + mutate(l_100km = 235 / MPG.city, + eur = Min.Price * 1000 / 1.1) %>% + select(Model,Passengers,l_100km,eur) > cars2 Model Passengers l_100km eur 1 90 5 11.75000 23545.45 2 100 6 12.36842 28000.00 > class(cars2) [1] "data.frame" |
Im obigen Beispiel wird zunächst auf den Hersteller Audi selektiert und danach auf einen Streich zwei neue Spalten eingeführt, l_100km und eur. Durch Zuweisen auf eine neue Variable wird das fertige Ergebnis dauerhaft gespeichert. Hierbei handelt es sich wieder um ein natives Data Frame-Objekt. Die Operation transmute() arbeitet analog zu mutate(), verwirft aber nach Bildung der Ausdrücke alle nicht genannten Spalten. Somit können wir obiges Beispiel auch wie folgt schreiben:
|
1 2 3 4 5 6 7 8 9 10 |
cars3 <- + cars %>% + filter(Manufacturer=="Audi") %>% + transmute(Model = Model, Passengers = Passengers, + l_100km = 235 / MPG.city, + eur = Min.Price * 1000 / 1.1) cars3 Model Passengers l_100km eur 1 90 5 11.75000 23545.45 2 100 6 12.36842 28000.00 |
Aggregate
Neben der Selektion von Zeilen und Spalten sowie der Bildung abgeleiteter Ausdrücke ist bei Datenbanktabellen die Gruppierung und Aggregation mit GROUP BY eine sehr wichtige Operation. Dies gilt auch für Data Frames in R, wenngleich hier der Funktionsumfang über diverse Funktionen wie table() oder aggregate() verteilt ist und wenig intuitiv ist.
Hier bringt dplyr ebenfalls eine großartige Verbesserung mit. Das entsprechende Verb heißt group_by(). Diese Operation wird zusammen mit einer Spaltenliste auf ein Data Frame angewendet:
|
1 2 3 |
grp_cars <- cars %>% group_by(Manufacturer) > class(grp_cars) [1] "grouped_df" "tbl_df" "tbl" "data.frame" |
Das Ergebnis von group_by() ist ein Objekt, das “mehr” ist als ein Data Frame, sondern auch noch einige spezifische Strukturinformationen von dplyr enthält. In unserem Beispiel sind dies Indizes von Zeilen, die zum gleichen Hersteller gehören. Das ursprüngliche Data Frame wird hierbei nicht kopiert, sondern nur eingebettet.
Nach Anwenden einer group_by()-Operation ist das Data Frame optimal vorbereitet für die eigentliche Aggregation mit summarise():
|
1 2 3 4 5 6 7 8 |
> sum_cars <- cars %>% + group_by(Manufacturer) %>% + summarise(nCars = n(), avg_price = mean(Min.Price)) > str(sum_cars) Classes ‘tbl_df’, ‘tbl’ and ’data.frame’: 32 obs. of 3 variables: $ Manufacturer: Factor w/ 32 levels "Acura","Audi",..: 1 2 3 4 5 6 7 8 9 10 ... $ nCars : int 2 2 1 4 2 8 1 2 6 2 ... $ avg_price : num 21.1 28.4 23.7 20.8 35.2 ... |
Das Resultat von summarise() ist wieder ein Data Frame, das neben den ursprünglichen Gruppierungskriterien nur noch die Aggregate enthält.
Daten in Reih’ und Glied
Zwischen Relationalen Datenbanken und R-Data Frames besteht ein wesentlicher konzeptioneller Unterschied: Die Ergebnisse eines SELECT-Befehls haben keine definierte Reihenfolge, so lange die Zeilen nicht mit der Klausel ORDER BY festgelegt wird. Im Gegensatz dazu haben die Zeilen von Data Frames eine konstante Reihenfolge, die sich aus der Anordnung derWerte in den Spaltenvektoren ergibt.
Dennoch ist es manchmal wünschenswert, Data Frames umzusortieren, um eine fachliche Reihenfolge abzubilden. Hierzu dient in dplyr das Verb arrange(), das im Standard-R weitgehend der Indizierung eines Data Frames mit Ergebnissen der order()-Funktion entspricht, aber syntaktisch eleganter ist:
|
1 2 3 4 5 6 7 8 9 10 |
cars %>% + arrange(desc(Horsepower),Manufacturer) %>% + select(Manufacturer, Model, Horsepower,Min.Price) %>% + slice(1:5) Manufacturer Model Horsepower Min.Price 1 Chevrolet Corvette 300 34.6 2 Dodge Stealth 300 18.5 3 Cadillac Seville 295 37.5 4 Infiniti Q45 278 45.4 5 Mazda RX-7 255 32.5 |
Dieses Beispiel hat zum Ziel, die fünf PS-stärksten Autos zu selektieren. Die arrange()-Funktion sortiert hier zunächst absteigend nach der PS-Stärke, dann aufsteigend nach Herstellername. Die Selektion der 5 ersten Zeilen erfolgt mit der hilfreichen Funktion slice(), die aus einem Data Frame Zeilen anhand ihrer Reihenfolge selektiert.
Fazit und Ausblick
Mit dplyr wird die Arbeit mit Data Frames stark verbessert: Im Vergleich zu “nacktem” R bringt das Paket eine klarere Syntax, abgerundete Funktionalität und bessere Performance. In der Kürze dieses Artikels konnte ich dies nur oberflächlich anreissen. Daher verweise ich auf die vielen Hilfe-Seiten, Vignetten und Internet-Videos zum Paket. Im zweiten Teil dieses Artikels werde ich auf einige fortgeschrittene Features von dplyr eingehen, z.B. die Verknüpfung von Data Frames mit Joins, die Window-Funktionen und die Verwendung von Datenbanken als Backend.
Weiter zu R Data Frames meistern mit dplyr – Teil 2.
