diff --git a/slides/dplyr-grammar.Rmd b/slides/dplyr-grammar.Rmd
index 4e4453911416639ff7d501d666bee1393399b468..e9b97996145440999ba9248b81f6ebdc3e997bf3 100644
--- a/slides/dplyr-grammar.Rmd
+++ b/slides/dplyr-grammar.Rmd
@@ -3,21 +3,32 @@ title: "Einführung in dplyr-Grammatik"
subtitle: "Daten bändigen & visualisieren"
author: "B. Philipp Kleer"
date: "11. Oktober 2021"
-output:
- slidy_presentation:
- slide_level: 3
- footer: "Copyright: CC BY-SA 4.0, B. Philipp Kleer"
- css: styles/style-slides.css
- df_print: paged
- highlight: espresso
+institute: "Methodentage 2021"
+output:
+ xaringan::moon_reader:
+ css: [metropolis, metropolis-fonts, "./styles/scrollable.css"]
+ nature:
+ highlightStyle: github
+ highlightLines: true
+ countIncrementalSlides: false
+ ratio: '16:9'
+ slideNumberFormat: |
+ <div class="progress-bar-container">
+ <div class="progress-bar" style="width: calc(%current% / %total% * 100%);">
+ </div>
+ </div>`
+ navigation:
+ scroll: false
+
---
```{r setup, include=FALSE}
library("knitr")
library("rmarkdown")
library("tidyverse")
+library("DT")
-uni <- readRDS("../datasets/uni.rds")
+uni <- readRDS("./datasets/uni.rds")
opts_chunk$set(fig.path = "pics/s6-", # path for calculated figures
fig.align = "center", # alignment of figure (also possible right, left, default)
@@ -36,6 +47,13 @@ opts_chunk$set(fig.path = "pics/s6-", # path for calculated figures
rows.print = 15
)
+options(DT.options = list(pageLength = 5,
+ language = list(search = 'Filter:'),
+ autowidth = TRUE,
+ lengthChange = FALSE,
+ formatStyle = (fontSize = "40%"))
+ )
+
htmltools::tagList(
xaringanExtra::use_clipboard(
button_text = "<i class=\"fa fa-clipboard\"></i>",
@@ -44,13 +62,17 @@ htmltools::tagList(
),
rmarkdown::html_dependency_font_awesome()
)
+
```
-## Starten wir!
+# Starten wir!
+
Nun tauchen wir in die Welt von **dplyr** ein. Das Paket nutzt man oft, um Datenstrukturen zu erkunden oder Transformationen vorzunehmen. Dabei gibt es einen Grundstock an Vokabeln, die über **piping** miteinander verbunden werden.
Dazu installieren wir zuerst **tidyverse**:
+--
+
``` {r install-tidy}
install.packages("tidyverse")
library("tidyverse")
@@ -60,18 +82,45 @@ library("tidyverse")
# library("dplyr")
```
-Anschließend laden wir den Datensatz ```uni``` ins *environment*.
+---
+
+# Datensatz laden
+
+Anschließend laden wir den Datensatz `uni` ins *environment*.
+
+--
``` {r uni-load}
-uni <- readRDS("../datasets/uni.rds") #oder eigener Pfad, wenn nicht in der Cloud
+uni <- readRDS("../datasets/uni.rds")
+# oder eigener Pfad, wenn nicht in der Cloud
```
+--
+
Wir verschaffen uns einen Überblick über den Datensatz:
-``` {r inspect-data, eval=TRUE}
-uni
+
+--
+
+``` {r inspect-data}
+head(uni,
+ n = 10
+ )
+```
+
+---
+
+# Datensatz im Ãœberblick
+
+``` {r inspect-data2, eval=TRUE, echo=FALSE}
+head(uni,
+ n = 10
+ )
```
Einen Überblick über die Variablen:
+
+--
+
```{r codebook}
# ID: laufende Nummer
# mot: Studienmotivation (0 <sehr niedrig> - 10 <sehr hoch>)
@@ -82,113 +131,242 @@ Einen Überblick über die Variablen:
# term: Fachsemester
```
-## Grundvokabeln in dplyr
-In **dplyr** gibt es nicht viele Vokabeln, die aber effektiv miteinander verbunden werden können, um Daten zu sortieren bzw. zu manipulieren.
+---
+# Grundvokabeln in dplyr
+In `dplyr` gibt es nicht viele Vokabeln, die aber effektiv miteinander verbunden werden können, um Daten zu sortieren bzw. zu manipulieren.
+
+--
Die Grundvokabeln lernen wir jetzt im Folgenden erstmal ohne *piping* kennen:
+
+- `select()`
+- `slice()`
+- `filter()`
+- `arrange()`
+- `mutate()`
+- `summarise()` / `summarize()`
+- `group_by()`
-- ```select()```
-- ```slice()```
-- ```filter()```
-- ```arrange()```
-- ```mutate()```
-- ```summarise()``` / ```summarize()```
-- ```group_by()```
+---
-## select()
+# select()
Mit **select()** wählen wir Spalten aus, die uns angezeigt werden
-``` {r select, eval=TRUE}
+
+``` {r select, eval=FALSE}
select(uni, # Datenquelle
c(mot, # ausgewählte Spalten
- term
+ term
)
)
```
-## slice()
+``` {r select-unseen, eval=TRUE, echo=FALSE}
+select(uni, # Datenquelle
+ c(mot, # ausgewählte Spalten
+ term
+ )
+ ) %>%
+ datatable()
+```
+
+
+---
+
+# slice()
Demgegenüber können wir mit **slice()** Zeilen auswählen, also Fälle:
+
``` {r slice, eval=TRUE}
slice(uni, # Datenquelle
- 50:55
- ) # ausgewählte Zahlen
+ 50:55 # ausgewählte Zahlen
+ )
```
-## filter()
-Mit **filter()** können wir spezifische Fälle des Datensatzes auswählen. Zur Erinnerung die logischen Verknüpfungen in R:
-- logisches und: ```&```
-- logisches oder: ```|```
-- logisches gleich: ```==```
-- logisches ungleich: ```!=```
-- logisches größer: ```>```
-- logisches kleiner: ```<```
-- logisches kleiner gleich: ```<=```
-- logisches größer gleich: ```>=```
+---
+
+# filter()
+Mit `filter()` können wir spezifische Fälle des Datensatzes auswählen. Zur Erinnerung die logischen Verknüpfungen in R:
+
+--
+
+- logisches und: `&`
+- logisches oder: `|`
+- logisches gleich: `==`
+- logisches ungleich: `!=`
+- logisches größer: `>`
+- logisches kleiner: `<`
+- logisches kleiner gleich: `<=`
+- logisches größer gleich: `>=`
-``` {r filter, eval = TRUE}
+---
+# filter()
+Zur Anwendung:
+
+.pull-left[
+
+``` {r filter, eval = FALSE}
filter(uni, # Datenquelle
- city == "Giessen" # Filtervariable
+ city == "Giessen" # Filtervariable #<<
)
```
+]
-```{r filter2, eval=TRUE}
+--
+
+.pull-right[
+.scrollable[
+```{r filter2, eval=TRUE, echo=FALSE, size=8}
filter(uni,
city == "Frankfurt" & study == "Political Science"
)
```
+]
+]
+---
-## arrange()
+# arrange()
+.pull-left[
Mit **arrange()** können wir den Datensatz sortieren.
-``` {r arrange, eval=TRUE}
+``` {r arrange, eval=FALSE}
arrange(uni,
abi
)
```
+]
-Die Sortierung ist dabei immer aufsteigend. Dies kann man über die Funktion ```desc()``` ändert (***desc**ending*):
-``` {r arrange2, eval=TRUE}
+--
+
+.pull-right[
+.scrollable[
+
+``` {r arrange-true, eval=TRUE, echo=FALSE}
+arrange(uni,
+ abi
+ )
+```
+]
+]
+
+---
+
+# arrange()
+.pull-left[
+Die Sortierung ist dabei immer aufsteigend. Dies kann man über die Funktion ```desc()``` ändert (**desc**ending):
+``` {r arrange2, eval=FALSE}
+arrange(uni,
+ desc(abi) #<<
+ )
+```
+]
+
+--
+
+.pull-right[
+.scrollable[
+``` {r arrange2-true, eval=TRUE, echo=FALSE}
arrange(uni,
desc(abi)
)
```
+]
+]
+---
+
+# arrange()
+.pull-left[
Alternativ kann man auch einfach ein Minuszeichen vor die Variable, nach der sortiert werden soll, setzen:
-``` {r arrange3, eval=TRUE}
+``` {r arrange3, eval=FALSE}
+arrange(uni,
+ -abi #<<
+ )
+```
+]
+
+--
+
+.pull-right[
+.scrollable[
+``` {r arrange3-true, eval=TRUE, echo=FALSE}
arrange(uni,
-abi
)
```
+]
+]
+---
-## mutate()
+# mutate()
+.pull-left-narrow[
Mit **mutate()** werden neue Variablen geschaffen.
-Zum Beispiel könnten wir eine Variable schaffen, die den Abstand zum Mittelwert in der Variable ```abi``` misst:
-``` {r mutate, eval=TRUE}
+Zum Beispiel könnten wir eine Variable schaffen, die den Abstand zum Mittelwert in der Variable `abi` misst.
+
+**Wichtig:** Wir haben zwar hier die Variable `abiDist` gespeichert, aber diese nicht im Datensatz gespeichert.
+]
+
+--
+
+.pull-right-wide[
+``` {r mutate, eval=FALSE}
+mutate(uni,
+ abiDist = abi - mean(abi, #<<
+ na.rm = TRUE #<<
+ ). #<<
+ )
+```
+]
+
+.scrollable[
+``` {r mutate-true, eval=TRUE, echo=FALSE}
mutate(uni,
abiDist = abi - mean(abi,
na.rm = TRUE
)
)
```
+]
+]
-**Wichtig:** Wir haben zwar hier die Variable ```abiDist``` gespeichert, aber diese nicht im Datensatz gespeichert.
+---
+# mutate() & case_when()
Bei der Erstellung kategorieller Variablen muss man zusätzlich die Funktion **case_when()** nutzen. **case_when()** funktioniert wie eine Aneinanderreihung von *if*-Bedingung, wobei die spezifischste Bestimmung zuerst kommen sollte. (spezifisch -> allgemein).
-Im Beispiel schaffen wir eine Dummy-Variable, die anzeigt, ob die Person in Marburg studiert (```1```) oder nicht (```0```).
+--
+
+Im Beispiel schaffen wir eine Dummy-Variable, die anzeigt, ob die Person in Marburg studiert (`1`) oder nicht (`0`).
+
+--
Die Grammatik in **case_when()** ist wie folgt:
+
``` {r casewhen}
case_when(Fallauswahl ~ neuer Codewert)
```
+--
-``` {r mutate2, eval=TRUE}
+Im Beispiel:
+``` {r mutate2, eval=FALSE}
+mutate(uni,
+ dum.pum = case_when(city == "Marburg" ~ 1, # "Fallauswahl" ~ "neuer Codewert" #<<
+ city == "Gießen" ~ 0, #<<
+ city == "Frankfurt" ~ 0 #<<
+ )
+ )
+```
+
+---
+
+# mutate() & case_when()
+.scrollable[
+``` {r mutate2-true, eval=TRUE, echo=FALSE}
mutate(uni,
dum.pum = case_when(city == "Marburg" ~ 1, # "Fallauswahl" ~ "neuer Codewert"
city == "Gießen" ~ 0,
@@ -196,61 +374,110 @@ mutate(uni,
)
)
```
+]
+---
+
+# mutate() & case_when()
Auch hier könnten mehrere Bedingungen verknüpft werden: So möchten wir einen Dummy schaffen, der anzeigt, ob eine Person in Marburg Erziehungswissenschaften studiert.
+--
+
Wir würden wie folgt beginnen:
``` {r mutate3}
mutate(uni,
- dum.pum.es = case_when(city == "Marburg" & study == "Educational Science" ~ 1
+ dum.pum.es = case_when(city == "Marburg" & study == "Educational Science" ~ 1 #<<
)
)
```
-Wenn man nicht alle verschiedenen Kombinationen eingeben möchte und zum Beispiel nur eine von Interesse ist, kann man mit ```TRUE ~ 0``` allen restlichen Fällen direkt einen Wert zuordnen (aber nur denselben Wert!). Alle Kombinationen, die nicht vor ```TRUE ~ 0``` definiert wurden, erhalten automatisch den in der ```TRUE```-Zeile definierten Wert.
-``` {r mutate4, eval=TRUE}
+--
+
+Wenn man nicht alle verschiedenen Kombinationen eingeben möchte und zum Beispiel nur eine von Interesse ist, kann man mit `TRUE ~ 0` allen restlichen Fällen direkt einen Wert zuordnen (aber nur denselben Wert!). Alle Kombinationen, die nicht vor `TRUE ~ 0` definiert wurden, erhalten automatisch den in der `TRUE`-Zeile definierten Wert.
+
+--
+
+``` {r mutate4, eval=FALSE}
+mutate(uni,
+ dum.pum.es = case_when(city == "Marburg" & study == "Educational Science" ~ 1,
+ TRUE ~ 0 #<<
+ )
+ )
+```
+
+---
+
+# mutate() & case_when()
+.scrollable[
+``` {r mutate4-true, eval=TRUE, echo=FALSE}
mutate(uni,
dum.pum.es = case_when(city == "Marburg" & study == "Educational Science" ~ 1,
TRUE ~ 0
)
)
```
+]
-## summarize()
-Mit **summarize()** können vereinfacht erste Einblicke in die Daten erfolgen. So könnten wir uns z.B. den Mittelwert von ```term``` ausgeben lassen.
+---
+
+# summarise()
+Mit **summarise()** (oder **summarize()**) können vereinfacht erste Einblicke in die Daten erfolgen. So könnten wir uns z.B. den Mittelwert von `term` ausgeben lassen.
+
+--
```{r summarize, eval=TRUE}
-summarize(uni,
- mean(term)
+summarise(uni,
+ mean(term) #<<
)
```
-In **summarize()** können verschiedene Funktionen genutzt werden, die auf die Variablen im Datensatz angewendet werden können. Auch können direkt mehrere Werte ausgegeben werden. **Wichtig:** Das Ausgabe-Format ist immer ein *tibble*.
+--
+
+In **summarise()** können verschiedene Funktionen genutzt werden, die auf die Variablen im Datensatz angewendet werden können. Auch können direkt mehrere Werte ausgegeben werden.
+
+--
+
+**Wichtig:** Das Ausgabe-Format ist immer ein *tibble*.
+
```{r summarize2, eval=TRUE}
-summarize(uni,
+summarise(uni,
mean(term),
mean(mot)
)
```
-Die Unterfunktion **summarize_if()** bietet dazu die Möglichkeit leicht auf eine Gruppe von Variablen Funktionen anzuwenden, also zum Beispiel auf alle numerischen Variablen:
+---
+
+# summarise_if()
+Die Unterfunktion **summarise_if()** bietet dazu die Möglichkeit leicht auf eine Gruppe von Variablen Funktionen anzuwenden, also zum Beispiel auf alle numerischen Variablen:
+
+--
+
``` {r summarize3, eval=TRUE}
-summarize_if(uni,
- is.numeric,
+summarise_if(uni,
+ is.numeric, #<<
list(mean = mean,
sd = sd
)
)
```
-Wer weiß, warum hier teils ```NA``` angezeigt wird?
+--
+Wer weiß, warum hier teils `NA` angezeigt wird?
+
+---
+
+# summarise_at()
Die Unterfunktion **summarise_at()** bietet die Möglichkeit nur bei bestimmten Variablen die Funktion anzuwenden:
+
+--
+
``` {r summarize4, eval=TRUE}
-summarize_at(uni,
- vars(mot,
- abi,
- term
+summarise_at(uni,
+ vars(mot, #<<
+ abi, #<<
+ term #<<
),
list(mean = mean,
sd = sd
@@ -258,61 +485,128 @@ summarize_at(uni,
)
```
-## group_by()
-Mit **group_by()** kann der Datensatz gruppiert werden, also zum Beispiel nach eine kategoriellen Variable. In ```uni```-Datensatz zum Beispiel nach ```study```:
-``` {r groupby, eval=TRUE}
+---
+
+# group_by()
+.pull-left[
+Mit **group_by()** kann der Datensatz gruppiert werden, also zum Beispiel nach eine kategoriellen Variable. In `uni`-Datensatz zum Beispiel nach `study`:
+
+``` {r groupby, eval=FALSE}
+group_by(uni,
+ study
+ )
+```
+
+Was sehen wir?
+]
+
+.pull-right[
+.scrollable[
+``` {r groupby-true, eval=TRUE, echo=FALSE}
group_by(uni,
study
)
```
+]
+]
-Was sehen wir? **Nichts!**
+???
+Antwort: **Nichts!**
+---
+
+# group_by()
**group_by()** macht nichts weiter als die Daten zu gruppieren, die Ausgabe verändert sich dabei erstmal nicht. Erst in Kombination mit weiteren Funktionen, wird dies sichtbar:
+--
+
```{r groupby2, eval=TRUE}
summarize(group_by(uni,
study
),
- mean(term)
+ mean(term) #<<
)
```
-Jetzt haben wir für jeden Studienort einen Mittelwert für das Fachsemester (```term```).
+--
+
+Jetzt haben wir für jeden Studienort einen Mittelwert für das Fachsemester (`term`).
+
+--
+
+**Wichtig**: Wenn Daten gespeichert oder übergeben werden, sollte am Ende die Befehlskette immer mit `ungroup()` enden, um die Datenteilung nicht zu übergeben!
+
+---
+
+class: inverse, mline, center, middle
-**Wichtig:* Wenn Daten gespeichert oder übergeben werden, sollte am Ende die Befehlskette immer mit ```ungroup()``` enden, um die Datenteilung nicht zu übergeben!
+# Piping `%>%`
-## Piping
+---
+
+# Pipes mit tidyverse
Mit den sogenannte *pipes* können Ergebnisse von Ausführungsschritten weitergegeben werden. Dies ist vorteilhaft, da so verschiedene Schritte direkt ausgeführt werden können. Auch kann so Code oftmas leichter nachvollzogen werden.
-Den *pipe*-Operator ```%>%``` kann man einfach per Tastenkürzel hinzufügen (```Strg```/```Cmd``` + ```Shift``` + ```M```).
+--
+
+Den *pipe*-Operator in `tidyverse` ist `%>%` und kann einfach per Tastenkürzel hinzugefügt werden (`Strg`/`Cmd` + `Shift` + `M`).
-Seit R Version 4.0 gibt es den Pipe-Operator auch in R Base, allerdings wird in R Base ```|>``` als *pipe*-Operator genutzt. Es kann sein, dass es bereits *packages* gibt, die damit umgehen können, allerdings benötigt das auf Entwicklerseite meist etwas Zeit.
+--
+
+Seit R Version 4.0 gibt es den Pipe-Operator auch in RBase, daher diese beiden nicht verwechseln.
+
+---
+# Pipes
Hier mal ein Beispiel: Das Ziel ist es eine Variable zu erstellen, die den Abiturschnitt pro Uni-Stadt ausgibt. Das könnte die Frage beantworten, ob besonders gute Schüler:innen einen der drei Studienorte präferieren.
+---
+
+# Beispiel Pipes
Die Schritte, die wir hierbei machen, sind folgende:
-1. Wir geben den Datensatz ```uni``` weiter.
-2. Wir gruppieren den Datensatz nach ```city```.
-3. Wir berechnen eine neue Variable ```abiMean```.
+--
+
+1. Wir geben den Datensatz `uni` weiter.
+
+--
+
+2. Wir gruppieren den Datensatz nach `city`.
+
+--
+
+3. Wir berechnen eine neue Variable `abiMean`.
+
+--
+
4. Wir heben die Gruppierung wieder auf.
+
+--
+
5./0. Wir überspeichern den alten Datensatz.
+--
+
``` {r pipe, eval=TRUE}
-uni <- uni %>% # Schritt 1 / Schritt 5/0
- group_by(city) %>% # Schritt 2
+uni <- uni %>%
+ group_by(city) %>%
mutate(abiMean = mean(abi,
na.rm = TRUE
)
- ) %>% # Schritt 4
- ungroup() #Schritt 5
+ ) %>%
+ ungroup()
table(uni$city,
uni$abiMean)
```
+---
+
+# Pipes
Alternativ könnten wir uns dies auch erstmal nur ausgeben lassen.
+
+--
+
```{r pipe2, eval=TRUE}
uni %>%
group_by(city) %>%
@@ -322,14 +616,23 @@ uni %>%
)
```
-Ein weiteres Beispiel: Wir möchten Studierende nach der Anzahl des Fachsemesters kategorisieren. Die neue Variable ```termg``` soll zwischen:
+---
+
+# Pipes
+Ein weiteres Beispiel: Wir möchten Studierende nach der Anzahl des Fachsemesters kategorisieren. Die neue Variable `termg` soll zwischen:
+
+--
- Anfänger:innen (<=2 Semester)
+
- Erfahrene (>2 & <= 6 Semester)
+
- Langzeitstudierende (>6 Semester)
unterscheiden.
+--
+
```{r pipe3, eval=TRUE}
uni <- uni %>%
mutate(termg = case_when(term <= 2 ~ "Anfänger:in",
@@ -341,8 +644,13 @@ table(uni$termg)
str(uni$termg)
```
+---
+
+# Pipes
Etwas komplexer wäre folgende Aufgabe: Wir möchten nicht die Abweichung zum Mittelwert des Abiturs in unserer gesamten Erhebung berechnen, sondern die Abweichung zum Mittelwert der einzelnen Universitäten. Damit wir die Gruppen-Mittelwerte angezeigt bekommen, berechnen wir auch eine Variable für den Gruppen-Mittelwert.
+--
+
```{r pipe4, eval=TRUE}
uni <- uni %>%
group_by(city) %>%
@@ -359,31 +667,42 @@ uni[, c("ID",
]
```
-Alternativ könnten wir die Daten auch hierarchisch nach Standort und Studienfach gruppieren und uns dann einfach die unterschiedlichen Mittelwerte mit **summarize()** ausgeben lassen:
+---
+
+# Pipes
+Alternativ könnten wir die Daten auch hierarchisch nach Standort und Studienfach gruppieren und uns dann einfach die unterschiedlichen Mittelwerte mit **summarise()** ausgeben lassen:
+
+--
```{r pipe5, eval=TRUE}
mCityStudy <- uni %>%
group_by(city,
study
) %>%
- summarize(mean(abi))
+ summarise(mean(abi))
mCityStudy
```
-## Versuchen wir es zusammen zu lösen!
+---
+
+# Versuchen wir es zusammen zu lösen!
Versucht euch mit dem Grundvokabular an folgenden Aufgaben in den Breakout-Rooms oder allein:
+--
+
1. Teile den Datensatz uni in drei Datensätze, die jeweils nur eine Universitätsstadt inkludieren.
2. Berichte die durchschnittliche Semesterzahl pro Uni und Studiengang!
3. Berechne eine Variable, die die Abweichung von der durchschnittlichen Semesterzahl nach Studienfach angibt.
-## Lab Task
+---
+
+# Lab Task
In der nächsten halbe Stunde sollt ihr euch in Gruppen (Breakout-Rooms) oder einzeln an den folgenden Aufgaben versuchen. Es müssen nicht alle Aufgaben in der Zeit geschafft werden, es geht viel mehr um die Auseinandersetzung mit dem neuen Vokabular.
-Nutzt dazu den Datensatz ```pss``` (Panem Social Survey).
+Nutzt dazu den Datensatz `pss` (Panem Social Survey).
1. Filter den Datensatz, so dass ein Subset nur mit Personen aus Distrikt 1 entsteht. Lass dir mit **pipes** jeden 150. Fall anzeigen.
@@ -396,6 +715,11 @@ Nutzt dazu den Datensatz ```pss``` (Panem Social Survey).
5. Wie stufen sich die 10 jüngsten personen auf der Links-Rechts-Selbsteinschätzung ein.
6. Gruppiere den Datensatz nach Distrikten und lasse dir deskriptive Werte für die Links-Rechts-Selbsteinschätzung ausgeben.
+
7. Zeigen sich, gruppiert nach Alter (!), deskriptive Differenzen auf der Links-Rechts-Selbsteinschätzung.
-## Das war"s!
\ No newline at end of file
+---
+
+class: inverse, mline, center, middle
+
+# Das wars!
\ No newline at end of file