020_Rahmen.Rmd

---
output:
  pdf_document: default
  html_document: default
---





\mainmatter


\setcounter{chapter}{0}
\part{Grundlagen}


# Rahmen



```{r echo = FALSE, out.width = "30%", fig.align = "center"}
knitr::include_graphics("images/FOM.jpg")
```

```{r echo = FALSE, out.width = "10%", fig.align = "center"}
knitr::include_graphics("images/licence.png")
```

```{block2, ziele-rahmen, type='rmdcaution', echo = TRUE} 
Lernziele:

- Einen Überblick über die fünf wesentliche Schritte der Datenanalyse gewinnen.
- R und RStudio installieren können.
- Einige häufige technische Probleme zu lösen wissen.
- R-Pakete installieren können.
- Einige grundlegende R-Funktionalitäten verstehen.
- Auf die Frage "Was ist Statistik?" eine Antwort geben können.


```


In diesem Skript geht es um die Praxis der Datenanalyse. Mit Rahmen ist das 
"Drumherum" oder der Kontext der eigentlichen Datenanalyse gemeint. Dazu gehören
einige praktische Vorbereitungen und ein paar Überlegungen. Zum Beispiel 
brauchen wir einen Überblick über das Thema. Voilà (Abb. \@ref(fig:fig-prozess)):

```{r fig-prozess, echo = FALSE, fig.cap = "Der Prozess der Datenanalyse"}
knitr::include_graphics("images/Rahmen/Prozess_Datenanalyse.png") 
```


Datenanalyse, praktisch betrachtet, kann man in fünf Schritte einteilen [@r4ds].
Zuerst muss man die Daten *einlesen*, die Daten also in R (oder einer anderen 
Software) verfügbar machen (laden). Fügen wir hinzu: In *schöner Form* verfügbar
machen; man nennt dies auch *tidy data* (hört sich cooler an). Sobald die Daten in geeigneter 
Form in R geladen sind, folgt das *Aufbereiten*. Das beinhaltet Zusammenfassen, 
Umformen oder Anreichern je nach Bedarf. Ein nächster wesentlicher Schritt ist 
das *Visualisieren* der Daten. Ein Bild sagt bekanntlich mehr als viele Worte. 
Schließlich folgt das *Modellieren* oder das Hypothesen prüfen: Man überlegt 
sich, wie sich die Daten erklären lassen könnten. Zu beachten ist, dass diese 
drei Schritte - Aufbereiten, Visualisieren, Modellieren - keine starre Abfolge 
sind, sondern eher ein munteres Hin-und-Her-Springen, ein aufbauendes 
Abwechseln. Der letzte Schritt ist das *Kommunizieren* der Ergebnisse der 
Analyse - nicht der Daten. Niemand ist an Zahlenwüsten interessiert; es gilt, 
spannende Einblicke zu vermitteln.

Der Prozess der Datenanalyse vollzieht sich nicht im luftleeren Raum, sondern 
ist in einem *Rahmen* eingebettet. Dieser beinhaltet praktische Aspekte - wie 
Software, Datensätze - und grundsätzliche Überlegungen - wie Ziele und 
Grundannahmen.




## Software installieren


Als Haupt-Analysewerkzeug nutzen wir R; daneben wird uns die sog. 
"Entwicklungsumgebung" RStudio einiges an komfortabler Funktionalität bescheren.
Eine Reihe von R-Paketen ("Packages"; d.h. Erweiterungen) werden wir auch 
nutzen. R ist eine recht alte Sprache; viele Neuerungen finden in Paketen 
Niederschlag, da der "harte Kern" von R lieber nicht so stark geändert wird. 
Stellen Sie sich vor: Seit 29 Jahren nutzen Sie eine Befehl, der Ihnen einen 
Mittelwert ausrechnet, sagen wir die mittlere Anzahl von Tassen Kaffee am Tag. 
Und auf einmal wird der Mittelwert anders berechnet?! Eine Welt stürzt ein! 
Naja, vielleicht nicht ganz so tragisch in dem Beispiel, aber grundsätzlich sind
Änderungen in viel benutzen Befehlen potenziell problematisch. Das ist wohl ein 
Grund, warum sich am "R-Kern" nicht so viel ändert. Die Innovationen in R 
passieren in den Paketen. Und es gibt viele davon; als ich diese Zeilen 
schreibe, sind es fast schon 10.000! Genauer: 9937 nach dieser Quelle: 
<https://cran.r-project.org/web/packages/>. Übrigens können R-Pakete auch Daten enthalten.


### R und RStudio installieren

![](images/Rahmen/Rlogo.png){ width=10% } ![](images/Rahmen/rstudiologo.png){ width=20% }

Sie können R unter 
<https://cran.r-project.org> herunterladen und installieren (für Windows, Mac 
oder Linux). RStudio finden Sie auf der gleichnamigen Homepage: 
<https://www.rstudio.com>; laden Sie die "Desktop-Version" für Ihr 
Betriebssystem herunter.

RStudio ist "nur" eine Oberfläche ("GUI") für R, mit einer R von praktischen Zusatzfunktionen. Die eigentlich Arbeit verrichtet das "normale" R, welches automatisch gestartet wird, wenn Sie RStudio starten (sofern R installiert ist).


Die Oberfläche von RStudio sieht (unter allen Betriebssystemen etwa gleich) so 
aus wie in Abbildung \@ref(fig:rstudio-screenshot) dargestellt.

```{r rstudio-screenshot, echo = FALSE, fig.cap = "RStudio"} 
knitr::include_graphics("images/Rahmen/RStudio-Screenshot.png")

```


Das *Skript-Fenster*\index{Skript-Fenster} ähnelt einem normalem Text-Editor; 
praktischerweise finden Sie aber einen Button "run", der 
die aktuelle Zeile oder die Auswahl "abschickt", d.h. in die 
Konsole gibt, wo die Syntax ausgeführt wird. Wenn Sie ein Skript-Fenster
öffnen möchten, so können Sie das Icon ![new_script](images/Rahmen/new_script.png) 
klicken (Alternativ: Ctrl-Shift-N oder File > New File > R Script).

Aus dem Fenster der *Konsole*\index{Konsole} spricht R zu uns bzw. 
wir mit R. Wird ein Befehl\index{Funktion} (synonym: *Funktion*\index{Funktion}) hier eingegeben, so führt R ihn aus. 
Es ist aber viel praktischer, Befehle in das Skript-Fenster einzugeben, als in
die Konsole. Behalten Sie dieses Fenster im Blick, wenn Sie Antwort von R erwarten.

Im Fenster *Umgebung*\index{Umgebung} (engl. "environment") zeigt R, 
welche Variablen (Objekte) vorhanden sind. Stellen Sie sich die Umgebung wie einen
Karpfenteich vor, in dem die Datensätze und andere Objekte herumschwimmen. Was nicht
in der Umgebung angezeigt wird, existiert nicht für R.

Im Fenster rechts unten werden mehrere Informationen bereit gestellt, z.B. 
werden Diagramme (Plots) dort ausgegeben. Klicken Sie mal die anderen Reiter im Fenster
rechts unten durch.



Wer Shortcuts mag, wird in RStudio überschwänglich beschenkt; der Shortcut für die Shortcuts ist `Shift-Alt-K`.


 Wenn Sie RStudio starten, startet R automatisch auch. Starten Sie daher, wenn 
Sie RStudio gestartet haben, *nicht* noch extra R. Damit hätten Sie sonst zwei 
Instanzen von R laufen, was zu Verwirrungen (bei R und beim Nutzer) führen kann.








### Pakete 

Ein Großteil der Neuentwicklungen bei R passiert in sog. 'Paketen' (engl. *packages*), das sind Erweiterungen für R. Jeder, der sich berufen fühlt, kann ein R-Paket schreiben und es zum 'R-Appstore' ([CRAN](https://cran.r-project.org/)) hochladen. Von dort kann es dann frei (frei wie in Bier) heruntergeladen werden.

Am einfachsten installiert man R-Pakete in RStudio über den Button "Install" im Reiter "Packages" (s. Abb. \@ref(fig:fig-install-packages)).

```{r fig-install-packages, echo = FALSE, fig.cap = "So installiert man Pakete in RStudio"}

knitr::include_graphics("images/Rahmen/install_packages.png")

```

Ein R-Paket, welches wir gleich benötigen, heißt `devtools`. Bitte installieren Sie es 
schon einmal (sofern noch nicht geschehen). Sie können auch folgenden Befehl verwenden, um Pakete zu installieren.

```{r eval = FALSE} 
install.packages("devtools", dependencies = TRUE) 
```

Aber einfacher geht es über die RStudio-Oberfläche.

Alle Pakete außer `devtools`, die wir hier benötigen, können über das R-Paket `prada` installiert werden. Sie müssen also nur noch das Paket `prada`installieren. Mit dem Befehl `install_prada_pckgs` (aus dem Paket `prada`) werdenn dann ggf. eine Reihe weiterer Pakete installiert. Allerdings wohnt `prada` nicht im R-Appstore (CRAN), sondern bei [Github](www.github.com)^[einer Online-Plattform, auf der man Dateien bereistellen und ihre Veränderungen nachverfolgen kann]. Um Pakete von Github zu installieren, nutzen wir diesen Befehl (Sie müssen natürlich online sein):

```{r eval = FALSE}
devtools::install_github("sebastiansauer/prada")
library(prada)
```



Sofern Sie online sind, sollte das Paket `prada` jetzt installiert sein. Installieren Sie jetzt alle Pakete, die für diesen Kurs benötigt werden mit dem Befehl `install_prada_pckgs()`.

```{block2, CRAN_mirrors, type='rmdcaution', echo = TRUE} 
Beim Installieren von 
R-Paketen könnten Sie gefragt werden, welchen "Mirror" Sie verwenden möchten. 
Das hat folgenden Hintergrund: R-Pakete sind in einer Art "App-Store", mit Namen
CRAN (Comprehense R Archive Network) gespeichert. Damit nicht ein armer, kleiner
Server überlastet wird, wenn alle Studis dieser Welt just gerade beschließen, 
ein Paket herunterzuladen, gibt es viele Kopien dieses Servers - seine Spiegelbilder (engl. "mirrors"). 
Suchen Sie sich einfach einen aus, der in der Nähe ist.

Bei der Installation von Paketen mit `install.packages("name_des_pakets")` 
sollte stets der Parameter `dependencies = TRUE` angefügt werden. Also 
`install.packages("name_des_pakets", dependencies = TRUE)`. Hintergrund ist: 
Falls das zu installierende Paket seinerseits Pakete benötigt, die noch nicht 
installiert sind (gut möglich), dann werden diese sog. "dependencies" gleich 
mitinstalliert (wenn Sie  `dependencies = TRUE` setzen).

```

Ich fasse zusammen:

1. Paket `devtools` installieren von CRAN (über RStudio -> Packages -> Install)
2. Paket `prada` installieren von Github (Syntax s. oben)
3. Alle weiteren Pakete installieren mit Befehl `install_prada_pckgs`.


Nicht vergessen: Installieren muss man eine Software *nur einmal*; *starten* 
(laden) muss man die R-Pakete jedes Mal, wenn man sie vorher geschlossen hat und wieder 
nutzen möchte. 

> Wenn Sie R bzw. RStudio schließen, werden alle Pakete ebenfalls geschlossen. Sie müssen die benötigten Pakete beim erneuten Öffnen von RStudio wieder starten.

```{r eval = FALSE} 
library(dplyr) 
```

Der Befehl bedeutet sinngemäß: "Hey R, geh in die Bücherei (library) und hole 
das Buch (package) dplyr!".


```{block2, quotation_marks, type='rmdcaution', echo = TRUE} 
Wann benutzt man bei R Anführungszeichen? Das ist etwas verwirrend im Detail, aber die Grundegel 
lautet: wenn man Text anspricht. Im Beispiel oben "library(dplyr)" ist "dplyr" 
hier erst mal für R nichts Bekanntes, weil noch nicht geladen. Demnach müssten 
*eigentlich* Anführungsstriche stehen. Allerdings meinte ein Programmierer, dass
es doch so bequemer ist. Hat er Recht. Aber bedenken Sie, dass es sich um die 
Ausnahme einer Regel handelt. Sie können also auch schreiben: library("dplyr") 
oder library('dplyr'); beides geht.

```





### Hilfe! R startet nicht!

>    Manntje, Manntje, Timpe Te,   
    Buttje, Buttje inne See,    
    myne Fru de Ilsebill    
    will nich so, as ik wol will. 


*Gebrüder Grimm, Märchen vom Fischer und seiner Frau^[<https://de.wikipedia.org/wiki/Vom_Fischer_und_seiner_Frau>]*




Ihr R startet nicht oder nicht richtig? Die drei wichtigsten Heilmittel sind:

1. Schließen Sie die Augen für eine Minute. Denken Sie an etwas Schönes und was 
Rs Problem sein könnte. 
2. Schalten Sie den Rechner aus und probieren Sie es 
morgen noch einmal. 
3. Googeln.

Sorry für die schnoddrigen Tipps. Aber: Es passiert allzu leicht, dass man 
*Fehler* wie diese macht:



```{block2, typ-fehler, type='rmdcaution', echo = TRUE} 

OH NO:

- install.packages(dplyr) 

- install.packages("dliar")

- install.packages("derpyler") 

- install.packages("dplyr")  # dependencies vergessen 

- Keine Internet-Verbindung 

- library(dplyr)  # ohne vorher zu installieren

```




Wenn R oder RStudio dann immer noch nicht starten oder nicht richtig laufen, 
probieren Sie dieses:


- Sehen Sie eine Fehlermeldung, die von einem fehlenden Paket spricht (z.B. 
"Package 'Rcpp' not available") oder davon spricht, dass ein Paket nicht 
installiert werden konnte (z.B. "Package 'Rcpp' could not be installed" oder "es
gibt kein Paket namens ‘Rcpp’" oder "unable to move temporary installation XXX 
to YYY"), dann tun Sie folgendes:

- Schließen Sie R und starten Sie es neu. 
- Installieren Sie das oder die angesprochenen Pakete^[ `install.packages("name_des_pakets", dependencies = TRUE)` oder mit dem entsprechenden Klick in RStudio]. 
- Starten Sie das entsprechende Paket mit `library(name_des_pakets)`.


- Gerade bei Windows 10 scheinen die Schreibrechte für R (und damit RStudio oder
RCommander) eingeschränkt zu sein. Ohne Schreibrechte kann R aber nicht die 
Pakete ("packages") installieren, die Sie für bestimmte R-Funktionen benötigen. 
Daher schließen Sie R bzw. RStudio und suchen Sie das Icon von R oder wenn Sie 
RStudio verwenden von RStudio. Rechtsklicken Sie das Icon und wählen Sie "als 
Administrator ausführen". Damit geben Sie dem Programm Schreibrechte. Jetzt 
können Sie etwaige fehlende Pakete installieren.

- Ein weiterer Grund, warum R bzw. RStudio die Schreibrechte verwehrt werden 
könnten (und damit die Installation von Paketen), ist ein Virenscanner. Der 
Virenscanner sagt, nicht ganz zu Unrecht: "Moment, einfach hier Software zu 
installieren, das geht nicht, zu gefährlich". Grundsätzlich gut, in diesem Fall 
unnötig. Schließen Sie R/RStudio und schalten Sie dann den Virenscanner 
*komplett* (!) aus. Öffnen Sie dann R/RStudio wieder und versuchen Sie fehlende 
Pakete zu installieren.



```{block2, imaoutdatedmodel, type='rmdcaution', echo = TRUE} 
Verwenden Sie möglichst die neueste Version von R, RStudio und Ihres Betriebssystems. Ältere Versionen führen u.U. zu Problemen; je älter, desto Problem... Updaten Sie Ihre Packages regelmäßig z.B. mit `update.packages()` 
oder dem Button "Update" bei RStudio (Reiter `Packages`).


```



### Vertiefung: Zuordnung von Paketen zu Befehlen {#funs-pckgs}


*Woher weiß man, welche Befehle (oder auch Daten) in einem Paket enthalten sind?*

Eine einfache Möglichkeit ist es, beim Reiter 'Pakete' auf den Namen eines der installierten Pakete zu klicken. Daraufhin öffnet sich die Dokumentation des Pakets und man sieht dort alle Befehle und Daten aufgeführt (s. Abbildung \@ref(fig:pakete-hilfe)). Übrigens sehen Sie dort auch die Version eines Pakets (vielleicht sagt jemand mal zu Ihnen, "Sie sind ja outdated", dann schauen Sie mal auf die die Paket-Versionen).

```{r pakete-hilfe, echo = FALSE, fig.cap = "Hier werden Sie geholfen: Die Dokumentation der R-Pakete", out.width = "50%"}

knitr::include_graphics("images/Rahmen/hilfe_pakete.png")
```


Für geladenen Pakete kann man auch den Befehl `help` nutzen, z.B. `help(ggplot2)`.


*Und umgekehrt, woher weiß ich, in welchem Paket ein Befehl 'wohnt'?*

Probieren Sie den Befehl `help.search("qplot")`, wenn Sie wissen möchten, in welchem Paket `qplot` zuhause ist. `help.search` sucht alle Hilfeseiten von *installierten* Paketen, in der der Suchbegriff irgendwie vorkommt. Um das Paket eines *geladenen* Befehl zu finden, hilft der Befehl `find`: `find("qplot")`.


Sie können auch den Befehl `find_fun`s aus dem Paket `prada` nutzen:

```{r}
prada::find_funs("select")
```


In diesem Skript sind am Ende jedes Kapitels die jeweils besprochenen (neuen) Befehle aufgeführt - inklusive ihres Paketes. Falls bei einem Befehl kein Paket angegeben ist, heißt das, dass der Befehl im 'Standard-R' wohnt - Sie müssen kein weiteres Paket laden^[Eine Liste der Pakete, die beim Standard-R enthalten sind (also bereits installiert sind) finden Sie [hier](https://stat.ethz.ch/R-manual/R-devel/doc/html/packages.html)]. Also zum Beispiel `ggplot2::qplot`: Der *Befehl* `qplot` ist im *Paket* `ggplot2` enthalten. Das Zeichen `::` trennt also Paket von Befehl.




```{block2, ziele-double-colon, type='rmdcaution', echo = TRUE} 

Manche Befehle haben Allerweltsnamen (z.B. 'filter'). Manchmal gibt es Befehle mit gleichem Namen in verschiedenen Paketen; besonders Befehle mit Allerweltsnamen (wie 'filter') sind betroffen ('mosaic::filter' vs. 'dplyr::filter'). Falls Sie von wirre Ausgaben bekommen oder diffuse Fehlermeldung kann es sein, kann es sein, dass R einen Befehl mit dem richtigen Namen aber aus dem 'falschen' Paket zieht. Geben Sie im Zweifel lieber den Namen des Pakets vor dem Paketnamen an, z.B. so `dplyr::filter`. Der 'doppelte Doppelpunnkt' trennt den Paketnamen vom Namen der Funtion.
```


Außerdem sind zu Beginn jedes Kapitels die in diesem Kapitel benötigten Pakete angegeben. Wenn sie diese Pakete laden, werden alle Befehle dieses Kapitels funktionieren^[es sei denn, sie tun es nicht].



*Wie weiß ich, ob ein Paket geladen ist?*

Wenn der Haken im Reiter 'Packages' gesetzt ist (s. Abbildung \@ref(fig:pakete-hilfe)), dann ist das Paket geladen. Sonst nicht.



### Daten

Die folgenden Datensätze sind entweder im Paket `prada` enthalten oder können aus anderen Paketen geladen werden. Um Daten aus einem (intallierten) Paket zu laden, gibt es den Befehl `data`: `data("name_datenobjekt", package = "Paketname")`. Also zum Beispiel:

```{r eval = FALSE}
data("stats_test", package = "prada")
```


Wenn ein bestimmtes Paket geladen ist, können Sie auch auf den Parameter `package = ...` verzichten, wenn ihr Datensatz in jedem Paket wohnt: Geladene Pakete werden vom Befehl `data` automatisch durchsucht. Die folgenden Datensätze nutzen wir im Rahmen dieses Kurses:


- Datensatz `profiles` aus dem R-Paket {okcupiddata} [@kim2015okcupid]; es handelt sich um Daten von einer Online-Singlebörse 
- Datensatz `stats_test` aus dem R-Paket {prada} [@Sauer_2017]; es handelt sich um Ergebnisse einer Statistikklausur (einer Probeklausur)
- Datensatz `flights` aus dem R-Paket {nycflights13} [@nycflights13]; es handelt sich um Abflüge von den New Yorker Flughäfen 
- Datensatz `wo_men`, URL: <https://osf.io/ja9dw> [@Sauer_2017a]; es handelt sich um Körper- und Schuhgröße von Studierenden
- Datensatz `extra`  aus dem R-Paket {prada} [@Sauer_2016]; es handelt sich die Ergebnisse einer Umfrage zu Extraversion
- Datensatz `titanic_train` aus dem Paket {titanic} von [kaggle](https://www.kaggle.com/c/titanic/data); es handelt sich um Überlebensraten vom Titanic-Unglück.
- Datensatz `Affairs` aus dem Paket {AER} [@fair1978theory]; es handelt sich um eine Umfrage zu außerehehlichen Affären.
- Datensatz `Werte` von @Gansser_2017 (auch im Paket {prada}); es handelt sich um Daten einer Umfrage zu Werte hinsichtlich Kaufentscheidungen.

Wie man Daten in R 'einlädt' (Studierende sagen gerne 'ins R hochladen'), besprechen wir im Kapitel \@ref(daten-einlesen). 







```{block2, data-from-github, type='rmdcaution', echo = TRUE} 

Alternativ können Sie die Daten auch im Ordner `data` im Github-Repositorium herunterladen. Gehen Sie auf die Github-Seite dieses Kurses^[<https://github.com/sebastiansauer/Praxis_der_Datenanalyse>], klicken Sie auf den großen grünen Button "Clone or download", wählen Sie dann "Download ZIP", um alle Dateien herunterzuladen. Nach dem Entzippen können Sie dann auf alle Dateien, inklusive Daten, zugreifen. 

```



## ERRRstkontakt


### R-Skript-Dateien

Ein neues *R-Skript*\index{R-Skript} im RStudio können Sie z.B. öffnen mit `File-New File-R Script`. Schreiben Sie dort Ihre R-Befehle; Sie können die Skriptdatei speichern, öffnen, ausdrucken, übers Bett hängen... R-Skripte können Sie speichern (unter `File-Save`) und öffnen. R-Skripte sind einfache Textdateien, die jeder Texteditor verarbeiten kann. 
Nur statt der Endung `.txt`, sind R-Skripte stolzer Träger der Endung `.R`. Es 
bleibt aber eine schnöde Textdatei. Geben Sie Ihren R-Skript-Dateien die Endung ".R",
damit erkennt RStudio, dass es sich um ein R-Skript handelt und bietet ein paar 
praktische Funktionen wie den "Run-Button".




### Datentypen in R

Die (für diesen Kurs) wichtigsten Datentypen von R sind in Tabelle \@ref(tab:datentypen) aufgeführt (vgl. @ligges).

```{r datentypen, echo = FALSE}
df <- readr::read_csv("includes/Datentypen.csv")

knitr::kable(df, caption = "Wichtige Datentypen in R")
```

All diese Datentypen (mit Ausnahme der leeren Menge) sind als *Vektoren*\index{Vektoren} angelegt, also mehreren Elementen (z.B. Zahlen), die zu einem Ganzen (wie in einer Liste) verknüpft sind. *Faktoren* sind ganz interessant, weil die einzelnen Ausprägungen (*Faktorstufen*\index{Faktorstufen} genannt) für R als Zahlen gespeichert sind (z.B. "Frau Müller und Herr Schorsch" = 1). Wenn ein Vektor aus 100 Mal diesem Text ("Frau Müller...") besteht, muss R nur 100 mal 1 speichern und einmal die Zuordnung, was die 1 bedeutet. Spart Speicher. Außerdem kann man definieren, was alles eine Faktorstufe ist (z.B. nur "Mann" und "Frau"). Andere Eingaben sind dann nicht möglich; das kann praktisch sein, wenn man von vornerein nur bestimmte Ausprägungen zulassen möchte. Textvariablen sind da entspannter: Jeglicher Art von Text ist erlaubt. Text ist in R immer in Anführungszeichen (einfach oder doppelt) zu setzen.


Für die praktische Datenanalyse ist der `dataframe` (*Dataframe*\index{Dataframe}; auch Datentabelle\index{Dataframe} oder Datensatz\index{Dataframe}) am wichtigsten. Grob gesagt handelt es sich dabei um eine Tabelle, wie man sie aus Excel kennt. Etwas genauer ist eine Kombination von Vektoren mit gleicher Länge, so dass eine 'rechteckige' Datenstruktur entsteht. Alle Spalten (d.h. Vektoren) haben einen Namen, so dass es 'Spaltenköpfe' gibt. Eine neuere Variante von Dataframes sind *tibbles* (Tibbles)\index{Tibbles}, die *auch* Dataframes sind, aber ein paar praktische Zusatzeigenschaften aufweisen (normale Dataframes können sich manchmal in einfache Vektoren auflösen; Tibbles tun dies nie).


### Hinweise

Unser erster Kontakt mit R! Ein paar Anmerkungen vorweg:

- R unterscheidet zwischen Groß- und Kleinbuchstaben, d.h. `Oma` und `oma` sind 
zwei verschiedene Dinge für R!
- R verwendet den Punkt `.` als 
Dezimaltrennzeichen.
- Fehlende Werte werden in R durch `NA` kodiert.
- Kommentare werden mit dem Rautezeichen `#` eingeleitet; der Rest der Zeile von von R dann ignoriert. 
- *Variablennamen*\index{Variablen} in R sollten mit Buchstaben beginnen; ansonsten dürfen nur Zahlen und Unterstriche (`_`) enthalten sein. Leerzeichen sollte man meiden. Das gilt auch für Spaltennamen.
- Um den Inhalt einer Variablen auszulesen, geben wir einfach den Namen des Objekts ein (und schicken den Befehl ab).
- Bleiben Sie konsistent, in der Art und Weise, wie Sie Ihre Syntax schreiben. Ein Vorschlag zum 'Syntax-Stil' finden Sie [hier](http://adv-r.had.co.nz/Style.html).
- Variablen einen treffenden Namen zu geben, ist nicht immer leicht, aber wichtig. Namen sollten knapp, aber aussagekräftig sein.

```
# so nicht:
var
x
dummy
objekt
dieser_name_ist_etwas_lang_vielleicht

# gut:
tips_mw
lm1
```




### Text und Variablen zuweisen

Man kann einer Variablen auch Text zuweisen (im Gegensatz zu Zahlen):

```{r hallo, eval = FALSE}
y <- "Hallo R!"
```


Man kann auch einer Variablen eine andere zuweisen:

```{r eval = FALSE}
y <- x
```

Wird jetzt y mit dem Inhalt von x überschrieben oder umgekehrt? Der Zuweisungspfeil `<-` macht die Richtung der Zuweisung ganz klar. Zwar ist in R das Gleichheitszeichen synonym zum Zuweisungspfeil erlaubt, aber der Zuweisungspfeil macht die Sache glasklar und sollte daher bevorzugt werden.


Man kann auch einer Variablen *mehr als* einen Wert zuweisen:

```{r}
x <- c(1, 2, 3)
```

Dieser Befehl erzeugt eine "Spalte" (einen Vektor). Will man einer Variablen *mehr als* einen Wert zuweisen, muss man die Werte erst in einen Vektor "zusammen binden"; das geht mit dem Befehl `c` (vom engl. "***c**ombine*").




### Funktionen aufrufen


Um einen *Befehl*\index{Befehl, Funktion} (präziser aber synonym hier: eine Funktion) aufzurufen, geben wir ihren Namen an und definieren sog. *Parameter*\index{Parameter eines R-Befehls} in einer runden Klammer, z.B. so:

```{r eval = FALSE}
wo_men <- read.csv("data/wo_men.csv")
```

Allgemein gesprochen:

```
funktionsname(parametername1 = wert1, parametername2 = wert2, ...)
```

Die drei Punkte `...` sollen andeuten, dass evtl. weitere Parameter zu übergeben wären. 
Die Reihenfolge der Parameter ist *egal* - wenn man die Parameternamen anführt. 
Ansonsten muss man sich an die Standard-Reihenfolge, die eine Funktion vorgibt, halten:

```{r read-csv-example, eval = FALSE}
#ok:
wo_men <- read.csv(file = "data/wo_men.csv", header = TRUE, sep = ",")
wo_men <- read.csv("data/wo_men.csv", TRUE, ",")
wo_men <- read.csv(header = TRUE, sep = ",", file = "data/wo_men.csv")


# ohno:
wo_men <- read.csv(TRUE, "data/wo_men.csv", ",")
```


In der Hilfe zu einem Befehl findet man die Standard-Syntax inklusive der möglichen Parameter, ihrer Reihenfolge und Standardwerten (default values) von Parametern. Zum Beispiel ist beim Befehl `read.csv` der Standardwert für `sep` mit `;` voreingestellt (schauen Sie mal in der Hilfe nach). Gibt man einen Parameter nicht an, für den ein Standardwert eingestellt ist, 'befüllt' R den Parameter mit diesem Standardwert.


### Das Arbeitsverzeichnis {#wd}


Das aktuelle Verzeichnis (Arbeitsverzeichnis; "working directory") kann man mit `getwd()` erfragen und mit `setwd()` einstellen. Komfortabler ist es aber, das aktuelle Verzeichnis per Menü zu ändern (vgl. Abb. \@ref(fig:Arbeitsverzeichnis). In RStudio: `Session > Set Working Directory > Choose Directory ...` (oder per Shortcut, der dort angezeigt wird).

```{r Arbeitsverzeichnis, echo = FALSE, fig.cap = "Das Arbeitsverzeichnis mit RStudio auswählen", out.width = "50%"}

knitr::include_graphics("images/tidy/Arbeitsverzeichnis.png")
```


Es ist praktisch, das Arbeitsverzeichnis festzulegen, denn dann kann man z.B. eine Datendatei einlesen, ohne den Pfad eingeben zu müssen:

```{r eval = FALSE}
# nicht ausführen:
daten_deutsch <- read.csv("daten_deutsch.csv", sep = ";", dec = ".")
```

R geht dann davon aus, dass sich die Datei `daten_deutsch.csv` im Arbeitsverzeichnis befindet.


Für diesen Kurs ist es sinnvoll, das Arbeitsverzeichnis in einen "Hauptordner" zu legen (z.B. "Praxis_der_Datenanalyse"), in dem Daten und sonstiges Material als Unterordner abgelegt sind.


```{block2, working-directory, type='rmdcaution', echo = TRUE} 

Übrigens: Wenn Sie keinen Pfad angeben, so geht R davon aus, dass die Daten im aktuellen Verzeichnis (dem *working directory*) liegen. 

```



## Hier werden Sie geholfen


### Wo finde ich Hilfe?

Es ist keine Schande, nicht alle Befehle der ca. 10,000 R-Pakete auswendig zu 
wissen. Schlauer ist, zu wissen, wo man Antworten findet. Hier eine Auswahl:

- Zu diesen Paketen gibt es gute "Spickzettel" (cheatsheets): ggplot2, 
RMarkdown, dplyr, tidyr. Klicken Sie dazu in RStudio auf *Help > Cheatsheets > 
...* oder gehen Sie auf <https://www.rstudio.com/resources/cheatsheets/>.

- In RStudio gibt es eine Reihe (viele) von Tastaturkürzeln (Shortcuts), die Sie
hier finden: *Tools > Keyboard Shortcuts Help*.

- Für jeden Befehl aus einem *geladenen* Paket können Sie mit `help()` die Hilfe-Dokumentation anschauen, also z.B. `help("qplot")`.

- Im Internet finden sich zuhauf Tutorials.

- Der Reiter "Help" bei RStudio verweist auf die Hilfe-Seite des jeweiligen Pakets bzw. Befehls.

- Die bekannteste Seite um Fragen rund um R zu diskutieren ist 
<http://stackoverflow.com>.


### Einfache reproduzierbare Beispiele (ERBies)

Sagen wir, Sie haben ein Problem. Mit R. Bevor Sie jemanden bitten, Ihr Problem zu lösen, haben Sie schon ~~drei~~ ~~dreizehn~~ ~~dreißig~~ Minuten recherchiert, ohne Erfolg. Sie entschließen sich, bei [Stackoverflow](www.stackoverflow.com) Ihr Problem zu posten. Außerdem kann sicher eine Mail zu einem Bekannten, einem Dozenten oder sonstwem, der sich auskennen sollte, nicht schaden. Sie formulieren also Ihr Problem: "Hallo, mein R startet nicht, und wenn es startet, dann macht es nicht, was ich soll, außerdem funktioniert der Befehl 'mean' bei mir nicht. Bitte lös mein Problem!". Seltsamerweise reagieren die Empfänger Ihrer Nachricht nicht alle begeistert. Stattdessen verlangt jemand (dreist) nach einer genauen Beschreibung Ihres Problems, mit dem Hinweis, dass "Ferndiagnosen" schwierig sein. Genauer gesagt möchte ihr potenzieller Helfer ein 'minimal reproducible example' (MRE) oder, Deutsch, ein *einfaches reproduzierbares Beispiel*\index{einfaches reproduzierbares Beispiel} (ERBie).

>   Wenn Sie jemanden um R-Hilfe bitten, dann sollten Sie Ihr Problem prägnant beschreiben.

Was sollte alles in einem ERBie enthalten sein?

>   Ein ERBie besteht aus vier Teilen: Syntax, Daten, Paketen und Infos zum laufenden System (R Version etc.)


Wie sollte so ein ERBie aussehen? Ich empfehle, folgende Eckpunkte zu beachten^[Hier finden Sie weitere Hinweise zu ERBies: <https://stackoverflow.com/help/mcve> oder <https://gist.github.com/hadley/270442>]:

- Syntax: Stellen Sie die R-Syntax bereit, die ein Problem bereit (d.h. die einen Fehler liefert).
- Als Text, kein Screenshot: Wenn Sie einen Screenshot schicken, zwingen Sie Ihre Helfer, Ihre Syntax unnötigerweise abzutippen. Ihre Syntax sollte immer als Text ("copypastebar") zur Verfügung stehen.
- Einfach: Geben Sie sowenig Syntax wie möglich an. Es bereitet Ihrem Helfer nur wenig Spaß, sich durch 2000 Zeilen Code zu wühlen, wenn es 10 Zeilen auch getan hätten.
- Reproduzierbar Geben Sie soviel Syntax wie nötig, um den Fehler zu erzeugen (aber nicht mehr).
- Schreiben Sie Ihre Syntax übersichtlich, veständlich und kommentiert; z.B. sollten die Variablennamen informativ sein.
- Beschreiben Sie den Fehler genau ("läuft nicht" reicht nicht); z.B. ist es hilfreich, den Wortlaut einer Fehlermeldung bereitzustellen.
- Zu Beginn der Syntax sollten die benötigten Pakete geladen werden.
- Zu Ende des ERBie sollte der Output von `sessionInfo()` einkopiert werden; damit werden Informationen zum laufenden System (wie Version von R, Betriebssystem etc.) bereitgestellt.
- Beziehen Sie sich möglichst auf Daten, die in R schon "eingebaut sind" wie die Datensätze `iris` oder `mtcars`.


Natürlich sollte man immer erst selbst nach einer Lösung recherchieren, bevor man jemanden um Hilfe bittet. Viele Fragen wurden schon einmal diskutiert und oft auch gelöst.






## Was ist Statistik? Wozu ist sie gut?

Zwei Fragen bieten sich sich am Anfang der Beschäftigung mit jedem Thema an: Was
ist die Essenz des Themas? Warum ist das Thema (oder die Beschäftigung damit) 
wichtig?

Was ist Statistik? *Eine* Antwort dazu ist, dass Statistik die Wissenschaft von
Sammlung, Analyse, Interpretation und Kommunikation von Daten ist mithilfe 
mathematischer Verfahren ist und zur Entscheidungshilfe beitragen solle 
[@oxford; @sep-statistics]. Damit hätten wir auch den Unterschied zur schnöden 
Datenanalyse (ein Teil der Statistik) herausgemeißelt. Statistik wird häufig in 
die zwei Gebiete *deskriptive* und *inferierende* Statistik eingeteilt (vgl. Abb. \@ref(fig:desk-vs-inf)). Erstere 
fasst viele Zahlen zusammen, so dass wir den Wald statt vieler Bäume sehen. 
Letztere verallgemeinert von den vorliegenden (sog. "Stichproben-")Daten auf 
eine zugrunde liegende Grundmenge (Population). Dabei spielt die 
Wahrscheinlichkeitsrechnung (Stochastik) eine große 
Rolle.

```{r desk-vs-inf, echo = FALSE, fig.cap  ="Sinnbild für die Deskriptiv- und die Inferenzstatistik"}

knitr::include_graphics("images/Rahmen/desk_vs_inf-crop.png")
```



Aufgabe der deskriptiven Statistik ist es primär, Daten prägnant 
zusammenzufassen. Aufgabe der Inferenzstatistik ist es, zu prüfen, ob Daten 
einer Stichprobe auf eine Grundgesamtheit verallgemeinert werden können.


Dabei lässt sich der Begriff "Statistik" als Überbegriff von "Datenanalyse" 
verstehen, wenn diese Sicht auch nicht von allen geteilt wird 
[@grolemund2014cognitive]. In diesem Buch steht die Aufbereitung, Analyse, 
Interpretation und Kommunikation von Daten im Vordergrund. Liegt der Schwerpunkt
dieser Aktivitäten bei computerintensiven Methoden, so wird auch von *Data 
Science* gesprochen, wobei der Begriff nicht einheitlich verwendet wird [@r4ds;
@hardin2015data]

*Daten* kann man definieren als *Informationen, die in einem Kontext stehen*
[@moore1990uncertainty], wobei eine numerische Konnotation mitschwingt.

*Modellieren* kann man als *zentrale Aufgabe von Statistik* begreifen 
[@cobb2007introductory; @grolemund2014cognitive]. Einfach gesprochen, bedeutet 
Modellieren in diesem Sinne, ein mathematisches Narrativ ("Geschichte") zu 
finden, welches als Erklärung für gewisse Muster in den Daten fungiert; vgl. 
Kap. \@ref(mod1).

Statistisches Modellieren läuft gewöhnlich nach folgendem Muster ab [@grolemund2014cognitive]:


```
Prämisse 1: Wenn Modell M wahr ist, dann sollten die Daten das Muster D aufweisen.
Prämisse 2: Die Daten weisen das Muster D auf.
---
Konklusion: Daher muss das Modell M wahr sein.
```

Die Konklusion ist *nicht* zwangsläufig richtig. Es ist falsch zu sagen, dass dieses Argumentationsmuster - Abduktion [@peirce1955abduction] genannt - wahre, sichere Schlüsse (Konklusionen) liefert. Die Konklusion *kann, muss aber nicht*, zutreffen.

Ein Beispiel: Auf dem Nachhauseweg eines langen Arbeitstags wartet, in einer dunklen Ecke, ein Mann, der sich als Statistik-Professor vorstellt und Sie zu einem Glücksspiel einlädt. Sofort sagen Sie zu. Der Statistiker will 10 Mal eine Münze werfen, er setzt auf Zahl (versteht sich). Wenn er gewinnt, bekommt er 10€ von Ihnen; gewinnen Sie, bekommen Sie 11€ von ihm. Hört sich gut an, oder? Nun wirft er die Münze zehn Mal. Was passiert? Er gewinnt 10 Mal, natürlich (so will es die Geschichte). Sollten wir glauben, dass er ein Betrüger ist?

Ein Modell, welches wir hier verwenden könnten, lautet: Wenn die Münze gezinkt ist (Modell M zutrifft), dann wäre diese Datenlage D (10 von 10 Treffern) wahrscheinlich - Prämisse 1. Datenlage D ist tatsächlich der Fall; der Statistiker hat 10 von 10 Treffer erzielt - Prämisse 2. Die Daten D "passen" also zum Modell M; man entscheidet sich, dass der Professor ein Falschspieler ist. 

Wichtig zu erkennen ist, dass Abduktion mit dem Wörtchen *wenn* beginnt. Also davon *ausgeht*, dass ein Modell M der Fall ist (der Professor also tatsächlich ein Betrüger ist). Das, worüber wir entscheiden wollen, wird bereits vorausgesetzt. Falls M gilt, gehen wir mal davon aus, wie gut passen dann die Daten dazu? 

>    Wie gut passen die Daten D zum Modell M?

Das ist die Frage, die hier tatsächlich gestellt bzw. beantwortet wird.

Natürlich ist es keineswegs sicher, *dass* das Modell gilt. Darüber macht die Abduktion auch keine Aussage. Es könnte also sein, dass ein anderes Modell zutrifft: Der Professor könnte ein Heiliger sein, der uns auf etwas merkwürdige Art versucht, Geld zuzuschanzen... Oder er hat einfach Glück gehabt.

>   Statistische Modelle beantworten i.d.R. nicht, wie wahrscheinlich es ist, dass ein Modell gilt. Statistische Modelle beurteilen, wie gut Daten zu einem Modell passen.

Häufig trifft ein Modell eine Reihe von Annahmen, die nicht immer explizit gemacht werden, aber die klar sein sollten. Z.B. sind die Münzwürfe unabhängig voneinander? Oder kann es sein, dass sich die Münze "einschießt" auf eine Seite? Dann wären die Münzwürfe nicht unabhängig voneinander. In diesem Fall klingt das reichlich unplausibel; in anderen Fällen kann dies eher der Fall sein[^447]. Auch wenn die Münzwürfe unabhängig voneinander sind, ist die Wahrscheinlichkeit für Zahl jedes Mal gleich? Hier ist es wiederum unwahrscheinlich, dass sich die Münze verändert, ihre Masse verlagert, so dass eine Seite Unwucht bekommt. In anderen Situationen können sich Untersuchungsobjekte verändern (Menschen lernen manchmal etwas, sagt man), so dass die Wahrscheinlichkeiten für ein Ereignis unterschiedlich sein können, man dies aber nicht berücksichtigt. 



## Aufgaben 


1. Öffnen Sie das Cheatsheet für RStudio und machen Sie sich mit dem Cheatsheet vertraut.

2. Sichten Sie kurz die übrigen Cheatsheets; später werden die Ihnen vielleicht von Nutzen sein.


3. Führen Sie diese Syntax aus:

```{r eval = FALSE}
meine_coole_variable <- 10
meine_coole_var1able 
```

Woher rührt der Fehler?

4. Korrigieren Sie die Syntax:

```{r eval = FALSE}
install.packages(dplyer)
```


`y <- Hallo R!`


`Hallo R <- 1`


```{r eval = FALSE}
Hallo_R < - 1
```



Richtig oder Falsch???^[R, F: die Daten müssen sinnvoll zusammengefasst werden, F, F, F: Wenn er ehrlich sein sollte, dann ist das Ereignis '10 von 10' selten]

```{block2, exercises-rahmen, type='rmdexercises', echo = TRUE} 
Richtig oder Falsch!?

1. Statistik wird gemeinhin in zwei Bereiche unterteilt: Deskriptivstatistik und Inferenzstatistik.

1. Unter Deskriptivstatistik versteht man, Daten zu beschreiben. Dazu ist jede Art von Beschreibung sinnvoll, vorausgesetzt es wird eine konsistente Regel eingesetzt.

1. Unter Abduktion versteht man den Schluss vom Allgemeinen auf das Konkrete.

4. Wirft jemand bei 10 von 10 Münzwürfen 'Kopf', so muss er ein Betrüger sein.

1. Wirft jemand bei 10 von 10 Münzwürfen 'Kopf', so ist die Wahrscheinlichkeit groß, dass er ein Betrüger ist.


```




## Befehlsübersicht

Tabelle \@ref(tab:befehle-rahmen) stellt die Befehle dieses Kapitels dar. 

```{r befehle-rahmen, echo = FALSE}
df <- readr::read_csv("includes/Befehle_Rahmen.csv")

knitr::kable(df, caption = "Befehle des Kapitels 'Rahmen'")
```






Diese Befehle "wohnen" alle im Standard-R; es ist für diese Befehle nicht nötig, zusätzliche Pakete zu installieren/ laden.


## Verweise

- Chester Ismay erläutert einige Grundlagen von R und RStudio, die für 
Datenanalyse hilfreich sind: https://bookdown.org/chesterismay/rbasics/.

- Roger Peng und Kollegen bieten hier einen Einstieg in Data Science mit R: 
https://bookdown.org/rdpeng/artofdatascience/

- Wickham und Grolemund [-@r4ds] geben einen hervorragenden Überblick in das 
Thema dieses Buches; ihr Buch ist sehr zu empfehlen.

- Wer einen stärker an der Statistik orientierten Zugang sucht, aber 
"mathematisch sanft" behandelt werden möchte, wird bei James et al. 
[-@introstatlearning] glücklich oder zumindest fündig werden.

- Uwe Ligges -@ligges 'Programmieren mit R' gibt einen tieferen Einstieg in die Grundlagen von R.

- Wer ganz tief ein- und abtauchen möchte in R, dem sei - solide Grundkenntnisse vorausgesetzt - Hadley Wickhams -@wickham2014advanced 'Advanced R' ans Herz gelegt.





[^447]: Sind z.B. die Prüfungsergebnisse von Schülern unabhängig voneinander? Möglicherweise haben sie von einem "Superschüler" abgeschrieben. Wenn der Superschüler viel weiß, dann zeigen die Abschreiber auch gute Leistung.