Laden Sie die Statistik-Software R herunter und installieren Sie sie. Die neueste Version ist derzeit 4.0.x (Stand: April 2021).
Laden Sie außerdem RStudio herunter und installieren Sie es.
Schauen Sie sich diese kurze Einführung in RStudio an.
Legen Sie außerdem ein Verzeichnis für diesen Kurs auf Ihrer Festplatte an.
Für diesen Kurs werden wir ein R project anlegen, da Ihnen dies die Arbeit mit R auf lange Sicht erleichtern wird.
Öffnen Sie RStudio und klicken Sie oben rechts auf die Schaltfläche Project: (None).
Klicken Sie dann auf New Project und im Folgenden auf Existing Directory und wählen Sie mit Browse das Kursverzeichnis aus, das Sie eben angelegt haben.
Schließen Sie den Vorgang ab, indem Sie auf Create Project klicken.
RStudio öffnet nun automatisch das Projekt, das genauso benannt ist wie Ihr Kursverzeichnis (siehe Schaltfläche oben rechts). Sie können das Projekt über diese Schaltfläche schließen und anschließend auch wieder öffnen. Das Projekt lässt sich außerdem öffnen, indem Sie in Ihrem Kursverzeichnis auf die neu angelegte Datei mit der Endung .Rproj klicken.
Sollten Sie Probleme beim Erstellen des Projekts haben, empfehlen wir Ihnen diese Video-Kurzanleitung.
Weiterführende Infos: R Projekte
R Projekte haben viele Vorteile, insbesondere wenn Sie in mehreren Kursen mit R arbeiten und für jeden ein eigenes R Projekt haben. Das Projekt merkt sich, welche Dateien Sie geöffnet haben, und stellt diese beim nächsten Öffnen des Projekts wieder her, sodass Sie da weiterarbeiten können, wo Sie aufgehört haben. Außerdem ist das working directory des Projekts Ihr Kursverzeichnis, das heißt alle Dateien, die Sie im Verlauf des Kurses dort ablegen, können Sie ganz einfach über das Panel unten links (Tab Files) oder über relative Pfade öffnen. Ihr Arbeitsverzeichnis können Sie übrigens überprüfen, indem Sie in der Konsole getwd() eingeben und Enter drücken.
Unten links in RStudio sehen Sie die Console. Darin wird Code ausgeführt, d.h. die Konsole ist die Verbindung zwischen R und dem Computer, der die Berechnungen umsetzt. Geben Sie z.B. den folgenden Code Zeile für Zeile in die Konsole ein und drücken Sie danach Enter:
1 + 1## [1] 210 - 5## [1] 53 * 4## [1] 1212 / 6## [1] 22^4## [1] 16Die Konsole gibt Ihnen die Antwort auf die eingegebene Rechnung zurück.
Natürlich werden wir die Konsole nicht nur als Taschenrechner benutzen. Ganz häufig wollen wir bestimmte Werte mehrfach verwenden, ohne jedes Mal den Wert oder die Berechnung eingeben zu müssen. Deshalb speichern wir Werte als sogenannte Variablen ab. Diese Variablen sind dann in Ihrem Environment (Panel oben rechts) vorhanden.
Um eine neue Variable anzulegen, gibt man in der Konsole zuerst den gewünschten Variablennamen ein, dann den Zuweisungspfeil <- und dann den zu speichernden Wert. Im folgenden legen wir eine Variable namens summe an, die den Wert 1 + 1 enthält:
summe <- 1 + 1Um den Inhalt der Variable anzusehen, geben Sie einfach den Variablennamen in die Konsole ein und drücken wieder Enter:
summe## [1] 2Sie sehen, dass nicht 1 + 1 zurückgegeben wird, sondern 2. Wann immer wir den Wert der Berechnung 1 + 1 verwenden wollen, können wir stattdessen auch summe verwenden:
summe + 3## [1] 5Achtung! Variablen werden in R ohne Warnmeldung überschrieben:
x <- 4
x## [1] 4x <- 3
x## [1] 3In Ihrem Environment haben Sie nun zwei Variablen: summe hat den Wert 2, x hat den Wert 3. Sie können auch herausbekommen, welche Variablen in Ihrem Environment sind, indem Sie eine sogenannte Funktion verwenden. Funktionen (auch: Befehle) führen Aktionen aus. Dahinter steht Code, den jemand geschrieben und für alle NutzerInnen verfügbar gemacht hat (man kann auch selbst Funktionen schreiben, aber das werden wir in diesem Kurs nicht behandeln). Geben Sie folgendes in Ihre Konsole ein und drücken Sie Enter:
ls()## [1] "summe" "x"Die Funktion heißt ls(), das steht für list (auflisten), und gibt Ihnen die Namen aller Variablen in Ihrem Environment zurück. Funktionen können Sie an den runden Klammern nach dem Funktionsnamen erkennen. In den runden Klammern stehen die sogenannten Argumente der Funktion, also Angaben, die die Funktion benötigt, um etwas berechnen zu können. ls() ist eine der wenigen Funktionen in R, die keine Argumente benötigen.
Eine weitere nützliche Funktion ist rm() (remove), damit können Sie Variablen aus dem Environment entfernen (Achtung: diese Entscheidung ist endgültig!). Die Funktion bekommt als Argumente die Namen der Variablen, die Sie löschen wollen. Im Folgenden entfernen wir die Variable x:
rm(x)
ls()## [1] "summe"Bisher haben wir nur mit Zahlen (sog. numerics) gearbeitet. In R gibt es noch viele weitere Arten von Objekten. Bei den numerischen Objekten unterscheidet man zwischen double (Dezimalzahlen) und integer (Ganzzahlen).
x <- 3.2 # double
x## [1] 3.2y <- 4 # integer
y## [1] 4Es gibt außerdem Schriftzeichen-Objekte (engl. strings oder character), die immer in Anführungszeichen gesetzt werden müssen:
z <- "wir lernen programmieren"
z## [1] "wir lernen programmieren"… und die zwei booleschen Werte (engl. booleans oder logicals), die ohne Anführungszeichen aber in Großbuchstaben geschrieben werden:
a <- TRUE # Kurzform: T
a## [1] TRUEb <- FALSE # Kurzform: F
b## [1] FALSEEs gibt zusätzlich noch eine wichtige Objektklasse namens factor, die für kategorische Daten verwendet wird. Diese Art von Daten werden wir, zusammen mit noch ein paar weiteren Objektklassen, später kennenlernen.
Um herauszufinden, welche Objektklasse eine Variable hat, verwendet man die Funktion class(). Diese Funktion bekommt nur ein Argument, nämlich den Namen der Variable, deren Objektklasse Sie erfragen wollen.
class(a)## [1] "logical"class(y)## [1] "numeric"class(z)## [1] "character"Die Funktion c() (concatenate) erzeugt einen Vektor, d.h. eine Datenstruktur mit mehreren Elementen desselben Typs.
vec <- c("a", "b", "c") # alle Elemente sind Schriftzeichen
vec## [1] "a" "b" "c"vec <- c(3, 6, 89.3, 0, -10) # alle Elemente sind numerisch (genauer: doubles)
vec## [1] 3.0 6.0 89.3 0.0 -10.0Sollten die Elemente unterschiedlichen Klassen angehören (strings, booleans, numerics), werden die Elemente still, also ohne Warnmeldung, in denselben Typ umgewandelt.
c(3, 4, "string", T) # alle Elemente werden in strings umgewandelt## [1] "3" "4" "string" "TRUE"c(2, 5, T, F) # alle Elemente werden in numerics umgewandelt; TRUE = 1, FALSE = 0## [1] 2 5 1 0Sie haben schon gesehen, dass die Konsole wie ein Taschenrechner funktioniert. Die Grundrechenarten sowie arithmetische Funktionen können Sie auf alle numerischen Objekte anwenden, auch auf numerische Vektoren:
a <- c(10, 4, 20)
a * 10## [1] 100 40 200b <- c(5, 2, 7)
a + b## [1] 15 6 27In R gibt es viele arithmetische Funktionen, die als Argument einfach eine numerische Variable bekommen:
sum(a) # Summe aller Elemente## [1] 34sqrt(a) # Wurzel (square root) pro Element## [1] 3.162278 2.000000 4.472136log(a) # Logarithmus eines jeden Elements## [1] 2.302585 1.386294 2.995732exp(a) # Exponential für jedes Element## [1] 2.202647e+04 5.459815e+01 4.851652e+08Logische Operatoren vergleichen zwei Variablen derselben Objektklasse miteinander. Die folgenden logischen Operatoren existieren in R:
x < y # weniger als
x > y # mehr als
x <= y # weniger als oder gleich
x >= y # mehr als oder gleich
x == y # genau gleich
x != y # ungleich
!x # nicht x
x | y # x ODER y
x & y # x UND y
isTRUE(x) # prüfen, ob x TRUE ist
x %in% y # prüfen, ob ein Wert x in einem Vektor y enthalten istDie Antwort auf diese Operatoren sind die booleschen Werte, also entweder TRUE oder FALSE, wie folgende Beispiele zeigen:
x <- 3
y <- 4
x == y## [1] FALSEx != y## [1] TRUEx > y## [1] FALSEx <- c(1, 2, 3, 4, 5)
x == 3## [1] FALSE FALSE TRUE FALSE FALSE"a" %in% c("a","b","c")## [1] TRUEDie logischen Operatoren werden später noch sehr wichtig werden.
Wir wollen Ihnen noch ein paar Funktionen vorstellen, die hilfreich bei der Arbeit mit Vektoren sind.
Neben c() gibt es noch weitere Funktionen, mit denen man Vektoren erstellen kann. Zuerst gibt es eine Kurznotation für numerische Vektoren von aufeinander folgenden Ganzzahlen, nämlich den Doppelpunkt:
1:10## [1] 1 2 3 4 5 6 7 8 9 1010:1## [1] 10 9 8 7 6 5 4 3 2 1Die Funktion seq() erzeugt einen Vektor mit numerischen Intervallen, also Zahlensequenzen, bei denen alle Zahlen gleich weit voneinander entfernt sind. Die Funktion bekommt drei Argumente: den ersten (from) und den maximalen (nicht zwangsläufig letzten) Wert des Intervalls (to), und dann entweder die gewünschte Länge des Vektors (length.out) oder die Abstufung des Intervalls (by).
seq(from = 10, to = 20, length.out = 5) # 5 Intervalle zwischen 10 und 20## [1] 10.0 12.5 15.0 17.5 20.0seq(from = 10, to = 20, by = 1.5) # In Intervallen von 1.5## [1] 10.0 11.5 13.0 14.5 16.0 17.5 19.0Weiterführende Infos: Argumente in Funktionen
Oben sehen Sie zum ersten Mal, dass Argumente Namen haben können (z.B. from, to, length.out und by). Wenn Argumente Namen haben (was fast immer der Fall ist), können Sie entweder die Namen dieser Argumente verwenden wie oben gezeigt, oder sie lassen die Namen komplett weg.
seq(10, 20, length.out = 5)## [1] 10.0 12.5 15.0 17.5 20.0Wenn Sie die Namen weglassen, müssen Sie die Argumente in der richtigen Reihenfolge verwenden. Die Reihenfolge der Argumente können Sie auf den Hilfeseiten herausfinden. Navigieren Sie dazu in den Tab Help im Panel unten rechts und geben Sie den Funktionsnamen seq in die Suchleiste ein. Wenn Sie Enter drücken, sollte die Hilfeseite der Funktion erscheinen. Die Reihenfolge der Argumente für diese Funktion ist from, to und dann entweder by oder length.out, wie Sie sehen können. Wir können die Argumentnamen from und to weglassen, solange wir die richtigen Zahlen an der richtigen Stelle in der Funktion verwenden (also zuerst den Wert für from, dann den Wert für to). Der Funktion ist aber nicht automatisch klar, ob als drittes Argument by oder length.out kommt, daher schreiben wir das Argument hier ausführlich als length.out = 5. Wenn wir dies nicht machen würden, würde die Funktion das Argument an dritter Stelle in der Funktion als den Wert für by interpretieren:
seq(10, 20, 5)## [1] 10 15 20Wenn wir allerdings die Namen der Argumente verwenden, ist die Reihenfolge egal:
seq(to = 20, by = 1.5, from = 10)## [1] 10.0 11.5 13.0 14.5 16.0 17.5 19.0Die Funktion rep() wiederholt Werte (egal ob numerisch, logisch oder strings). Neben den zu wiederholenden Werten bekommt die Funktion das Argument times und/oder das Argument each (oder das Argument length.out, das wir hier erstmal ignorieren). Im folgenden demonstrieren wir, was diese Argumente ausrichten (schauen Sie auch auf die Hilfsseite für diese Funktion!):
rep(1, times = 3)## [1] 1 1 1rep("a", times = 2)## [1] "a" "a"vek <- c("a", "b")
rep(vek, times = 4)## [1] "a" "b" "a" "b" "a" "b" "a" "b"rep(vek, each = 4)## [1] "a" "a" "a" "a" "b" "b" "b" "b"rep(vek, times = 3, each = 3)## [1] "a" "a" "a" "b" "b" "b" "a" "a" "a" "b" "b" "b" "a" "a" "a" "b" "b" "b"Zuletzt gibt es noch zwei verwandte Funktionen, die Schriftzeichen-Vektoren generieren: paste() und paste0(). Die Funktion paste() bekommt zunächst all die Elemente, die Sie miteinander verbinden wollen, und optional das Argument sep (separator), das bestimmt, mit welchem Zeichen die Elemente verbunden werden. paste0() bekommt nur die Elemente, die dann direkt aneinander gebunden werden. Wenn die Elemente alle einfache Variablen sind, erstellen paste() und paste0() ein einfaches Schriftzeichenobjekt, wenn eines der Elemente ein Vektor ist, ergibt sich ein Schriftzeichen-Vektor.
paste("a", "b", "c", sep = " ")## [1] "a b c"paste("a", "b", "c", sep = "")## [1] "abc"paste0("a", "b", "c")## [1] "abc"paste("subject", 1:5, sep = "_")## [1] "subject_1" "subject_2" "subject_3" "subject_4" "subject_5"paste0("subject", 1:5)## [1] "subject1" "subject2" "subject3" "subject4" "subject5"Es gibt noch einige weitere nützliche Funktionen, um Vektoren zu manipulieren oder etwas über den Inhalt der Vektoren zu erfahren. Schauen Sie mal in Ihr Environment. Dort befinden sich jetzt drei einfache Variablen: summe, y und z. Alle anderen Variablen sind Vektoren. Sie sehen z.B. bei der Variable a, dass es sich um einen numerischen Vektor der Länge 3 (d.h. er enthält 3 Elemente) handelt: dort steht num [1:3]. num steht für numeric, die Notation [1:3] bedeutet, dass dies ein 1-dimensionales Objekt der Länge 3 ist. Um die Länge eines Vektors herauszufinden, ohne in Ihr Environment zu schauen, gibt es die Funktion length():
length(a)## [1] 3length(vec)## [1] 5Wenn Sie erfahren möchten, welche unterschiedlichen (einzigartigen) Elemente in einem Vektor sind, nutzen Sie unique():
vec <- c(1, 5, 2, 7, 6, 3, 7, 5)
unique(vec)## [1] 1 5 2 7 6 3vec <- c("i", "i", "a", "a", "E", "E", "E", "E", "U")
unique(vec) ## [1] "i" "a" "E" "U"Zuletzt stellen wir Ihnen noch eine sehr vielseitig einsetzbare Funktion vor, nämlich table(). Wenn diese Funktion auf einen Vektor angewendet wird, erhalten Sie als Ergebnis eine Auflistung der unterschiedlichen Elemente des Vektors mit ihrer Vorkommenshäufigkeit in diesem Vektor:
table(vec)## vec
## a E i U
## 2 4 2 1Im Vektor vec gibt es also zwei Mal das Element “a”, vier Mal das Element “E”, usw. Wir werden später noch sehen, wofür table() sonst noch eingesetzt werden kann.
Nachdem Sie jetzt wissen, was ein Vektor ist, möchten wir Ihnen noch eine Objektklasse namens Faktor (factor) vorstellen. Faktoren werden für kategoriale Daten verwendet, also solche, die nur eine begrenzte Anzahl an verschiedenartigen Werten annehmen können. Einen Faktor erzeugt man mit der Funktion factor(). Hier erzeugen wir zum Beispiel einen Faktoren-Vektor, der verschiedene Alterskategorien enthält:
age <- factor(c("jung", "alt", "alt", "mittel", "jung", "jung"))
class(age)## [1] "factor"age## [1] jung alt alt mittel jung jung
## Levels: alt jung mittelBei der Ausgabe des Faktors age, den wir angelegt haben, sehen wir zuerst die eingegebenen Werte in der eingegebenen Reihenfolge. Obwohl wir die Werte als Schriftzeichen eingegeben haben, werden sie nicht als Schriftzeichen (in Anführungszeichen) ausgegeben. Das liegt daran, dass dies jetzt nicht mehr einfache Schriftzeichen, sondern Kategorien sind. Die Kategorien werden auch Levels genannt und in der Ausgabe ebenfalls angezeigt. Man kann die Levels auch mittels der Funktion levels() abfragen:
levels(age)## [1] "alt" "jung" "mittel"Die Funktion factor() kann ein Argument namens levels bekommen, mit dem man die Levels selbst bestimmen und ihre Reihenfolge festlegen kann (R ordnet die Levels sonst alpha-numerisch aufsteigend).
age <- factor(c("jung", "alt", "alt", "mittel", "jung", "jung"),
levels = c("jung", "mittel", "alt"))
age## [1] jung alt alt mittel jung jung
## Levels: jung mittel altAuch numerische Werte können (in eher seltenen Fällen) kategorial sein. Nehmen wir an, Sie haben fünf Kommilitoninnen nach ihrem Alter in Jahren gefragt und die Werte in einem Vektor abgespeichert:
age <- c(22, 25, 23, 22, 23)Wenn Sie das Alter in Jahren als kategorial betrachten, können Sie den Vektor in einen Faktor umwandeln.
age <- factor(c(22, 25, 23, 22, 23))
age## [1] 22 25 23 22 23
## Levels: 22 23 25Eine äußerst wichtige Datenstruktur in R ist der Data Frame. Das ist eine zwei-dimensionale Tabelle. Die Zeilen werden auch observations genannt und die Spalten variables (nicht zu verwechseln mit den Variablen von vorhin!). In der Phonetik arbeiten wir sehr häufig mit Data Frames, z.B. wenn wir akustische Informationen aus Sprachaufnahmen oder Messungen aus einem Perzeptionsexperiment extrahiert haben und diese auswerten oder statistisch analysieren wollen.
In R gibt es verschiedene Möglichkeiten, eine Tabelle im Format .csv oder .txt einzulesen. Wenn Sie eine Tabelle von Ihrer Festplatte einlesen wollen, können Sie im Panel mit dem Environment in der Werkzeugleiste auf Import Dataset klicken und sich von dem Assistenten leiten lassen. Der Befehl, den der Assistent zum Laden des Data Frames verwendet, wird übrigens in der Konsole angezeigt.
In diesem Kurs werden wir u.a. Data Frames von einer Webseite benutzen, daher müssen wir den Befehl zum Einlesen selbst schreiben. Der Befehl, den wir verwenden, lautet read.table(), und bekommt als wichtigstes Argument in Anführungszeichen den Pfad (bzw. die URL) zu dem Data Frame (aber schauen Sie auf die Hilfeseite dieser Funktion, um alle Argumente und weitere verwandte Funktionen zum Einlesen von Daten zu sehen):
ai <- read.table("http://www.phonetik.uni-muenchen.de/~jmh/lehre/Rdf/ai.txt")Da wir im Verlauf der Vorlesung mehrere Data Frames von derselben Webseite verwenden werden, können wir das Einlesen etwas cleverer gestalten, damit wir nicht immer wieder die komplizierte URL abtippen oder kopieren müssen. Dafür legen wir eine Variable mit der URL als Schriftzeichenobjekt an und verwenden dann die Funktion file.path(), mittels derer die URL und der Dateiname zusammengefügt werden:
url <- "http://www.phonetik.uni-muenchen.de/~jmh/lehre/Rdf"
file.path(url, "ai.txt")## [1] "http://www.phonetik.uni-muenchen.de/~jmh/lehre/Rdf/ai.txt"# zusammen mit dem Befehl zum Einlesen:
ai <- read.table(file.path(url, "ai.txt"))Das Gegenstück zu read.table() ist write.table(), womit Sie einen Data Frame abspeichern können. Diese Funktion bekommt zuerst den Namen des Objekts, das abgespeichert werden soll, dann den Pfad samt gewünschtem Dateinamen (./ steht für das aktuelle Verzeichnis), und als weiteres optionales Argument nutzen wir row.names = FALSE, damit es nicht eine Spalte mit den (hier nicht vorhandenen) Zeilennamen in dem abgespeicherten Data Frame gibt.
write.table(ai, file.path("./", "ai.txt"), row.names = FALSE)Natürlich können Sie Data Frames nicht nur einlesen, sondern auch selbst erstellen. Dafür wird der Befehl data.frame() verwendet. Diese Funktion bekommt als Argumente die Spaltennamen und anschließend die Werte, die in der Spalte stehen sollen. Hier ein Beispiel:
df <- data.frame(F1 = c(240, 220, 250, 210, 280, 520, 510, 605, 670, 613),
vowel = rep(c("i","o"), each = 5))
df## F1 vowel
## 1 240 i
## 2 220 i
## 3 250 i
## 4 210 i
## 5 280 i
## 6 520 o
## 7 510 o
## 8 605 o
## 9 670 o
## 10 613 oData Frames haben eine eigene Objektklasse:
class(df)## [1] "data.frame"Wenn wir mit Datenstrukturen arbeiten, die viele Informationen enthalten, ist es wichtig, uns mit dem Objekt vertraut zu machen. R bietet viele nützliche Funktionen, um sich Data Frames anzuschauen und etwas über deren Eigenschaften zu erfahren:
# Data Frame in einem Sub-Fenster anschauen
View(ai)# Nur die ersten oder letzten paar Zeilen (Beobachtungen) ausgeben
head(ai)## F1 Kiefer Lippe
## 1 773 -25.47651 -24.59616
## 2 287 -27.02695 -26.44491
## 3 1006 -27.24509 -27.59161
## 4 814 -26.05803 -27.17365
## 5 814 -26.15489 -25.93095
## 6 806 -26.37281 -24.44872tail(ai)## F1 Kiefer Lippe
## 20 888 -25.99100 -26.84534
## 21 988 -26.27380 -28.26909
## 22 650 -26.50057 -24.31192
## 23 1026 -27.10303 -24.64248
## 24 992 -28.41081 -28.30641
## 25 896 -26.57372 -25.69383# Reihen- und Spaltenanzahl
nrow(ai)## [1] 25ncol(ai)## [1] 3dim(ai)## [1] 25 3# Spaltennamen (Variablennamen)
colnames(ai)## [1] "F1" "Kiefer" "Lippe"names(ai)## [1] "F1" "Kiefer" "Lippe"Obwohl wir in den kommenden Wochen mit der modernen tidyverse-Syntax arbeiten werden, wollen wir hier zeigen, wie man in traditioneller Weise auf Spalten in einem Data Frame zugreifen kann. Manchmal werden Sie nicht darum herum kommen, diese traditionelle Notation zu verwenden.
Wenn Sie in Ihr Environment schauen, sehen Sie, dass dort unter “Values” die ganzen einfachen Variablen und Vektoren stehen und unter “Data” finden Sie die zwei Data Frames ai und df. Als Informationen zu den Data Frames stehen im Environment immer die Anzahl an observations (Zeilen) und variables (Spalten), z.B. 25 obs. of 3 variables. Wenn Sie auf das kleine blaue Icon links neben dem Namen des Data Frames klicken, sehen Sie die Spaltennamen, welcher Objektklasse die Spalten angehören (int für integer, num für numerics bzw. doubles, usw.) und die ersten paar Werte aus der Spalte. Dieselben Informationen erhalten Sie, wenn Sie die Funktion str() (structure) auf einen Data Frame anwenden:
str(ai)## 'data.frame': 25 obs. of 3 variables:
## $ F1 : int 773 287 1006 814 814 806 938 1005 964 931 ...
## $ Kiefer: num -25.5 -27 -27.2 -26.1 -26.2 ...
## $ Lippe : num -24.6 -26.4 -27.6 -27.2 -25.9 ...str(df)## 'data.frame': 10 obs. of 2 variables:
## $ F1 : num 240 220 250 210 280 520 510 605 670 613
## $ vowel: chr "i" "i" "i" "i" ...Vor jeder Spalte in dieser Auflistung steht ein Dollarzeichen. Genau so können Sie auf Spalten in einem Data Frame zugreifen: Sie schreiben den Namen des Data Frames, dann (ohne Lehrzeichen!) das Dollarzeichen, und anschließend (wieder ohne Leerzeichen!) den Spaltennamen:
df$F1## [1] 240 220 250 210 280 520 510 605 670 613Sie sehen, dass eine Spalte an und für sich nichts anderes ist als ein Vektor! Das heißt, Sie können die Funktionen, mit denen wir zuvor Vektoren manipuliert haben, jetzt auch auf Spalten in Data Frames anwenden:
length(df$F1)## [1] 10table(df$vowel)##
## i o
## 5 5Weiterführende Informationen: Factors in Data Frames
Für den Data Frame df, den wir oben selbst angelegt haben, sehen Sie im Environment, dass die Spalte vowel der Objektklasse factor angehört, und dass dieser factor zwei levels hat – obwohl wir die Spalte vowel mit Schriftzeichen gefüllt hatten! Die Funktion data.frame(), mit der wir df erstellt haben, hat ein Argument namens stringsAsFactors, das, wenn nicht anders angegeben, automatisch TRUE ist. Das heißt, beim Erstellen des Data Frames wurden die Schriftzeichen in der Spalte vowel in einen factor umgewandelt. Die zwei verschiedenartigen Werte (Kategorien) in dieser Spalte sind “i” und “o”, dementsprechend hat dieser factor zwei levels.
Wenn Sie sich nochmal die Informationen zu dem Data Frame df im Environment oder Ihrer Konsole anschauen, werden Sie feststellen, dass die Spalte vowel nicht nur ein Faktor mit zwei Levels ist, sondern dass die ersten Werte in dieser Spalte komischerweise Zahlen sind und nicht “i” und “o”. Das liegt daran, dass Faktoren im Hintergrund (also für die NutzerInnen meist unsichtbar) als integer abgespeichert werden. Diese integer sind mit den einzigartigen Levels des Faktors assoziiert. Wenn also in unserem Environment bei der Spalte vowel der Wert 1 steht, dann repräsentiert dies das Level “i”, der Wert 2 repräsentiert das Level “o”.
Wenn Sie beim Erstellen des Data Frames verhindern möchten, dass strings in factors umgewandelt werden, verwenden Sie das Argument stringsAsFactors = FALSE:
df <- data.frame(F1 = c(240, 220, 250, 210, 280, 520, 510, 605, 670, 613),
vowel = rep(c("i","o"), each = 5),
stringsAsFactors = FALSE)Zuletzt möchten wir Ihnen noch einige wichtige Informationen zur Arbeit mit R und RStudio mitgeben.
Für R gibt es viele Tausend packages bzw. libraries, die uns die Arbeit erleichtern werden. Bitte installieren Sie nun folgende Packages (das dauert eine Weile!):
install.packages(c("Rcpp", "remotes", "knitr", "tidyverse", "magrittr", "rmarkdown", "emuR", "gridExtra"))
remotes::install_github("rlesur/klippy")Weiterführende Infos: Installation von R Paketen
Sollte der obige Befehl den Fehler installation of package had non-zero exit status werfen, hat die Installation nicht geklappt. Für Windows kann es sein, dass Sie in diesem Fall zusätzlich Rtools installieren müssen. Für MacOS müssen Sie ggf. die XCode command-line tools installieren und/oder resetten. Öffnen Sie dafür ein Mac Terminal und führen Sie folgende Befehle aus:
xcode-select --install
# Falls die Installation der R Packages dann immer noch nicht klappt:
xcode-select --resetWenn Sie sich unsicher sind, wie Sie auftretende Fehler bei der Installation der R Packages für Ihr Betriebssystem beheben können, können Sie uns auch gerne fragen!
Einige Basispakete werden automatisch aktiviert beim Öffnen von RStudio, die meisten aber müssen Sie erst laden, bevor Sie die Funktionen verwenden können, die die Pakete anbieten. Zum Laden von Packages benutzen Sie den Befehl library():
library(tidyverse)
library(emuR)Weiterführende Infos: Updates
Bitte überprüfen Sie regelmäßig, ob Ihre Packages Updates benötigen – die Updates werden in R nicht automatisch eingespielt! Klicken Sie hierfür in der Werkzeugleiste auf Tools > Check for Package Updates. Auch RStudio selbst erhält ab und zu Updates, dies können Sie überprüfen mit Help > Check for Updates.
R muss ebenfalls aktuell gehalten werden. Sie können Ihre R Version überprüfen mit getRversion(). Besuchen Sie einfach in regelmäßigen Abständen die R Webseite und schauen Sie, ob eine neue stabile Version verfügbar ist.
Eine Session beginnt, wenn man R bzw. RStudio startet bzw. wenn man ein Projekt öffnet. Man beendet eine Session entweder mit Session > Quit Session in der Werkzeugleiste oder mit Strg+Q bzw. Ctrl+Q. Die Session endet außerdem automatisch, wenn Sie RStudio schließen.
Sie werden dann gefragt, ob Sie das workspace image speichern wollen. Wenn Sie die Variablen, die Sie in der Session angelegt haben, im Environment behalten und in der nächsten Session wieder verwenden wollen, klicken Sie auf Save. Der workspace wird dann in Ihrem Kursverzeichnis in einer Datei mit der Endung .RData abgelegt. Wenn Sie den workspace nicht speichern möchten, klicken Sie auf Don't save. Falls Sie die Session doch nicht beenden wollen, klicken Sie auf Cancel.
Für diesen Kurs bitten wir Sie, den workspace nicht zu speichern (Don't save).
Die Konsole in RStudio ist die direkte Verbindung zu R, d.h. dort kann R Code direkt ausgeführt werden, so wie Sie das in dieser Vorlesung bisher gemacht haben. Um aber Ihren Code jederzeit replizieren zu können, müssen Sie ihn in einem Dokument festhalten. Üblicherweise werden Sie das in Ihrem Arbeitsalltag in einem R Skript machen. Ein R Skript kann einfach erstellt werden über File > New File > R Script (bzw. Strg + Shift + N) und sollte immer mit der Dateiendung .R abgespeichert werden. Ein R Skript enthält ausschließlich ausführbaren Code. Beim Ausführen eines Skriptes wird eine Zeile nur dann von R ignoriert, wenn sie mit # beginnt; dann ist die Zeile auskommentiert. Es gibt verschiedene Möglichkeiten, ein R Skript auszuführen. Markieren Sie die gewünschten Zeilen (wenn es nur eine Zeile ist, setzen Sie einfach den Cursor in die Zeile), und klicken Sie in der kleinen Werkzeugleiste im Panel mit dem geöffneten Skript auf Run oder drücken Sie Strg+Enter bzw. Ctrl+Enter. Das Ergebnis sehen Sie sofort in der Konsole.
In den letzten Jahren hat sich aber auch eine andere Dokumentart etabliert, insbesondere für die Erstellung von Berichten und Lehrmaterial: das R Markdown. R Markdown ist eine Art Textdokument, in das man Code Snippets einbetten kann, die ganz normal ausgeführt werden können (wie oben beschrieben). Ein solches Dokument enthält häufig mehr Text als Code. Sie können ein R Markdown erstellen mit File > New File > R Markdown und es ist Konvention, das Dokument mit der Dateiendung .Rmd abzuspeichern. Eine R Markdown Datei wird im Normalfall in ein anderes Format umgewandelt (“ge-knitted”), z.B. in eine HTML, eine PDF, oder sogar ein Word Dokument. Dies geschieht entweder über den Wollknäuel-Button mit der Aufschrift Knit oder mittels:
library(rmarkdown)
render("Uebung1.Rmd")Wir benutzen R Markdown, um z.B. die HTML herzustellen, die Sie gerade lesen. Auch Ihre Übungen werden Sie in einem R Markdown erledigen. Der Vorteil davon ist, dass Sie für jede Ihrer Übungen einen schönen HTML-Report haben und trotzdem gut am Code arbeiten können.
Ab der zweiten Vorlesungswoche werden wir Ihnen anstatt der HTML die rohe R Markdown Datei für die Vorlesung hochladen. Dies wird es Ihnen erleichern, den Code auszuprobieren, denn im Markdown können die Code Snippets wie gesagt direkt ausgeführt werden (u.a. auch über den kleinen grünen Pfeil oben rechts in jedem Code Snippet). Trotzdem können Sie die Vorlesung, wenn Sie sie in eine HTML umgewandelt haben, entspannt im Browser oder im RStudio Viewer (Panel unten rechts) lesen.
Im Markdown Dokument werden für Textmarkierungen besondere Zeichen verwendet, die dann beim knitten interpretiert und umgesetzt werden:
# Überschrift: Mit einem Hashtag bekommt man die größtmögliche Überschrift; je mehr Hashtags man benutzt, desto kleiner wird die Überschrift
**fett**: Mit doppeltem Asterisk vor und hinter einer Textpassage wird der Text fett gesetzt
*kursiv*: Mit einfachem Asterisk wird der Text kursiv
`code`: die einfachen rückwärts gewandten Anführungszeichen heben den darin enthaltenen Text hervor; das wird üblicherweise für Code oder Variablen benutzt, wenn man sich außerhalb eines Code Snippets befindet; dieser Code kann aber nicht ausgeführt werden!
```: Die dreifachen rückwarts gewandten Anführungszeichen markieren den Anfang und das Ende eine Code Snippets (auch Code Block genannt). Dazwischen darf nur Code geschrieben werden; Text muss mit einem Hashtag als Kommentar verfasst werden. Am Anfang des Code Snippets wird außerdem in geschweiften Klammern angegeben, welche Programmiersprache man im Code Block schreibt (in unserem Fall: {r}).
Noch mehr Informationen dazu finden Sie im Cheatsheet zu R Markdown (insb. Seite 2, linke Spalte).
Warnzeichen: Wenn Sie einen groben Syntaxfehler in einem Dokument haben, sehen Sie am Rand kleine rote Warnzeichen. Diese sollten nicht ignoriert werden, denn sie weisen darauf hin, dass Sie einen Fehler gemacht haben. Wenn Sie den Fehler korrigieren, verschwinden die Warnzeichen.
“Knit”: Wir empfehlen, dass Sie Ihr Markdown-Dokument regelmäßig, während Sie an der Übung arbeiten, in eine HTML überführen, indem Sie oben in der Werkzeugleiste auf “Knit” klicken. Wenn alles klappt, sehen Sie hoffentlich in einem neuen Fenster oder im Viewer (Panel unten rechts in RStudio) die kompilierte HTML. Wenn Sie aber Syntaxfehler oder andere Fehler in Ihrem Code haben, wird die HTML nicht erstellt und Sie kriegen stattdessen einen Fehler in der Konsole angezeigt. Dort sehen Sie auch, in welcher Zeile der Fehler ist.
Code einzeln ausführen: Führen Sie jede neu geschriebene Zeile Code aus. So sehen Sie Ihr Ergebnis und können überlegen, ob das Ergebnis das gewünschte ist oder nicht.
Es gibt eine sehr große und hilfsbereite R Community, die Ihnen das Programmieren lernen mit R erleichtern wird. Hier ein paar gute Links und Befehle, falls Sie mal nicht weiter wissen:
Stack Overflow: Ein Blog, auf dem Sie höchstwahrscheinlich eine Antwort auf Ihre Frage zu R finden werden. Am einfachsten googlen Sie Ihre Frage auf Englisch; die Antwort eines Mitglieds von Stack Overflow wird bei den ersten Suchergebnissen dabei sein.
Hadley Wickham’s “R for Data Science”: Hadley Wickham ist der Chief Programmer des “tidyverse”, mit dem wir uns noch auseinandersetzen werden. Seine Bücher sind sehr verständlich, gut strukturiert und kurzweilig zu lesen.
Cheatsheets: Das sind PDFs, die eine Funktionsübersicht mit Erklärungen und ggf. Beispielen in absoluter Kurzform bieten. Sie finden einige Cheatsheets in der obersten Werkzeugleiste unter Help > Cheatsheets. Insbesondere die ersten drei sind für Sie interessant. Ansonsten kann man Cheatsheets auch googlen und findet dann z.B. Data Transformation with dplyr oder diese sehr ausführliche Reference Card.
Vignetten: Zu einigen essentiellen Paketen gibt es so genannte “Vignetten”, das sind meist HTMLs oder PDFs, die die Autoren eines Pakets geschrieben haben. Sie können mit folgender Konsoleneingabe nach Vignetten suchen:
# zum Beispiel zu einer Library aus dem tidyverse:
vignette("dplyr")Help die gewünschte Funktion ins Suchfeld eingeben. Sie erhalten dann u.a. Informationen über die Argumente der Funktion und Beispiele. Dasselbe erreichen Sie über diese Konsoleneingaben (beispielhaft für Hilfe zur Funktion getwd()):?getwd
help("getwd")