@@ -89,7 +89,7 @@ Die Grundvokabeln lernen wir jetzt im Folgenden erstmal ohne *piping* kennen:
- filter()
- arrange()
- mutate()
- summarize()
- summarise() / summarize()
- group_by()
## select()
...
...
@@ -222,6 +222,14 @@ summarize_if(uni,
Wer weiß, warum hier teils ```NA``` angezeigt wird?
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),
list(mean = mean,
sd = sd))
```
## 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}
...
...
@@ -274,7 +282,8 @@ Alternativ könnten wir uns dies auch erstmal nur ausgeben lassen.
```{r pipe2, eval=TRUE}
uni %>%
group_by(city) %>%
summarize(mean = mean(abi, na.rm=TRUE))
summarize(mean = mean(abi,
na.rm = TRUE))
```
Ein weiteres Beispiel: Wir möchten Studierende nach der Anzahl des Fachsemesters kategorisieren. Die neue Variable ```termg``` soll zwischen:
...
...
@@ -313,10 +322,10 @@ 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:
incremental: false #True dann jedes Bullet einzeln
collapse: true # means the text output will be merged into the R source code block
---
```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
uni <- readRDS("../datasets/uni.rds")
library("viridis")
library("foreign")
library("psych")
library("Hmisc")
library("car")
library("DescTools")
library("ggpubr")
library("ggExtra")
library("readstata13")
library("summarytools")
library("gmodels")
library("corrplot")
library("gt")
library("extrafont")
library("tidyverse")
loadfonts(quiet = TRUE)
library("knitr")
opts_chunk$set(fig.path = 'pics/s6-', # path for calculated figures
fig.align = 'center', # alignment of figure (also possible right, left, default)
fig.show = 'hold', # how to show figures: hold -> direct at the end of code chunk; animate: all plots in an animation
fig.width = 3, # figure width
fig.height = 4, # figure height
echo = TRUE, # Code is printed
eval = FALSE, # Code is NOT evaluated
warning = FALSE, # warnings are NOT displayed
message = FALSE, # messages are NOT displayed
size = "tiny", # latex-size of code chunks
background = "#E7E7E7", # background color of code chunks
comment = "", # no hashtags before output
options(width = 80),
results = "markdown",
rows.print = 15
)
example <- table(uni$study,
uni$city)
library("xaringanExtra")
```
## Zum Paket ```gt```
Das *package* ```gt``` inkludiert hilfreiche Funktionen, um Tabellen aus R in ein Format zu exportieren, das in wissenschaftlichen Arbeiten oder bei Präsentationen genutzt werden kann.
Das Paket ist umfassend und hier werden nur einführende Schritte dargestellt, die aber für erste Projekte im BA-Studium hilfreich sind. Die genaue Dokumentation findet sich in der [Benutzerdokumentation](https://gt.rstudio.com/).
Die generelle Funktionslogik erfolgt bei ```gt``` wie folgt:
<center>
</center>
All diese verschiedenen Felder können einzeln angesprochen werden und verändert werden.
Bevor wir nun mit den Beispielen starten, müssen wir das *package* selbst laden als auch ```tidyverse```.
```{r install-packages}
# falls noch nicht installiert
# install.packages("gt",
# dependencies = TRUE)
# install.packages("tidyverse",
# dependencies = TRUE)
library("gt")
library("tidyverse")
```
## Eine einfache Tabelle
Bevor wir nun Kreuztabellen darstellen, machen wir eine einfache Tabelle. Wir wollen zum Beispiel die Häufigkeiten für die *Studienmotivation* ausgeben lassen (```mot```).
```{r r-table, eval=TRUE}
table(uni$mot)
```
Zuerst müssen wir mit ```tidyverse``` ein *tibble* schaffen, dass wir an ```gt``` übergeben können. Dazu wählen wir aus dem Datensatz die Variable ```mot``` aus, gruppieren die Daten nach ```mot``` und bilden dann mit summarize die jeweilige Summe unter den Ausprägungen der Variable ```mot``` (Funktion ```n()```). Mit ```gt()``` erstellen wir dann die Tabelle:
```{r gt-table1, eval=TRUE}
uni %>%
select(mot) %>%
group_by(mot) %>%
summarise(n = n()) %>%
gt()
```
Jetzt ist das Format noch etwas unhandlich für Berichte oder Abschlussarbeiten und daher nutzen wir eine weitere Funktion aus ```tidyverse```, nämlich ```pivot_wider()```. Mit ```pivot_wider()``` können wir die Tabelle neu ordnen. Hierbei geben wir dann an, dass die Spaltennamen die Ausprägungen von ```mot``` sind und die Werte (also der Inhalt der ersten und einzigen Zeile) aus der vorherigen Spalte ```n``` entnommen werden.
```{r gt-table2, eval=TRUE}
uni %>%
select(mot) %>%
group_by(mot) %>%
summarise(n = n()) %>%
pivot_wider(names_from = mot,
values_from = n) %>%
gt()
```
Fertig ist die Darstellung der absoluten Häufigkeiten der Variable ```mot```. Dies sieht schon viel schöner aus als in der R Konsole (und ist auch als Bild exportierbar, dazu später mehr). Bevor nun einzelne Formatierungsmöglichkeiten in ```gt``` gezeigt werden, gehen wir über zu Kreuztabellen und zur Ausgabe prozentualer Häufigkeiten.
## Kreuztabelle
Wir nehmen wieder ein Beispiel aus dem Trainingsdatensatz ```uni```. Wir möchten eine Kreuztabelle zwischen Studienort (```city```) und Studienfach (```study```) erstellen. Wir möchten wissen, wie viele Personen jeweils in den einzelnen Städten die spezifischen Fächer studieren.
``` {r example-crosstable, eval=TRUE}
example
```
Wir wir sehen ist die originäre R Ausgabe nicht gut visuell dargestellt und auch die bisher genutzten Pakete erhöhten zwar die *readibility* in der Konsole, konnten aber nicht den Export unterstützen. Für die Weiterverwendung in anderen Paketen eignet sich daher das *package* ```gt```, mit dem wir Bilddateien aus den Tabellen erstellen können.
Hierbei greifen wir auf das Paket ```tidyverse``` zurück, in dem wir die Daten für das *package* ```gt``` manipulieren. Nehmen wir das Beispiel einer Kreuztabelle zwischen Studienort und Studienfach von oben. Zuerst selektieren wir zur Vereinfachung den Datensatz auf die zwei genutzten Variablen mit ```select()```. Anschließend gruppieren wir die Daten mit ```group_by()```. Danach nutzen wir ```summarize()```, um die Summen der einzelnen Kombinationen zu bilden (also die späteren Zellen der Tabelle). Bevor wir dann die Funktion ```gt()``` aufrufen, nutzen wir eine weitere Funktion aus ```tidyverse```, nämlich ```pivot_wider()```.
```{r crosstable, eval=TRUE}
uni %>%
select(study, city) %>%
group_by(city, study) %>%
summarise(n = n()) %>%
pivot_wider(names_from = city,
values_from = n)
```
Wir sehen, dass wir nun ein *tibble* haben, der in der ersten Spalte die Ausprägungen von ```study``` hat, und die zweite bis vierte Spalte stellen die Ausprägungen von ```city``` dar. In den einzelnen Feldern befindet sich die Summe der einzelnen Paare.
## Kreuztabelle mit ```gt```
Als nächstes werden wir jetzt dann die Funktion ```gt()``` aufrufen:
```{r gt-crosstable1, eval=TRUE}
uni %>%
select(study, city) %>%
group_by(city, study) %>%
summarise(n = n()) %>%
pivot_wider(names_from = city,
values_from = n) %>%
gt()
```
Nun sehen wir die erste mit ```gt``` erzeugte Kreuztabelle. Bevor wir nun in die Formatierung der Tabelle gehen, schaffen wir erst prozentuale Ausgaben. **Wichtig hierbei**: Die Konvention ist, dass wir Spaltenprozente erstellen.
```{r gt-crosstable-percent, eval = TRUE}
uni %>%
select(study, city) %>%
group_by(city, study) %>%
summarise(n = n()) %>%
mutate(prop = n / sum(n))%>% # neue prozentualer Anteil nach Spalten!
pivot_wider(names_from = city,
values_from = prop) %>%
gt()
```
Das Ergebnis irritiert etwas, denn wir haben doppelte Spalten. Dies liegt daran, dass wir weiterhin noch die absoluten Zahlen als Spalte (```n```) mit übergeben haben. Diese schließen wir einfach über ```subset()``` aus:
```{r gt-crosstable-percent2, eval=TRUE}
uni %>%
select(study, city) %>%
group_by(city, study) %>%
summarise(n = n()) %>%
mutate(prop = n / sum(n))%>% # neue prozentualer Anteil nach Spalten!
subset(select = c("city", "study", "prop")) %>% # die zwei Variablen und prop!
pivot_wider(names_from = city,
values_from = prop) %>%
gt()
```
Nun haben wir also eine Kreuztabelle mit absoluten Häufigkeiten und eine mit relativen Häufigkeiten. In den nächsten Schritten wird die Tabelle formatiert.
## Formatierungen in ```gt```
Um die Tabellen nun zu formatieren, speichern wir diese zuerst in einem Objekt: Denn R ist objektorientiert! Wir nehmen die absolute Häufigkeitstabelle der Variable ```mot``` und die prozentuale Kreuztabelle ziwschen ```city``` und ```study```. **Wichtig hierbei**: Erinnere dich an die Abbildung zu Beginn, in der alle einzelnen Bereiche einer ```gt```-Tabelle benannt waren!
```{r gt-objects, eval=TRUE}
single <- uni %>%
select(mot) %>%
group_by(mot) %>%
summarise(n = n()) %>%
pivot_wider(names_from = mot,
values_from = n) %>%
gt()
cross <- uni %>%
select(study, city) %>%
group_by(city, study) %>%
summarise(n = n()) %>%
mutate(prop = n / sum(n))%>%
subset(select = c("city", "study", "prop")) %>%
pivot_wider(names_from = city, values_from = prop) %>%
gt()
```
## Titel ändern
Zuerst fügen wir der Häufigkeitstabelle nun einen Titel hinzu, damit klar ist, um was für Daten es sich handelt.
```{r gt-single1, eval= TRUE}
single %>%
tab_header(title = "Abs. Häufigkeit von Studienmotivation")
```
## Alignment ändern
Wie wir sehen, sind die Spalten rechts ausgerichtet, dies können wir ebenfalls ändern und zentrieren es nun:
```{r gt-single2, eval = TRUE}
single %>%
tab_header(title = "Abs. Häufigkeit von Studienmotivation") %>%
cols_align(align = c("center")) # auch möglich: auto, left, right
```
## Quelle \& Fußnote hinzufügen
Oft werden unter Tabellen Quellen oder Anmerkungen angegeben, dies können wir auch ganz einfach mit ```gt```machen:
```{r gt-single3, eval=TRUE}
single %>%
tab_header(title = md("Abs. Häufigkeit von Studienmotivation")) %>%
cols_align(align = c("center")) %>%
tab_source_note(source_note = "Quelle: eigene Erhebung.") %>%
tab_source_note(source_note = md("Anmerkungen: Mit *md()* können Textformatierungen wie in Markdown vorgenommen **werden**."))
```
Manchmal möchte man zu einzelnen Werten auch eine Fußnote einfügen. Wir fügen jetzt eine Fußnote zum Wert *0* ein. Hierbei muss unterschieden werden, ob im ```cells body``` oder in den ```column labels``` eine Fußnote hinzugefügt werden soll. Wir fügen die erste Fußnote in ein ```column label``` ein und die zweite Fußnote in eine Zelle der Tabelle. Wenn wir im ```column label``` eine Fußnote hinzufügen wollen, benutzen wir in der Funktion ```tab_footnote()``` im Argument ```locations``` die Funktion ```cells_column_labels()``` und geben unter ```columns``` die spezifische Spalte an. Wenn wir in einer Zelle eine Fußnote setzen wollen, nutzen wir im Argument ```locations``` die Funktion ```cells_body()``` und geben dort in den Argumenten ```columns``` und ```rows``` die Position(en) an. Dies können auch mehrere sein (mit ```c()``` oder ```1:3```):
```{r gt-single6, eval = TRUE}
single %>%
tab_header(title = md("Abs. Häufigkeit von Studienmotivation")) %>%
cols_align(align = c("center")) %>%
tab_source_note(source_note = "Quelle: eigene Erhebung.") %>%
tab_source_note(source_note = md("Anmerkungen: Mit *md()* können Textformatierungen vorgenommen **werden**.")) %>%
tab_footnote(footnote = md("Ein Wert von *0* bedeutet **keinerlei Studienmotivation**."),
tab_footnote(footnote = md("***Dies ist einfach nur ein Test.***"),
locations = cells_body(columns = 7,
rows = 1))
```
## Spaltenbreite ändern
Als kleineres Manko sehen wir jetzt noch, dass die Spalten unterschiedlich breit sind. Dies können wir über ```cols_width()``` ändern. Hierbei können wir einzelnen Spalten aufrufen oder einen Bereich an Spalten festlegen. Wir könnten z.B. die Breite von Spalte 4 erhöhen. Hierzu nutzen wir die Hilfsfunktion ```px()```, die die Größe in Pixel angibt.
```{r gt-single-colwidth, eval=TRUE}
single %>%
tab_header(title = md("Abs. Häufigkeit von Studienmotivation")) %>%
cols_align(align = c("center")) %>%
tab_source_note(source_note = "Quelle: eigene Erhebung.") %>%
tab_source_note(source_note = md("Anmerkungen: Mit *md()* können Textformatierungen vorgenommen **werden**.")) %>%
tab_footnote(footnote = md("Ein Wert von *0* bedeutet **keinerlei Studienmotivation**."),
tab_footnote(footnote = md("***Dies ist einfach nur ein Test.***"),
locations = cells_body(columns = 7,
rows = 1)) %>%
cols_width(everything() ~ px(45))
```
## Schriftart \& Schriftgröße ändern
Innerhalb von ```tab_options()``` gibt es eine Vielzahl von Optionen. Um Schriftarten zu ändern, muss man zuvor das *package* ```extrafont``` laden.
```{r extrafont}
install.packages("extrafont",
dependencies = TRUE)
library("extrafont")
#for mac
loadfonts(quiet = TRUE)
# for windows
loadfonts(device = "win",
quiet = TRUE)
```
So könnten wir die folgenden Anpassungen zum Beispiel vornehmen. Verändere den Code in der Funktion ```tab_options()``` einfach stellenweise, um zu sehen, was sich in der Darstellung ändert:
```{r gt-single-fonts, eval = TRUE}
single %>%
tab_header(title = md("Abs. Häufigkeit von Studienmotivation")) %>%
cols_align(align = c("center")) %>%
tab_source_note(source_note = "Quelle: eigene Erhebung.") %>%
tab_source_note(source_note = md("Anmerkungen: Mit *md()* können Textformatierungen vorgenommen **werden**.")) %>%
tab_footnote(footnote = md("Ein Wert von *0* bedeutet **keinerlei Studienmotivation**"),
Dies stellt nur einen Ausschnitt der Funktionsmöglichkeiten von ```gt``` dar. Es können auch einzelne Zellen spezifisch farbig gestaltet werden und auch nach einer weiteren Variable dargestellt werden. Dazu ist ein Blick in die [Benutzerdokumentation](https://gt.rstudio.com/) hilfreich.
## Anpassungen bei Kreuztabellen
Nun wollen wir abschließend noch die Kreuztablle anpassen. Wir übernehmen die oben eingeführten Anpassungen für den Title, die Spaltenbreite und die Quelle. Die erste Spalte machen wir nun aber breiter als die anderen. Auch richten wir die erste Spalte links aus (wie nach Konvention üblich).
tab_source_note(source_note = "Quelle: eigene Erhebung.") %>%
cols_width(study ~ px(150),
everything() ~ px(100))
```
Was wir an dieser Stelle noch anpassen wollen, ist das die Zellen jeweils auf zwei Nachkommastellen gerundet werden. Dazu nutzen wir ```fmt()```. Mit dem Argument ```columns``` bestimmen wir in welchen Zeilen gerundet werden soll, mit dem Argument ```decimals``` legen wir die Dezimalstellen fest und wer das Dezimalzeichen ändern möchte, kann dies im Argument ```dec_mark``` machen (dann auch ```sep_mark``` (Tausenderzeichen) ändern:
tab_source_note(source_note = "Quelle: eigene Erhebung.") %>%
cols_width(study ~ px(150),
everything() ~ px(100)) %>%
fmt_number(columns = c(2:4),
decimals = 2,
dec_mark = ",",
sep_mark = ".") %>%
cols_label(study = md("**Studien-**<br>*fach*"))
```
So, für die Einführung in das *package* ```gt``` ist dies ausreichend. Insbesondere, wenn man eine dritte Gruppenvariable hinzufügt, bietet ```gt``` gute Möglichkeiten direkt in R publizierbare Tabellen zu generieren.
## Bevor ihr geht, speichert!
Anstatt aus dem Viewer die Dateien zu speichern, kann man diese auch direkt über ```gtsave()``` speichern. Dazu gibt man einfach den Dateinamen ein und R speichert das Objekt im *Working Directory*.
gtsave("mein-erster-gt-plot.png") # auch .html -Table möglich
```
## Labs
Ihr sehr hier drei verschiedene Tabellendarstellungen. Sucht euch eine Tabellendarstellung heraus und stellt diese mithilfe des ```gt```-*packages* nach.
incremental: false #True dann jedes Bullet einzeln
collapse: true # means the text output will be merged into the R source code block
---
```{r setup, include=FALSE}
library("knitr")
library("rmarkdown")
library("tidyverse")
uni <- readRDS("../datasets/uni.rds")
uni1 <- readRDS("../datasets/uni1.rds")
uni2 <- readRDS("../datasets/uni2.rds")
uni3 <- readRDS("../datasets/uni3.rds")
uni4 <- readRDS("../datasets/uni4.rds")
uniMacro <- readRDS("../datasets/unimacro.rds")
points <- readRDS("../datasets/points.rds")
opts_chunk$set(fig.path = 'pics/s6-', # path for calculated figures
fig.align = 'center', # alignment of figure (also possible right, left, default)
fig.show = 'hold', # how to show figures: hold -> direct at the end of code chunk; animate: all plots in an animation
fig.width = 3, # figure width
fig.height = 4, # figure height
echo = TRUE, # Code is printed
eval = FALSE, # Code is NOT evaluated
warning = FALSE, # warnings are NOT displayed
message = FALSE, # messages are NOT displayed
size = "tiny", # latex-size of code chunks
background = "#E7E7E7", # background color of code chunks
comment = "", # no hashtags before output
options(width = 80),
results = "markdown",
rows.print = 15
)
```
## Daten verknüpfen
Oftmals kommt es vor, dass die Datenerhebung in Teilschritten erfolgt oder zum Beispiel Daten aus zwei verschiedenen Zeitpunkten für die Datenanalyse zusammengefügt werden sollen. Auch bei Multi-Level-Modellen werden oftmals Makrodaten mit Mikrodaten vor der Analyse gemergt. Diese verschiedenen Varianten werden wir uns nun in ```tidyverse``` anschauen.
## Teilen eines Datensatzes
Zuerst wiederholen wir noch einmal, wie wir einen Datensatz teilen: Wir filtern die Fälle, die für unsere spätere Analyse relevant sind. Zum Beispiel wollen wir nur über Psychologie-Studierende aus Marburg forschen. Anschließend möchten wir eine neue Variable erstellen, die eine Beschreibung für die Studiendauer inkludiert (als Faktor)
Welche Funktionen müssen wir anwenden?
## Teilen eines Datensatzes
```{r split-df, eval=TRUE}
uniPumPsy <- uni %>%
filter(city == "Marburg" & study == "Psychology") %>%
Im nächsten Schritt nehmen wir nun an, dass die Datenerfassung von 4 verschiedenen Personen durchgeführt wurde und es somit 4 Teildatensätze gibt, die nun zu einem vollständigen Datensatz verbunden werden sollen. Dazu nutzen wir die Funktion ```bind_rows()```. In unserem Beispiel haben alle 4 Teildatensätze genau die gleiche Anzahl an Variablen, die dazu auch noch genau gleich benannt sind! Mit dem Argument ```.id``` erstellen wir eine Variable names ```"origin"```, die die Herkunft des Falles erfasst. Dies ist automatisch nummeriert. Mit ```mutate()``` machen wir daraus einen Faktor, der eine bessere Beschreibung beinhaltet (*coder1*, *coder2*, *coder3*, *coder4*)
## Datensätze zusammenführen (Fälle hinzufügen)
Im nächsten Schritt nehmen wir nun an, dass die Datenerfassung von 4 verschiedenen Personen durchgeführt wurde und es somit 4 Teildatensätze gibt, die nun zu einem vollständigen Datensatz verbunden werden sollen. Dazu nutzen wir die Funktion ```bind_rows()```. In unserem Beispiel haben alle 4 Teildatensätze genau die gleiche Anzahl an Variablen, die dazu auch noch genau gleich benannt sind! Mit dem Argument ```.id``` erstellen wir eine Variable names ```"origin"```, die die Herkunft des Falles erfasst. Dies ist automatisch nummeriert. Mit ```mutate()``` machen wir daraus einen Faktor, der eine bessere Beschreibung beinhaltet (*coder1*, *coder2*, *coder3*, *coder4*)
```{r merge1, eval=TRUE}
uniAll <- uni1 %>%
bind_rows(list(uni2,
uni3,
uni4),
.id = "origin") %>%
mutate(origin = factor(origin,
labels = c("coder1",
"coder2",
"coder3",
"coder4")))
table(uniAll$origin)
head(uniAll$origin)
```
Wir haben hier jetzt also aus vier Teildatensätzen einen gesamten Datensatz erstellt, der alle Fälle der vier Teildatensätze enthält. Wichtig, in diesem Fall waren alle Variablennamen gleich!
## Datensätze zusammenführen (Fälle hinzufügen)
Nun probieren wir einmal aus, was passiert, wenn es zum Beispiel in einem Teildatensatz einen Typo gibt. Zuerst erstellen wir dazu einfach zwei neue Datensätze, die jeweils nur 3 Fälle inkludieren, und unterschiedliche Variablen.
``` {r merge-prob, eval=TRUE}
uniA <- uni[1:3, 4:5]
City <- c("Giessen", "Marburg", "Marburg")
distance <- c(21, 30, 45)
uniB <- data.frame(City, distance)
head(uniA)
head(uniB)
```
Wir haben also in beiden Datensätzen die zwei Variablen, die Studienort und die Distanz zum Studienort angeben. im Datensatz ```uniB``` ist aber die Variable des Studienorts anders geschrieben. Probieren wir ```bind_rows()``` aus.
## Datensätze zusammenführen (Fälle hinzufügen)
``` {r test-bind-rows, eval=TRUE}
uniTest <- uniA %>%
bind_rows(uniB)
uniTest
```
Da die Variablennamen nicht genau gleich sind, werden nun drei Variablen geschaffen: ```city```, ```distance``` und ```City```. Wo die Variable nicht vorliegt, werden automatisch ```NAs``` erzeugt. Dies ist vorteilhaft, kann aber auch frickelig werden, wenn bei der Datensatzerstellung nicht streng nach einem Codenamen-Schema gearbeitet wurde. **Lösung**: Im Vorfeld Variablen abklären und umbenennen. Andernfalls kann man ```full_join()``` nutzen.
Dieser Ansatz ist nicht weniger aufwändig, als das Umbenennen von Spaltennamen, bietet aber dennoch eine Alternative. Mit ```full_join()``` kombinieren wir zwei Datensätze und können im Argument ```by``` angeben, welche Spalten jeweils denselben Inhalt haben. Schreibaufwand hierbei ist, dass gleiche Spaltennamen auch aufgeführt werden müssen, da ansonsten (hier im Beispiel) die Variablen ```distance.x``` und ```distance.y``` gebildet werden. Dies liegt daran, da ```full_join()``` eigentlich dafür gedacht ist, neue/zusätzliche Variablen hinzuzufügen.
In unserem Beispiel würden wir also angeben, dass aus Datensatz ```uniA``` die Spalte ```city``` gleich der Spalte ```City``` aus dem Datensatz ```uniB``` ist. Gleiches gilt für die ```distance``` Variable.
``` {r full-join, eval=TRUE}
uniTest2 <- uniA %>%
full_join(uniB,
by = c("city" = "City",
"distance" = "distance")
)
head(uniTest2)
```
## Zwei Datensätze kombinieren
Dies ist oft bei Mehrebenenansätzen nötig. Man hat Daten auf zwei verschiedenen Ebene und führt diese vor der Analyse in einem Datensatz zusammen, um alle Variablen aus einem Datensatz ansprechen zu können. Hierbei möchten wir Daten zu einem Datensatz hinzufügen, wobei wir eine Variable angeben, die als **Matching**-Variable dient. In diesem Beispiel haben wir im Datensatz ```uniMacro``` noch zusätzliche Variablen zu den jeweiligen Studienorten: Neben ```city``` und ```study``` sind hierin auch ```supervision``` (Betreuungsrelation) und ```maxsem``` (max. Seminargröße) pro Studienort und pro Studienfach eingetragen.
Für das **Mergen** von Datensätzen, kann man je nach Ausgangspunkt ```left_join()``` bzw. ```right_join()``` oder auch ```full_join()``` nutzen. Um die Daten korrekt zu mergen, müssen wir sowohl die Variable ```city``` als auch ```study``` nutzen, da sich die Makro-Variablen eben nach Studienort und Studienfach unterscheiden! Dies geben wir im Argument ```by``` an. Bei ```left_join()``` geben wir den Datensatz, an dem die Daten hinzugefügt werden sollen, per **Piping** weiter. Bei ```right_join()``` werden die Daten an den zweiten Datensatz angehängt.
## Zwei Datensätze kombinieren
Wir möchten nun die Makrodaten aus ```uniMacro``` jeweils passend auf Studienort und Studienfach in den Mikrodatensatz hinzufügen, um anschließend ein Multi-Level-Modell zu berechnen. Hierzu nutzen wir ```left_join()``` und geben im Argument ```by``` an, dass sowohl ```city``` als auch ```study``` als **Matching**-Variablen genutzt werden sollen.
Will man nur weitere Variablen in einen Datensatz hinzufügen, kann man auch hierfür ```full_join()``` nutzen. Wir haben zum Beispiel in einem weiteren Datensatz aus dem Prüfungsverwaltungssystem vor der Anonymisierung der Daten die geleisteten Creditpoints der Befragtena ausgelesen. Diese haben wir im Datensatz ```points``` getrennt gespeichert und dort ebenfalls eine ID-Variable genutzt, die auf die ID-Variable des Datensatzes ```uni``` matcht. Wir fügen jetzt die Creditpoints dem Datensatz ```uni``` mit ```full_join()``` hinzu. Schauen wir uns zuerst nochmal die zwei Datensätze an:
```{r points, eval=TRUE}
points
uni
```
Wir haben zwar in beiden Variablen eine ID-Variable, allerdings ist die Spalte unterschiedlich benannt. Wir können jetzt - wie zuvor oben - wieder im ```by```-Argument dies angeben. Diesmal wollen wir einfach schnell vorher den Spaltennamen in einem der Datensätze anpassen. Dazu nutzen wir einfach ```rename()```. Die Logik in der Funktion ist ```neuer Name = alter Name```.
``` {r add-points, eval=TRUE}
points <- points %>%
rename(ID = id)
points
```
Jetzt sind die Spaltennamen gleich und wir können die Datensätze mergen.
