-
Notifications
You must be signed in to change notification settings - Fork 5
/
10-Berichte.Rmd
178 lines (130 loc) · 9.37 KB
/
10-Berichte.Rmd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
# Berichte
Scripte schreiben ist schön und gut, aber das was dabei rauskommt ist in erster Linie ein Haufen Konsolen-Output, gespickt mit Plots, die ihr ggf. manuell speichern müsst, und dann wollt ihr das in eure krummen Word-Dokumente stecken und das will doch niemand.
In SPSS ist das einfach. Ihr drückt den großen bunten Knopf wo *"Mach mal Statistik"* draufsteht und dann fallen da PDFs raus. In R ist das anders. Habt ihr vermutlich gemerkt.
Das erste Output, das ihr mit R erzeugt wird wahrscheinlich nicht besonders hübsch aussehen — das ist schade, aber es ist nunmal auch die einfachste Art. Was in der Konsole passiert, kann auch problemlos auf großen Servern in der Cloud<sup>TM</sup> passieren und ferngesteuert werden — bei SPSS bleibt euch nur Remotedesktop-Kram.
Aber ich schweife ab. Das schöne an R ist jedenfalls die Flexibilität, die wir beim Output haben. Vielleicht habt ihr den Abschnitt zu `sjPlot` im Kapitel zu **[Packages]** schon gelesen, und wie die `sjt.*`-Funktionen hübsche Tabellen produzieren. Diese Tabellen sind HTML — dasselbe Zeug, aus dem Webseiten zusammengesteckt werden, und auch dasselbe Zeug, das so grob auch in Word-Dokumenten steckt. Wir können auch gleich eine ganze Analyse in HTML produzieren, mit Plots an den richtigen stellen und Tabellen in schön!
Wie das funktioniert soll in diesem Kapitel erklärt werden.
Als Vorraussetzung bzw. further reading könnt ihr euch bei diesen RStudio-Ressourcen umschauen:
- [RMarkdown](http://rmarkdown.rstudio.com/lesson-1.html)
- [HTML Output](http://rmarkdown.rstudio.com/html_document_format.html)
- [Word Output](http://rmarkdown.rstudio.com/word_document_format.html)
- [Markdown Syntax](http://rmarkdown.rstudio.com/authoring_basics.html)
- Bonus: [Präsentationen in RMarkdown mit `revealjs`](http://rmarkdown.rstudio.com/revealjs_presentation_format.html)
## Markdown
Habt ihr schonmal HTML gesehen? So mit `<html><body><p>Hallo Welt</p></body></html>`?
Den Scheiß will *kein Mensch* per Hand schreiben, wenn's nur um Text und vielleicht mal Bilder geht.
Dafür gibt es [Markdown](http://rmarkdown.rstudio.com/authoring_basics.html).
Markdown zu lernen wird euch **ungefähr 5 Minuten** kosten, _wenn_ ihr euch Zeit lasst und zwischendurch nochmal auf Klo geht.
Der obige Paragraph sieht im Markdown-Rohtext übrigens so aus:
```markdown
Habt ihr schonmal HTML gesehen? So mit `<html><body><p>Hallo Welt</p></body></html>`?
Den Scheiß will *kein Mensch* per Hand schreiben, wenn's nur um Text und vielleicht mal Bilder geht.
Dafür gibt es [Markdown](http://rmarkdown.rstudio.com/authoring_basics.html).
Markdown zu lernen wird euch **ungefähr 5 Minuten** kosten, _wenn_ ihr euch Zeit lasst und zwischendurch nochmal auf Klo geht.
```
Nicht so schwer, oder?
Das wird übersetzt in folgendes HTML:
```html
<p>Habt ihr schonmal HTML gesehen? So mit <code><html><body><p>Hallo Welt</p></body></html></code>?<br />
Den Scheiß will <em>kein Mensch</em> per Hand schreiben, wenn’s nur um Text und vielleicht mal Bilder geht.<br />
Dafür gibt es <a href="http://rmarkdown.rstudio.com/authoring_basics.html">Markdown</a>.<br />
Markdown zu lernen wird euch <strong>ungefähr 5 Minuten</strong> kosten, <em>wenn</em> ihr euch Zeit lasst und zwischendurch nochmal auf Klo geht.</p>
```
Anstrengend.
Was RStudio euch mittels RMarkdown erlaubt ist ein Bericht in Markdown geschrieben, zwischendurch mit R *Code Chunks*, die von R einfach ausgeführt werden, und am Ende fällt eine HTML-Datei raus, die ihr einfach im Browser öffnen könnt.
Optional könnt ihr da auch ein PDF rausfallen lassen, aber das erfordert möglicherweise rudimentäre *LaTeX*-Kenntnisse, und das will ja niemand.
## RMarkdown
RMarkdown ist R + Markdown. Jip.
Ihr schreibt ganz normales Markdown, und wenn ihr R Code einfügen wollt, setzt ihr da so einen Block rein:
````markdown
`r ""````{r}
nrow(sleep)
```
````
Und in eurem fertigen Dokument landet dann euer Text _und_ der R Code _und_ das Output des R-Codes.
Diese ganze Einführung ist in RMarkdown geschrieben, inklusive allen Code-Beispiele, Bildern und sowieso, und wenn ihr euch erstmal ein bisschen durch die oben verlinkte Einführung geklickt habt und gesehen habt, dass das gar nicht so schwer ist, werdet auch ihr irgendwann vermutlich lieber RMarkdown benutzen als Word.
Ihr könnt damit loslegen, sobald ihr RMarkdown installiert habt:
```r
# Für die Grundfunktion
install.packages("rmarkdown")
# Schöne Output-Formate (optional)
install.packages("rmdformats")
# Schöne Präsentationen (Optional)
install.packages("revealjs")
```
Also los, macht mal ein neues RMarkdown-Dokument auf:
```{r, echo=FALSE, fig.cap="Neues Dokument für RMarkdown", out.width="50%"}
knitr::include_graphics("images/rmarkdown_new_file_button.png")
```
Soweit alle mitgekommen? Gut.
Als nächstes dürft ihr euch was wünschen: Einen Dateinamen und einen AutorInnennamen.
```{r, echo=FALSE, fig.cap="Beliebig ausfüllen und \"HTML\" ausgewählt lassen", out.width="50%"}
knitr::include_graphics("images/rmarkdown_new_doc_modal.png")
```
Und sieheda, ein RMarkdown default document:
````markdown
---
title: "Untitled"
author: "Lukas"
date: "8/15/2017"
output: html_document
---
`r ''````{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
```
## R Markdown
This is an R Markdown document. Markdown is a simple formatting syntax for authoring HTML, PDF, and MS Word documents. For more details on using R Markdown see <http://rmarkdown.rstudio.com>.
When you click the **Knit** button a document will be generated that includes both content as well as the output of any embedded R code chunks within the document. You can embed an R code chunk like this:
`r ''````{r cars}
summary(cars)
```
## Including Plots
You can also embed plots, for example:
`r ''````{r pressure, echo=FALSE}
plot(pressure)
```
Note that the `echo = FALSE` parameter was added to the code chunk to prevent printing of the R code that generated the plot.
````
Das könnt ihr jetzt erstmal speichern, vielleicht testhalber etwas reinschreiben und sobald ihr den "*Knit*"-Button drückt, rödelt RMarkdown im Hintergrund los und spuckt euch ein HTML aus.
So einfach.
Jetzt könnt ihr damit beliebig experimentieren, den Text anpassen, eigenen Code reinschreiben und wenn ihr Fragen habt, googlet ihr die einfach solange, bis ihr jemanden findet, der/die die gleiche Frage auch schon hatte und rausgefunden hat wie's geht.
Oder es steht in der oben verlinkten Dokumentation von RStudio.
Vermutlich letzteres.
### Der `YAML`-Header
Als nächstes könnt ihr ein bisschen an den Optionen rumspielen:
```{r, echo=FALSE, fig.cap="Output Optionen für diversen Kram", out.width="50%"}
knitr::include_graphics("images/rmarkdown_output_options.png")
```
So Dinge wie die Dimensionen der ausgegebenen Plots ("figure height/width"), Inhaltsverzeichnis ("Table of Contents") etc. sind einfach über dieses Menü machbar, alles was irgendwie darüberhinausgeht muss über die Optionen am Anfang des Dokuments gesetzt werden.
Das oben ist der [*YAML*](https://en.wikipedia.org/wiki/YAML) header. YAML ist auch eine Markup-Sprache wie HTML, und weil es so viele dieser Markup-Sprachen gibt, heißt YAML lang "**Y**et **A**nother **M**arkup **L**anguage"[^yaml]. Es gibt auch noch [*HAML*](https://en.wikipedia.org/wiki/Haml) und [*TOML*](https://en.wikipedia.org/wiki/TOML)
Ihr erkennt das Muster.
Der Standard-Header definiert nur die wichtigstens Elemente, aber wir können den unter Anderem durch die Optionen im Menü erweitern. Ein umfangreicheres Beispiel aus einem alten QM-Aufgabenzettel sieht zum Beispiel so aus:
````yaml
---
title: "Aufgabenblatt 5"
author: "Lukas"
date: "Rendered ` r format(Sys.time(), '%F %H:%M')`"
output:
html_document:
toc: true
toc_float: true
toc_depth: 4
highlight: tango
fig_width: 9
fig_retina: 2
theme: yeti
code_folding: show
df_print: paged
---
````
Was euch da komisch vorkommen könnte ist der Teil mit dem `date:`. Das rechts daneben ist ein
*String* mit einem *inline code chunk*, und alles was in RMarkdown `` ` r `` und `` ` `` steht wird
wie R-Code behandelt und ausgeführt, das heißt das Datum des Dokuments wird in diesem Fall
automatisch auf `format(Sys.time(), '%F %H:%M')` gesetzt, was folgendes ergibt:
```{r}
format(Sys.time(), '%F %H:%M')
```
*Boom*, Dokument zeigt immer automatisch an, wann es zuletzt generiert (*rendered*, bzw. *knitted*) wurde.
Spitzfindigen Lesenden wird etwas aufgefallen sein: *"Aber seltsamer Nerd Mensch"*, werden sie sagen, *"wenn dieses Dokument hier in RMarkdon geschrieben wurde, und diese inline Code chunks automatisch ausgeführt werden"* werden sie feststellen, woraufhin sie sich fragen werden: *"wie ist es dann möglich den rohen Code dafür hier reinzuschreiben ohne, dass er ausgeführt wird?"* — und dazu, liebe hypothetische Lesende, habe ich eine Antwort: [Zero-width non-joiners everywhere](https://en.wikipedia.org/wiki/Zero-width_non-joiner), vielleicht [ASCII escape characters](http://donsnotes.com/tech/charsets/ascii.html), und extra `` ` ``.
Ihr werdet dieses Wissen vermutlich nie brauchen, aber ich habe ~30 Minuten damit verbracht herauszufinden wie ich das anstelle, also will ich dafür auch mindestens ein *bisschen* street cred.
[^yaml]: Alternativ kann YAML auch für <em>"**Y**AML **A**in't **M**arkup **L**anguage"</em> stehen, wenn ihr [rekursive Akronyme](https://de.wikipedia.org/wiki/Rekursives_Akronym) bevorzugt