Kapitel 2 Startvoraussetzungen

Die erste große Hürde beim Programmieren ist häufig die Einrichtung der notwendigen Programme auf dem eigenen Computer. Auch wenn im Falle von R die Installation vergleichsweise einfach funktioniert, haben doch viele AnfängerInnen Probleme damit. Schritt für Schritt wird außerdem erklärt, was Funktionen sind und wie man mit deren Hilfe Erweiterungen installieren und laden kann. Abschließend wird das Beheben von Fehlern besprochen.

2.1 Installation von R und RStudio

Die Unterscheidung zwischen R und RStudio ist für viele Anfänger verwirrend. Entgegen des ersten Eindrucks, handelt es sich dabei nicht um zwei austauschbare Alternativen. Stattdessen stellt R die Programmiersprache und RStudio eine Programmierumgebung dar. Den Unterschied können wir uns am Zusammenspiels eines Motors in einer Karosserie vor Augen führen, welcher in Abbildung 2.1 illustriert ist. Man braucht die Programmiersprache R, damit überhaupt etwas voran geht. Dabei könnte man das Auto grundsätzlich auch mit einem spartanischen Stahlgerüst fahren.

Abbildung 2.1: Illustration des Unterschieds zwischen R und RStudio.

Die Programmierumgebung RStudio macht aus dem minimalistischen Stahlgerüst mit dem Motor R eine komfortable Luxuslimousine mit Navigationssystem und Sitzheizung. Man kann R folglich auch ohne RStudio benutzen, aber RStudio nicht ohne R. Sonderlich viel Spaß bereitet das allerdings nicht. RStudio bietet eine Vielzahl von großartigen und praktischen Features, weshalb wir im Laufe des Buches nur innerhalb von RStudio arbeiten werden. Es wird aber trotzdem häufig von R die Rede sein, da RStudio lediglich die verwendete Programmierumgebung ist. In den folgenden Kapiteln wird Schritt für Schritt erklärt, wie du R und RStudio auf den gängigsten Betriebssystemen installierst und wichtige Anpassungen innerhalb von RStudio vornimmst. Auch wenn sich RStudio bereits auf deinem Computer oder Laptop befindet, solltest du Kapitel 2.3 unbedingt lesen.

2.1.1 Programmiersprache R

Zum Bearbeiten der Übungen dieses Buches benötigst du die R Version 4.1.0 oder neuer. Falls beim späteren Installieren der Packages (siehe Kapitel 2.5) ein Fehler auftritt, liegt das aller Wahrscheinlichkeit an einer zu alten R Version. Am besten installierst du R, genau wie es hier beschrieben wird, neu. Bei der Installation gibt es Unterschiede zwischen den verschiedenen Betriebssystemen Windows, macOS (Apple) und Ubuntu (Linux). In der späteren Benutzung gibt es hingegen keine Unterschiede. Du musst dir also nur den jeweiligen Abschnitt für dein Betriebssystem anschauen. Nach der Installation musst du mit R nichts weiter machen und kannst sofort zum Herunterladen von RStudio hinübergehen.

Windows:

Geh auf cloud.r-project.org und wähle Download R for Windows
Klicke anschließend auf den Link base.
Drücke dann auf Download R for Windows und achte darauf, wohin du die Installationsdatei abspeicherst.
Führe die Installationsdatei (z.B. R-4.1.0-win.exe) mit einem Doppelklick aus.
Folge schließlich den Installationsanweisungen. Hierbei ist das Entfernen des Häkchen bei Message translations zwingend erforderlich (siehe Abbildung 2.2). Ansonsten muss nichts an den Standardeinstellungen der Installation geändert werden.
Nach erfolgreicher Installation kannst du die heruntergeladene Installationsdatei (z.B. R-4.1.0-win.exe) wieder löschen.

Abbildung 2.2: Richtige Installation von R ohne Sprachsupport

macOS (Apple) :

Gehe auf cloud.r-project.org und wähle Download R for (Mac) OS X.
Je nachdem wie alt dein Mac ist, muss eine andere Version von R heruntergeladen werden. Deine macOS Version darf zur Benutzung der in diesem Buch vorgestellten Methoden nicht älter als 10.9 Mavericks sein.
- macOS 10.13 High Sierra und neuer: R-4.1.0.pkg (beziehungsweise die derzeit aktuellste Version)
- macOS 10.11 El Capitan und neuer: R-3.6.3.pkg
- macOS 10.9 Mavericks und neuer: R-3.3.3.pkg
Achte auf den Speicherort der Installationsdatei und führe diese aus. Falls deine Einstellungen die Installation externer Programme verhindern, musst du das Installieren von externen Paketen (mit der Endung .pkg) explizit erlauben (siehe unten).
Bei der Installation kann, ohne was zu verändern, stets auf weiter gedrückt werden.
Nach fertiger Installation kann die Installationsdatei (z.B. R-4.1.0.pkg) gelöscht werden.
Für englische Fehlermeldungen muss schließlich noch folgender Befehl innerhalb von R ausgeführt werden. Danach muss R geschlossen und erneut geöffnet werden. Alternativ kann man auch zuerst RStudio installieren und den Befehl dort entsprechend eingeben.

system("defaults write org.R-project.R force.LANG en_US.UTF-8")

Zum Schluss müssen wir noch manuell XQuartz (X11) installieren, da dies in neueren macOS Versionen nicht mehr standardmäßig enthalten ist. Dies brauchen wir später, um Datensätze auch innerhalb von RStudio anschauen zu können. Gehe dafür auf xquartz.org, lade die Installationsdatei (z.B. XQuartz-2.8.2.dmg) herunter und führe diese mit Doppelklick aus.

Je nach Einstellungen des Betriebssystems kann die Installation externer Software (nicht von Apple zertifiziert) wie R aus Sicherheitsgründen blockiert werden. Um das zu verhindern, musst du mit dem Finder (nicht Launchpad) nach der Installationsdatei (z.B. R-4.1.0.pkg) suchen. Halte anschließend Ctrl gedrückt und klicke auf die Datei. Aus dem erscheinenden Kontextmenü, kann schließlich Öffnen ausgewählt werden.

Ubuntu (Linux):

Drücke die Tastenkombination Strg + Alt + T oder tippe Terminal in die Suchleiste ein, um den Terminal zu öffnen.
Bringe die Informationen deiner Repositories auf den neuesten Stand und installiere ein notwendiges Paket.

sudo apt update -qq
sudo apt install --no-install-recommends software-properties-common dirmngr

Füge nun den Key hinzu, um für jetzt und zukünftige Updates einen sicheren Download zu gewährleisten.

wget -qO- https://cloud.r-project.org/bin/linux/ubuntu/marutter_pubkey.asc | \
sudo tee -a /etc/apt/trusted.gpg.d/cran\_ubuntu\_key.asc

Das entsprechende Repository kann anschließend mit folgendem Befehl hinzugefügt werden. Bei Wechsel der Hauptversion (z.B. von 4.0.0 auf 5.0.0) muss die Endung cran40 auf cran50 geändert werden.

sudo add-apt-repository "deb https://cloud.r-project.org/bin/linux/ubuntu \
$(lsb_release -cs)-cran40/"

Zum Installieren von R führe nun folgenden Befehl aus:

sudo apt install --no-install-recommends r-base

Zum Einstellen englischer Fehlermeldungen muss LANGUAGE=en an beliebiger Stelle in Renviron.site kopiert und gespeichert werden. Öffne die Datei dazu mit einem Texteditor wie gedit. Vergiss dabei nicht, die Datei im Anschluss abzuspeichern.

sudo gedit /etc/R/Renviron.site

2.1.2 Programmierumgebung RStudio

Nachdem R auf deinem Computer oder Laptop eingerichtet ist, kannst du die Installationsdatei für RStudio unter posit.co/download/rstudio-desktop/ herunterladen. Scrolle dafür hinunter und suche bei All Installers and Tarballs die richtige Datei aus. Wie beim Installieren von R musst du die heruntergeladene Installationsdatei mit der für dein Betriebssystem richtigen Endung (.exe, .pkg, .deb) ausführen und den anschließend eingeblendeten Anweisungen folgen. Nach Installation des Programms, kannst du die Installationsdatei auch in diesem Fall wieder löschen. Das eigentliche Programm RStudio findest du nun auf dem Computer zum Beispiel beim Drücken der Windows Taste und Eingabe des Wortes RStudio oder bei macOS über den Finder.

Von jetzt an solltest du zum Arbeiten mit R immer RStudio öffnen und nicht R. Die extra vorhandene minimalistische Oberfläche von R kannst du indes ignorieren. Es ist bloß wichtig, es auf dem Computer installiert zu haben.

2.2 Aufbau von RStudio

Wir schauen uns nun die einzelnen Komponenten innerhalb von RStudio an. Die Oberfläche ist dabei in vier Bereiche unterteilt: Nach frischer Installation ist die Console links unten, das R Skript als Source links oben, Environment & History rechts oben und Plots, Hilfe, Packages und mehr unten rechts. Diese Reihenfolge kann beliebig nach eigener Präferenz verändert werden (siehe Kapitel 2.3).

Abbildung 2.3: Aufbau von R Studio mit Skript (oben links), Konsole (unten links), Environment (oben rechts) und u.a. Plots und Help (unten rechts).

Console. In der Konsole befindet sich im Prinzip die reine Programmiersprache R. Wir können also jegliche Befehle direkt in die Konsole eingeben, auf Enter Enter drücken und das Ergebnis erhalten. Im Anschluss ist der eingegebene Befehl jedoch weg. Mit der oberen und unteren Pfeiltaste kannst du die in der bisherigen Sitzung bereits ausgeführten Befehle durchgehen. Da das weder sonderlich praktisch noch reproduzierbar ist, sollte man so genannte Skripte verwenden, die in einer gesonderten Datei (mit der Endung .R) gespeichert werden und nach Öffnen immer wieder ausführbar sind.

Source. Beim initialen Starten von R wird kein Skript angezeigt. Die Konsole nimmt also zuerst die gesamte linke Seite ein. Zum Erstellen eines R Skriptes kann man entweder die Tastenkombination Strg + Shift + N in Windows und Linux oder Cmd + Shift + N in macOS verwenden oder auf das unterhalb des Reiters File gelegene Blatt Papier mit dem Pluszeichen klicken und dort R Script auswählen. Gespeichert wird das R Skript wie üblich mit Strg + S oder über das Menü. Die Endung des Skriptes muss dabei .R sein, da die darin enthaltenen Befehle sonst nicht ausgeführt werden können. Man kann die Befehle innerhalb des Skriptes nun mit Strg / Cmd + Enter ausführen. Möchte man mehrere Zeilen ausführen, müssen diese erst markiert werden. Beispielsweise könnte man das gesamte R Skript ausführen, indem man erst mit Strg / Cmd + A alles markiert und anschließend mit Strg / Cmd + Enter bestätigt. Man kann mit der Tastenkombination Strg / Cmd + 1 und Strg / Cmd + 2 mit der Tastatur zwischen Konsole und Skript wechseln.

Environment & History. In der Environment werden alle gespeicherten Variablen angezeigt (siehe Kapitel 4.2). Man kann dort auch auf die eingelesenen Datensätze klicken und sich diese innerhalb von RStudio in einem eigenen Reiter ansehen. Vorsicht sei hier bei großen Datensätzen geboten, da diese Ansicht relativ rechenintensiv ist und RStudio dadurch abstürzen kann. Es empfiehlt sich daher, große Datensätze in ein anderes Format wie CSV oder Excel umzuwandeln, um dort einen guten Überblick über den Datensatz zu erhalten (siehe Kapitel 5). Die History zeigt alles an, was in der Konsole innerhalb einer R Sitzung ausgeführt wurde. Wenn du vollständig mit Skripten arbeitest, kannst du die History ignorieren. Tatsächlich solltest du das automatische Speichern und Laden der History, wie in Kapitel 2.3 erklärt, sogar ausschalten. Schließlich haben wir sämtliche durchgeführten Berechnungen bereits reproduzierbar durch das R Skript gegeben.

Plots, Help & Packages. Plots zeigt die erstellten Visualisierungen an (siehe Kapitel 8). Dabei kann man unter Zoom ein eigenes Fenster mit der Abbildung öffnen. Die Abbildung verändert sich, wenn man die Länge oder Breite des Fensters entsprechend verschiebt. Grundsätzlich kann mit Export die Visualisierung direkt in der Form gespeichert werden. Darauf sollte allerdings aufgrund der Auflösungsunterschiede verzichtet werden (siehe Kapitel 8.12). Unter Help wird die Dokumentation der verschiedenen R Funktionen angezeigt (siehe Kapitel 2.6). Der Reiter Packages ist auch nicht weiter von Bedeutung, da wir Packages im Rahmen dieses Buches über die Konsole installieren und laden.

2.3 RStudio anpassen

Die ersten zwei in diesem Kapitel erklärten Anpassungen sind essentielle und unabdingbare Voraussetzungen, um das erfolgreiche Ausführen des Codes auch auf anderen Computern zu gewährleisten. Diese Einstellungen nicht vorgenommen zu haben, ist eine häufige und schwer zu findende Fehlerquelle. Die anderen Anpassungen stellen Empfehlungen dar, die dir das Programmieren erleichtern sollen.

Niemals den Workspace und die History speichern. Um zu gewährleisten, dass dein Code nicht nur auf deinem Computer funktioniert, ist es dringend notwendig, das ständige Speichern und Laden des Workspaces auszustellen. Auch gewährleistest du dadurch, dass der Code immer funktioniert, wenn du diesen neu durchlaufen lässt.

Gehe zu: Tools/Global Options.../General
Entferne den Haken bei: Restore .RData into workspace at startup
Ändere Save workspace to .RData on exit zu never
Entferne den Haken bei: Always save history

Keine Sorge, auf das Speichern deines Codes hat das keine Auswirkung.

Im Sinne der Reproduzierbarkeit für Andere und für die eigene Fehlerbehebung ist es essentiell, beim erneuten Start von RStudio keine alten Zwischenergebnisse zu laden. Alle Berechnungen sollten durch die im Skript enthaltenen Befehle der Reihe nach auszuführen sein.

Standard Zeichenencodierung. Damit man den geschriebenen Code fehlerfrei auf anderen Geräten lesen kann, muss dieselbe Zeichencodierung gewählt werden. Die modernste und am weitesten verbreitetste ist UTF-8.

Gehe zu: Tools/Global Options.../Code/Saving
Ändere: Default text encoding zu UTF-8

Programmierhilfen. Aller Anfang ist schwer und warum sollte man dann nicht jede zur Verfügung stehende Hilfe nutzen wollen? Hier wird eingestellt, dass Funktionen vom Rest des Codes farblich hervorgehoben werden. Außerdem wirst du darauf hingewiesen, wenn zu wenige oder zu viele Leerzeichen gesetzt wurden. Zum Schluss stellen wir die Vorschläge zur Vervollständigung von Code noch auf eine kürzere Zeit ein.

Gehe zu: Tools/Global Options.../Code
Wechsel zu Display und mache einen Haken bei Highlight R function calls
Wechsel zu Diagnostics und mache einen Haken bei Provide R style diagnostics
Wechsel zu Completion und ändere im Abschnitt Completion Delay die Zahlen auf 1 (Character) und 0 (ms)

Schickes Aussehen. Es hat einen Grund, weshalb heutzutage viele Internetseiten und Smartphone Apps mit einem dunklen Farbthema angezeigt werden. Das ganze sieht nicht nur besser aus, sondern ist auch deutlich angenehmer für die Augen.

Gehe zu: Tools/Global Options.../Appearance
Nun kannst du aus verschiedenen Themen wählen und auch die Schriftart und Schriftgröße anpassen.

Anordnung der vier Layer. Die Anordnung von Console, Skript und Co ist Geschmackssache. Sinnvoll ist beispielsweise eine Aufteilung mit dem Skript auf der linken oberen Seite und der Console auf der rechten oberen Seite. Die Fenster unten links kannst du dann für immer Minimieren und hast so mehr Platz zum Arbeiten im Skript.

Gehe zu: Tools/Global Options.../Pane Layout
Oben links: Source
Oben rechts: Console
Unten links: History, Connections
Unten rechts: Environment, Files, Plots, Packages, Help, Build, VCS, Viewer

Komfortables Arbeiten. Wenig ist nerviger als dauernd die R Datei im Unterordner des Unterordners zu finden, um das Programm zu öffnen. Deshalb kann man einstellen, dass sich immer das zuletzt verwendete R Skript und Projekt öffnet. Über R Projekte erfährst du mehr in Kapitel 3.

Gehe zu: Tools/Global Options.../General
Mache einen Haken bei Restore most recently openend project at startup
Und bei Restore previously open source documents at startup

2.4 Funktionen und ihre Argumente

Eine Funktion erkennst du immer daran, dass sie von zwei runden Klammern gefolgt ist. In diesem Buch sind alle Funktion in orange hevorgehoben. Innerhalb von RStudio werden diese ebenfalls farblich markiert werden, wenn du den Anweisungen aus Kapitel 2.3 gefolgt bist.

Aber was ist eine Funktion eigentlich? Schauen wir uns exemplarisch die Funktion zur Berechnung der Summe mehrerer Werte an. Hier sollen die Werte 3, 4, 7 und 2 mithilfe der Funktion sum() zusammengezählt werden. Sämtliche Argumente (hier die vier Zahlen) müssen innerhalb runder Klammern der Funktion übergeben und dabei mit einem Komma voneinander getrennt werden.

sum(3, 4, 7, 2)

[1] 16

Auf diese Art und Weise können beliebig viele Argumente der Funktion übergeben werden. So könnte man bei einem vorliegendem fehlenden Wert (definiert als NA) diesen bei Zusammenzählen der Werte ignorieren und erhält nach wie vor ein Ergebnis. Das Argument zum Entfernen fehlender Werte heißt dabei na.rm.

sum(3, 4, 7, NA, 2, na.rm = TRUE)

[1] 16

Solange die Reihenfolge der Argumente, wie sie in der Funktion vorgeschrieben ist, eingehalten wird, können wir den Namen des Arguments weglassen. Davon werden wir im Verlauf des Buches immer wieder Gebrauch machen. In diesem Beispiel hingegen müssen wir na.rm explizit nennen, um den fehlenden Wert entfernen zu können. Die Entwickler der jeweiligen Funktionen definieren immer das Standardverhalten, falls keine weiteren Argumente genannt werden. Bei der Funktion sum() werden fehlende Werte bspw. standardmäßig nicht entfernt, weswegen wir dieses Verhalten mit na.rm = TRUE explizit hervorrufen müssen.

Funktionen stellen eine Abkürzung zu Berechnung dar, die wir ansonsten manuell durchführen müssten. Der Funktionsname wird von einer öffnenden und einer schließenden runden Klammer gefolgt (z.B. sum() für die Summe, mean() für den Mittelwert oder median() für den Median). Argumente verändern das Verhalten einer Funktion und können innerhalb der runden Klammern, getrennt durch ein Komma, mit einem Gleichheitszeichen verändert werden.

2.5 Packages (Erweiterungen)

Direkt in R ist eine Bandbreite an Funktionen integriert. Darüber hinaus gibt es zahlreiche Erweiterungen, die das Lösen verschiedener Problemstellungen erheblich erleichtern. Diese kostenlosen Erweiterungen nennt man Packages. Stell dir vor, du kaufst dir ein neues Smartphone, auf dem von Anfang an verschiedene Apps installiert sind. Du könntest dieses Smartphone mit den vorinstallierten Apps grundsätzlich verwenden. Für eine bessere Nutzerfreundlichkeit oder andere Funktionalitäten können allerdings auch zusätzliche Apps von Drittanbietern installiert werden. Genauso sind Packages in R zu verstehen. Auch mit den von Anfang an integrierten Funktionen könnte man die meisten Sachen irgendwie hinbekommen. Nur wäre dies mit deutlich mehr Aufwand verbunden als heutzutage notwendig. Deshalb arbeiten wir im Verlaufe des Buches mit verschiedenen Packages, die erst einmal installiert und geladen werden müssen.

Die Packages werden unter anderem auf CRAN, Github oder Bioconductor geteilt, von wo sie heruntergeladen und in die eigene Analyse integriert werden können. Es gibt beispielsweise mittlerweile über 11000 Packages alleine auf CRAN.

2.5.1 Installieren und laden

Wir unterscheiden zwischen einer Funktion zum einmaligen Installieren und einer Funktion zum wiederholten Laden des Packages innerhalb von R. Abbildung 2.4 verdeutlicht den Unterschied der beiden Funktionen.

Abbildung 2.4: Vergleich vom (a) Installieren und (b) vom Laden von Packages.

Während install.packages() das Package installiert, muss man es mit library() jedes Mal beim Starten von R neu laden. Erstere Funktion kannst du dir wie das Eindrehen einer Glühbirne vorstellen. Es bleibt dunkel im Zimmer, solange du nicht den Lichtschalter betätigst. Wenn du das Zimmer verlässt (R beendest), wird das Licht automatisch wieder ausgeschaltet. Jedes Mal, wenn du das Zimmer erneut betrittst, muss das Licht also erneut eingeschaltet werden.

Beim Starten von R muss jedes Mal aufs Neue der Befehl library() für jedes Package ausgeführt werden, welches du benutzen möchtest.

Es gilt generell, so wenige Packages wie möglich und so viele wie nötig zu verwenden. In diesem Buch werden nur aufeinander abgestimmte Packages verwendet, aber das ist nicht immer der Fall. Auch verändern sich manche Packages im Laufe der Zeit nennenswert, sodass die eigene Analyse zwei Jahre später ggf. nicht mehr funktionieren könnte.

Die Funktion install.packages("package") benötigt zur Installation als Argument den Namen des Packages in Anführungszeichen.

install.packages("here")

Innerhalb von RStudio wird der Befehlsaufruf in der Konsole eingegeben. Wie in Abbildung 2.5 illustriert, erscheint nach Ausführen der Funktion durch Drücken der Enter Enter Taste der Installationsverlauf in roter Schrift. Dabei handelt es sich, anders als die rote Farbe suggeriert, weder um eine Warnmeldung noch um eine Fehlermeldung. Ein Fehler würde in diesen Benachrichtigungen als Error beschrieben werden und die Installation stoppen.

Abbildung 2.5: Eingabe der einmaligen Installation in die Konsole.

Falls bei der Installation Fehler auftreten, sollte das Argument dependencies = TRUE, getrennt mit einem Komma, zusätzlich verwendet werden. Damit werden die Packages installiert, von denen das gewünschte Package gegebenenfalls zusätzlich abhängt.

install.packages("here", dependencies = TRUE)

Damit man auf die Funktionen des Packages zugreifen kann, muss das Package jedes Mal – also nach jedem neuen Öffnen von RStudio – aus der Bibliothek mithilfe von library(package) erneut geladen werden. Hierbei sind keine Anführungszeichen notwendig.

library(here)

Zur besseren Übersichtlichkeit solltest du alle library() Befehle am Anfang des jeweiligen R Skriptes untereinander schreiben und aufrufen. Nach der Installation der Packages gibt es zwei Gründe, die Packages erneut installieren zu müssen.

Der Umstieg auf eine neue Hauptversion von R (z.B. von R 4.0.0 auf R 5.0.0): Dabei wird der Ordner, der die Packages enthält, neu angelegt. Daher müssen alle Packages erneut installiert werden. Es gibt leider keinen einfachen Weg, alle installierten Packages automatisch in den neuen Ordner zu kopieren.
In einem der Packages gibt es eine neue Funktion, die man verwenden möchte.

Der einfachste Weg, Packages zu updaten, ist durch die erneute Installation. Es gibt zwar den Befehl update.packages(), allerdings muss dieser als Administrator in R und nicht RStudio ausgeführt werden. Selbst bei Ausführung als Administrator können dabei Probleme auftreten. Also ist man mit der erneuten Installation der Packages im Regelfall besser beraten. In aktuellen Versionen von RStudio wird automatisch eine Benachrichtigung am Anfang des Skriptes angezeigt, falls in dem Skript erwähnte Packages nicht installiert sind. Diese können dann über entsprechenden Mausklick durch RStudio installiert werden.

Die gute Nachricht ist, dass man im Grunde genommen weder R noch die Packages updaten muss. Alle in diesem Buch verwendeten Packages werden sich in Zukunft voraussichtlich nicht mehr nennenswert verändern und auch in R kommen nur selten für die Datenanalyse relevante Neuerungen hinzu.

2.5.2 Notwendige Packages für dieses Buch

Diese vier für dieses Buch essentiellen Packages werden wir nun zuerst installieren. Das remotes Package verwenden wir nur einmalig, um das Package begleitend zum Buch namens remp von Github herunterladen zu können. Wofür jedes einzelnen Package genau zuständig ist, wirst du im Verlaufe des Buches erfahren. Die Installation kann je nach Internet und Computer einige Minuten in Anspruch nehmen. Jeder Aufruf der Funktion install.packages() muss nur einmal ausgeführt werden. Kopiere nacheinander die einzelnen Befehle in die Console und warte, bis die jeweilige Installation abgeschlossen ist.

install.packages("tidyverse")
install.packages("here")
install.packages("rio")
install.packages("remotes")
install.packages("learnr")

Um auf die Übungsdatensätze und interaktive Übungen zugreifen zu können, musst du das Package remp installieren. Dafür wird zunächst das Package namens remotes geladen. Während der Installation des Packages kann es sein, dass du gefragt wirst, ob du bestimmte Packages aktualisieren möchtest. Du solltest dies an der Stelle ohne weiteres Zutun durch Klicken der Enter Enter Taste verneinen. Die Funktion install_github() aus dem remotes Package installiert im Anschluss das Package remp, welches im Github Account namens jpnolte liegt.

library(remotes)
install_github("jpnolte/remp")

Alle anderen teilweise speziell auf einen Kontext zugeschnittenen Packages, die im Rahmen des Buches vorgestellt werden, kannst du bei Bedarf installieren. Am Anfang jedes Kapitels mit einem neuen Package wird immer explizit darauf hingewiesen.

Im remp Package sind Datensätze, Funktionen und Übungen für dieses Buch enthalten. Da dieses Package nicht auf CRAN sondern auf Github gespeichert ist, muss hier zur Installation die Funktion install_github() aus dem remotes Package anstelle der üblichen Funktion install.packages() verwendet werden. Das remotes Package muss hierbei vorher installiert werden.

Wir werden im Rahmen dieses Buches vor allem diese vier Packages verwenden, weswegen zu Beginn jedes Skriptes die vier Packages geladen werden müssen.

library(tidyverse)
library(here)
library(rio)
library(remp)

In diesem Fall ist die Reihenfolge des Ladens nicht entscheidend. Falls verschiedene Packages jedoch gleichnamige Funktionen beinhalten, führt dies zu Problemen, auf die im folgenden Kapitel näher eingegangen wird.

2.5.3 Namespace

Beim Laden mehrerer Packages kann es sein, dass diese Funktionen mit demselben Namen verwenden (siehe Kapitel 6.1). Während beim tidyverse lediglich zwei selten verwendete base R Funktionen überschrieben werden, kann es beim Arbeiten mit vielen verschiedenen nicht aufeinander abgestimmten Packages durchaus häufiger zur Namensgleichheit kommen. Das ist eine schwierig zu identifizierende Fehlerquelle, weil sich die Funktion mitunter plötzlich nicht mehr so verhält wie erwartet. Dabei verwendet man automatisch die Funktion, die aus dem zuletzt geladenen Package stammt. Lädt man beispielsweise zuerst das Package tidyverse und anschließend data.table, erhält man folgende Meldung:

library(tidyverse)
library(data.table)

Attaching package: ‘data.table’

The following objects are masked from ‘package:dplyr’:

    between, first, last

The following object is masked from ‘package:purrr’:

    transpose

Drei Funktionen (between(), first(), last()) aus dem Package dplyr und eine Funktionen (transpose()) aus dem Package purrr werden von data.table überschrieben. Es ist also wichtig, diese Meldungen beim Laden eines Packages nicht zu ignorieren. Im Notfall kann dies durch die Verwendung von Doppelpunkten package::funktion() verhindert werden. So teilt man R explizit mit, welche Funktion aus welchem Package man meint. Um trotz des späteren Ladens von data.table auf die between() Funktion von dplyr zuzugreifen, würde man also beim Aufrufen der Funktion folgendes schreiben:

dplyr::between(1:12, 7, 9)

Eine Ausnahme stellt dabei das tidyverse dar. Weil das tidyverse nur andere Packages lädt, kann man nicht tidyverse::funktion() schreiben. Stattdessen muss man das Package, aus dem die Funktion stammt (z.B. dplyr), direkt ansprechen.

Für genauere Informationen zum Thema Namespace und die Hintergründe der damit verbundenen Environments sei auf das Buch Advanced R verwiesen.

2.6 Fehler- und Warnmeldungen

2.6.1 Der Unterschied

Es gibt einen großen Unterschied zwischen Fehler- und Warnmeldungen. Wie der Name bereits suggeriert, stoppen Fehlermeldungen den Code, während Warnmeldungen ein Ergebnis zurückgeben und nur auf mögliche Probleme hinweisen. Es ist also sehr wichtig, die roten Meldungen in der Konsole genau zu lesen, anstatt direkt in Panik zu geraten. Ein Beispiel für eine Fehlermeldung sehen wir, wenn wir die Zahl 1 mit dem Buchstaben c summieren möchten.

1 + "c"

Error in 1 + "c": non-numeric argument to binary operator

Hier ist die Fehlermeldung eindeutig. Wir versuchen einen nicht-numerisches Buchstaben (das c) mit einem numerischen zu addieren. Leider sind Fehlermeldungen in R keineswegs immer so eindeutig zu interpretieren. Nicht selten sind sie kryptisch und vor allem am Anfang wird man oft im Internet nach einer Lösung suchen müssen.

Warnmeldungen in R haben zwar dieselbe erschreckende rote Schrift wie Fehlermeldungen, allerdings starten sie mit Warning Message und stoppen den Code nicht. Warnmeldungen sind für dich als Benutzer gedacht, um auf mögliche Probleme bei deiner Eingabe hinzuweisen. Gerade bei der statistischen Auswertung können Warnungen dir schon einmal häufiger über den Weg laufen und sollten keinesfalls blind ignoriert werden.

Die Sprache der Fehler- und Warnmeldungen muss dabei Englisch sein, da sonst nicht vernünftig im Internet danach gesucht werden kann. Bitte beachte die dafür notwendigen Anpassungen bei der Installation, die in Kapitel 2.1.1 erklärt wurden.

2.6.2 Wo bekomme ich Hilfe?

Während der ersten Kontakte mit einer Programmiersprache dauert das Warmwerden möglicherweise eine gewisse Zeit. Damit man nicht gleich die Motivation verliert und aufgibt, sind die richtigen Quellen für eine schnelle Hilfe essentiell. Glücklicherweise ist dies einer der großen Vorteile von R. Es existieren nicht nur ausführliche Dokumentationen der verschiedenen Funktionen mit Anwendungsbeispielen. Darüber hinaus ist die R Community auch besonders hilfsbereit. Falls du verzweifelt vor deinem Computer oder Laptop sitzt und nicht weißt, wieso dein Code schon wieder nicht funktioniert, solltest du besonders an vier Orten nach Antworten suchen.

Package Dokumentation. Das naheliegendste ist die Dokumentation der R Funktionen, die auch ohne Internet direkt in R aufgerufen werden können. Dafür kannst du entweder ein Fragezeichen vor die Funktion schreiben und diese ausführen oder mit dem Cursor auf der Funktion F1 drücken. Wenn wir zum Beispiel mehr über die Argumente der Funktion install.packages() erhalten möchten, können wir dies so erreichen:

?install.packages

Die meisten modernen Packages stellen außerdem so genannte Vignetten zur Verfügung, in denen häufige Probleme ausführlich diskutiert und erklärt werden. Diese können mit vignette("nameDerVignette") auch direkt innerhalb von R aufgerufen werden.

Suchmaschine. In die Suchmaschine gibst du einfach r gefolgt von der Fehlermeldung oder dem Problem ein, an dem du aktuell festhängst. Es gibt kaum eine Fehlermeldung, bei der das Programmierforum StackOverflow nicht an erster Stelle angezeigt wird. Denn meistens hat jemand anderes schon einmal genau dasselbe Problem gehabt hat.

Stackoverflow. Dies ist wohl das mit Abstand größte Forum für Programmierfragen. Allerdings kann es einschüchternd sein, dort als absoluter Anfänger selbst eine Frage zu stellen. Voraussetzung zum Fragestellen ist dort das Erstellen eines kurzes reproduzierbares Beispiel für den Fehler. Du erreichst die Seite unter https://stackoverflow.com/.

RStudio Community. Eine etwas kleinere Alternative zu StackOverflow ist die RStudio Community. Statte ihr bei Bedarf unter https://community.rstudio.com/ einen Besuch ab.

2.6.3 Fehler beheben

Während deiner ganzen Zeit beim Programmieren wirst du immer wieder Code schreiben, der unweigerlich zu einem Fehler führt. Ob nun ein Package nicht geladen oder eine Klammer zu wenig gesetzt ist. Irgendetwas läuft häufig schief – so mag es zu Beginn erscheinen. Richtig um Hilfe fragen, ist dabei gar nicht so einfach.

Es ist zum Beispiel wenig informativ, wenn du jemandem schreibst: “RStudio funktioniert nicht”. Was funktioniert nicht? Wann tritt der Fehler auf? Hat es vorher funktioniert? Alle diese Informationen müssen dann erst einmal mühselig erfragt werden. Nun können die bereitzustellenden Informationen grundsätzlich in drei Abschnitte gegliedert werden.

Eine kurze Problembeschreibung.
Stelle ein minimales, reproduzierbares Beispiel bereit.
Erkläre, was du bereits probiert hast.

Während Punkt 1 und 3 soweit verständlich sind, bedarf es eine Erklärung für das reproduzierbare Beispiel. Ein reproduzierbares Beispiel enthält alle Informationen, die jemand anderes zum exakten Replizieren des Fehlers benötigt. Es müssen also zum Beispiel alle geladenen Packages angegeben werden. Außerdem ist es essentiell, den Datensatz in einer vereinfachten Kurzform zur Verfügung zu stellen.

Wenn du beim Analysieren deines eigenen Datensatzes auf ein Problem stößt, kann natürlich niemand anderes auf diesen Datensatz zugreifen. Entweder erstellt man dann einen kleinen Datensatz innerhalb von R, mit dem das Problem repliziert wird oder man lässt die Datenstruktur des eigenen Datensatzes ausgeben. Angenommen, wir haben eine Fehlermeldung bei der Auswertung eines Datensatzes namens demogr.

demogr

# A tibble: 4 × 3
  ID       Sex   Alter
  <chr>    <chr> <dbl>
1 AX161095 m        28
2 NM020683 f        47
3 IO240576 f        40
4 JH051199 m        24

Dieser Datensatz ist relativ kompakt und kann mit der Funktion dput() in ein Format gebracht werden, welches ohne Zugriff auf die Originaldatei von Anderen in R aufgerufen werden kann.

dput(demogr)

structure(list(ID = c("AX161095", "NM020683", "IO240576", "JH051199"
), Sex = c("m", "f", "f", "m"), Alter = c(28, 47, 40, 24)), class = c("tbl_df", 
"tbl", "data.frame"), row.names = c(NA, -4L))

Bei größeren Datensätzen sollte man nur einen Teil der Daten auswählen (siehe Kapitel 6.2 und 6.3). Bei sensiblen Daten bietet es sich an, einen kleinen Datensatz innerhalb von R neu zu erstellen, der anstelle der Originaldaten strukturell ähnliche Werte in den Spalten beinhaltet (siehe Kapitel 5.3).

Häufig kommt man von ganz alleine auf die Lösung, während man Schritt für Schritt die durchgeführten Zeilen Code auseinander nimmt, um das Problem innerhalb eines minimalen Beispiels zu reproduzieren.

Bevor du allerdings die Frage an jemand anderes richtest, solltest du diese häufigen Fehlerquellen bereits ausgeschlossen haben:

Tippfehler.
Ein Package ist nicht installiert oder geladen.
Ein oder mehrere Packages sind zu alt.
Eine Klammer ist zu viel oder zu wenig.
Anführungszeichen bei wurden vergessen oder an falsche Stelle gesetzt.
Ein Komma anstelle eines Punktes wurden füri Dezimalzahlen verwendet.
Numerische Spalten im Datensatz wurden als Character eingelesen (häufig bei Excel Dokumenten).
Character Spalten sind fälschlicher Weise als Faktoren dargestellt.
Das R Skript wurde nicht innerhalb eines R Projekts geöffnet, sodass der Datensatz nicht gefunden wird.