Skip to Tutorial Content

Hinweise

Eine R-Nutzerin, die bereits vorher einen R-Kurs belegt hat, bewertete dieses Tutorial insgesamt mit einer Schwierigkeit von 5.5 (0=sehr leicht, 10=sehr schwer). Sie brauchte für dieses Tutorial ungefähr 1.5h. Als absoluter Einsteiger wirst Du vermutlich etwas mehr Zeit benötigen. Klicke auf “Nächstes Kapitel” und es geht los.

Arithmetik mit der kleinen Nervensäge

Dein R-Kurs beginnt gerade, aber Deine kleine Schwester nervt schon seit Stunden, dass Du ihre Mathe-Hausaufgaben überprüfen sollst bevor sie diese an den Lehrer schickt. “Wenn R so toll ist, dann kannst Du das doch bestimmt damit machen”, sagt sie. Das stimmt, denn R ist eine Turing-Maschine.

Du schaust Dir die Aufgaben an:

  1. \(5462+124\)
  2. \(8733-9000\)
  3. \(12 \cdot 24\)
  4. \(16^4\)
  5. \(\frac{801}{3}\)
  6. \(\sqrt[4]{256}\)

“Alles nur Arithmetik”, denkst Du Dir und gibst die erste Zeile in R ein (drücke auf die Code ausführen-Schaltfläche rechts um den Befehl auszuführen):

5462+124

Das klappt. Also löst Du auch die restlichen Aufgaben. ACHTUNG: copy-pasten klappt nicht, Du musst die Zahlen eintippen!

Aufgabe b

\(8733-9000\)

8733-9000

Aufgabe c

\(12 \cdot 24\)

12*24

Aufgabe d

\(16^4\)

16^4
# Finde heraus welches Symbol fürs Potenzieren verwendet wird (z. B. bei einer Suchmaschine Deiner Wahl).

Aufgabe e

\(\frac{801}{3}\)

801/3

Aufgabe f

Die letzte Aufgabe erfordert allerdings einen Umweg, da R keinen Befehl kennt um die vierte Wurzel aus einer Zahl zu ziehen.

\(\sqrt[4]{256}\)

256^(1/4)
# Wie lässt sich die vierte Wurzel aus 256 anders schreiben?

Du zeigst Deiner Schwester die Ergebnisse und sie sagt nur cool und lakonisch zwei Worte: “R fetzt!”. Du selbst lässt Dich nicht so leicht beeindrucken, denn das Rechnen mit Zahlen ist was für Kinder. Du suchst die ultimative Herausforderung und willst mit Variablen rechnen!

Variablen, Skalare, Vektoren, Pizzen

Die einfachste Form von Variablen sind Skalare, Variablen mit nur einem Wert:

pi <- 3.14
z <- 14
a <- 1

Wie man sieht, kann man Variablen über den Zuweisungsoperator <- Werte zuweisen. Der Zuweisungsoperator besteht aus dem “kleiner als”-Symbol < und einem Minus -, zusammengesetzt sieht es dann aus wie ein nach links zeigender Pfeil. Man beachte hier zudem, dass das Dezimaltrennzeichen bei R ein Punkt und kein Komma ist (3.14 und nicht 3,14). Das Komma wird stattdessen bei Aufzählungen benutzt (3,14 wäre also 3 und 14). Gut merken, denn das ist ein häufiger Fehler bei Einsteigern..

Das Rechnen mit Variablen ist dann genauso einfach wie das Rechnen mit Zahlen:

pi*z*z*a
## [1] 615.44

Kleine Zwischenfrage:

Aufgabe

Ändere den Durchmesser der Pizza auf 32 und die Höhe auf 1.5. Führe die Berechnung erneut durch:

pi <- 3.14
z <- 16
a <- 1.5
pi*z*z*a

Möchte man mehrere Werte einer Variablen zuweisen, so benötigt man den combine-Operator c:

z <- c(14, 15, 16)
a <- c(2, 1.5, 1)

Im Grunde könnte man sagen, immer wenn ein c() zu sehen ist, kann man auch einfach “Vektor” denken (Kommas trennen die Elemente des Vektors). Da R vektor-orientiert ist, gehen nun auch solche Berechnungen:

pi*z*z*a
## [1] 1230.88 1059.75  803.84

Multiplizieren wir also Vektoren mit Skalaren, weiß R, dass er die Skalare auf die Länge der Vektoren bringen muss. Das ist ziemlich clever und geht in vielen anderen Programmiersprachen nicht!

Aufgabe

Bei einer veganen Pizzeria gibt es zwei Größen von Pizzen, 26 cm und 32 cm (Durchmesser). Heute ist Pizza-Tag und Du und Deine Freunde wollen jeweils eine Pizza bestellen. Da Du schon Erfahrung mit der Pizzeria hast, empfiehlst Du die folgenden drei Pizzen:

Pizza ⌀ 26 ⌀ 32
Speciale 9.00 € 12.50 €
Funghi 8.00 € 11.50 €
Margherita 6.00 € 9.50 €

Bei der Bestellung erfahrt Ihr, dass alle Pizzen eine Höhe von 1 cm haben. Einer Deiner Freunde ist knapp bei Kasse und sagt, dass er nicht mehr als 1.5 Cent pro Kubikzentimeter Pizza ausgeben möchte (er ist leicht nerdig, ja). Welche Pizzen kommen für ihn in Frage? Führe eine geeignete Berechnung in R durch. Erstelle dafür zunächst die Variablen Durchmesser (oder Radius) und Preis. Berechne dann das Volumen der Pizza und anschließend den Preis pro Kubikzentimeter.

preis <- c(9, 8, 6, 12.5, 11.5, 9.5)
durchmesser <- c(26, 26, 26, 32, 32, 32)
volumen <- (pi * (durchmesser / 2)^2 * 1)
preis_pro_kubikcm <- preis / volumen
preis_pro_kubikcm
preis <- c(9, 8, 6, 12.5, 11.5, 9.5)
durchmesser <- c(26, 26, 26, 32, 32, 32)
volumen <- (pi * (durchmesser / 2)^2 * 1)
# Was Du willst ist der Preis für einen Kubikzentimeter (Teile den Preis durch das Volumen).
preis_pro_kubikcm <- preis / volumen
preis_pro_kubikcm

Ihr gebt die Bestellung auf und genießt diesen Abend jeden Kubikzentimeter Pizza.

Dataframes

Zwar war die Lösung des Pizza-Problems in R zielführend, aber die Ausgabe des Ergebnisses als Vektor ist etwas unübersichtlich. Praktischer wäre eine Art Tabelle, bei der wir alle Variablen zu einer bestimmten Pizza direkt sehen. Und so eine Tabelle gibt es in R unter der Bezeichnung Dataframe. Wenn Du also Dataframe hörst, denke einfach: Tabelle.

Aus den bisherigen Vektoren lässt sich ein solcher Dataframe leicht konstruieren:

pi <- 3.14
preis <- c(9, 8, 6, 12.5, 11.5, 9.5)
durchmesser <- c(26, 26, 26, 32, 32, 32)
preis_pro_kubikcm <- preis / (pi * (durchmesser / 2)^2 * 1)
# nun erstellen wir den Dataframe:
d <- data.frame(preis, durchmesser, preis_pro_kubikcm)
#  und geben ihn aus
d

Wir verwenden also das Kommando data.frame und schreiben dann dort Vektoren mit Komma getrennt hinein. Beachte, dass ich am Ende für die Ausgabe den Dataframe nochmals hinschreibe (die letzte Zeile d), ansonsten würde R ihn nicht anzeigen, sondern nur erstellen.

Die Ausgabe sieht schon ganz gut aus, aber wir hätten gerne noch die Namen der Pizzen:

name <- c("Speciale", "Funghi", "Margherita", "Speciale", "Funghi",
          "Margherita")

Hier habe ich also einer Variablen mehrere Zeichenketten, auch Characters oder Strings (nicht was Du schon wieder denkst) genannt, zugewiesen. Diese müssen unbedingt in Anführungszeichen gesetzt werden. Warum? Weil R sonst denkt das wären auch Variablen, denn das folgende wäre ja prinzipiell auch möglich:

Speciale <- "ist gar nicht der Speciale-String, sondern die Variable"
Funghi <- "und das ist auch nicht der Funghi-Character, sondern die Variable"
name <- c(Speciale, Funghi, "Margherita", "Speciale", "Funghi",
          "Margherita")
name
## [1] "ist gar nicht der Speciale-String, sondern die Variable"          
## [2] "und das ist auch nicht der Funghi-Character, sondern die Variable"
## [3] "Margherita"                                                       
## [4] "Speciale"                                                         
## [5] "Funghi"                                                           
## [6] "Margherita"

Der einzige Unterschied zu vorher sind die Anführungszeichen bei Speciale und Funghi:

name <- c("Speciale", "Funghi", "Margherita", "Speciale", "Funghi",
          "Margherita")
name
## [1] "Speciale"   "Funghi"     "Margherita" "Speciale"   "Funghi"    
## [6] "Margherita"

Nun ist Deine Aufgabe einen Dataframe mit Namen, Preis, Durchmesser und Preis pro Kubikzentimeter zu erstellen und ihn anzuzeigen. Die ersten Befehle stehen schon da, Du musst also nur noch den Dataframe erzeugen und ihn ausgeben.

pi <- 3.14
preis <- c(9, 8, 6, 12.5, 11.5, 9.5)
durchmesser <- c(26, 26, 26, 32, 32, 32)
preis_pro_kubikcm <- preis / (pi*(durchmesser/2)^2 * 1)
name <- c("Speciale", "Funghi", "Margherita", "Speciale", "Funghi",
          "Margherita")
# erstelle nun auf den nächsten Zeilen den Dataframe und gib ihn aus!
pi <- 3.14
preis <- c(9, 8, 6, 12.5, 11.5, 9.5)
durchmesser <- c(26, 26, 26, 32, 32, 32)
preis_pro_kubikcm <- preis / (pi*(durchmesser/2)^2 * 1)
name <- c("Speciale", "Funghi", "Margherita", "Speciale", "Funghi",
          "Margherita")
# nun erstellen wir den Dataframe:
d <- data.frame(name, preis, durchmesser, preis_pro_kubikcm)
d

Bemerkenswert am Dataframe ist, dass er verschiedene Datentypen enthalten kann. Dies ist ganz anders zu einer Matrix, die aus einem einzigen Datentyp besteht (z. B. nur Zahlen oder nur Zeichenketten).

Es gibt noch andere Datentypen, die wir im Laufe des Kurses benutzen werden. Bei Datentypen kann man auch einfach an Skalenniveaus denken. Der Preis, Durchmesser und der Preis pro Kubikzentimeter sind alle verhältnisskaliert, der Name der Pizza ist hingegen nominalskaliert. Den Datentyp bekommt man durch den Befehl str (structure, also Struktur) heraus:

str(d)
## 'data.frame':    6 obs. of  4 variables:
##  $ name             : chr  "Speciale" "Funghi" "Margherita" "Speciale" ...
##  $ preis            : num  9 8 6 12.5 11.5 9.5
##  $ durchmesser      : num  26 26 26 32 32 32
##  $ preis_pro_kubikcm: num  0.017 0.0151 0.0113 0.0156 0.0143 ...

Nominalskalierte Variablen in R sind entweder characters oder factors. Bei der Variable name steht die Abkürzung chr, also eine Character-Variable. Die anderen Variablen haben den Datentyp num, also eine numerische Variable.

Die Datentypen zu kennen ist sehr wichtig, denn genau so wie bei Skalenniveaus, kann man mit bestimmten Datentypen nur ganz bestimmte Operationen durchführen. Einen Mittelwert über die Namen der Pizzen kann man beispielsweise nicht berechnen, sehr wohl aber über die anderen Variablen. Deshalb werden wir hin und wieder über solch trockene Themen sprechen müssen. Verhältnisskaliert und nominalskaliert haben wir schon, intervallskaliert ist ja ähnlich zu Verhältnis, dann fehlt nur noch ordinalskaliert:

geschmack <- factor(x = c("lecker", "sehr lecker", "lecker", "köstlich"), 
                    levels = c("lecker", "sehr lecker", "köstlich"),
                    ordered = TRUE)
geschmack
## [1] lecker      sehr lecker lecker      köstlich   
## Levels: lecker < sehr lecker < köstlich

Hier passiert sehr viel Neues, also aufpassen!

  • Wir verwenden das Kommando factor, um eine ordinalskalierte Variable zu erstellen.

  • Wir haben einen Vektor mit 4 Werten, den wir an x übergeben.

  • Dies machen wir mit einem Gleichheitszeichen =.

  • Beachte, dass lecker zweimal vorkommt.

  • Die Variable geschmack kann hier nur 3 unterschiedliche Werte annehmen. Diese sind Ihrer Reihenfolge nach im levels-Argument beschrieben.

  • Beachte den Parameter ordered = TRUE. Lassen wir ihn weg oder schreiben ordered = FALSE, so bekommen wir nur eine nominalskalierte Variable.

Wenn Du noch nicht alles verstehst, kein Problem, gleich siehst Du es nochmal und kannst es selbst üben.

Wir würden gerne zum Pizza-Dataframe noch die Variable geschmack hinzufügen. Speciale ist sehr lecker, Funghi ist köstlich und Margherita ist lecker.

Um dies zu bewerkstelligen, müssen wir den Dataframe nicht neu erstellen, sondern können ihm einfach eine neue Spalte hinzufügen:

cbind(d, geschmack = factor(x = c("sehr lecker", "köstlich", "lecker", "sehr lecker",
                                  "köstlich", "lecker"),
                            levels = c("lecker", "sehr lecker", "köstlich"),
                            ordered = TRUE))

Achte darauf, dass man an factor zwei Vektoren übergeben muss: An x den Vektor, wie er zu den Pizzen passt. Und an levels die richtige Reihenfolge für die Rangordnung. Sonst geht es schief!

cbind steht hier für columnbind, also “füge eine neue Spalte an einen vorhandenen Dataframe”. Weiterhin zu beachten ist, dass ich der Spalte einen Namen gebe (geschmack). Hier haben wir allerdings vergessen, diesen neuen Dataframe einer Variablen zuzuweisen. Das heißt, wir haben immer noch den alten Dataframe auf d gespeichert und die Variable geschmack ist nirgends aufzufinden:

d

Die Lösung: einfach nochmal auf die Variable d zuweisen:

d <- cbind(d, geschmack = factor(x = c("sehr lecker", "köstlich", "lecker", 
                                       "sehr lecker", "köstlich", "lecker"),
                                 levels = c("lecker", "sehr lecker", "köstlich"),
                                 ordered = TRUE))
d

In Deinem Freundeskreis gibt es ein paar Champignon-Allergiker. Praktischerweise listet die Pizzeria auf, ob Champignons eine Zutat in der jeweiligen Pizza ist. Auf der Funghi sind natürlich viele Champignons, auf der Speciale sind auch ein paar drauf, aber auf der Margherita keine. Erstelle zunächst den Vektor champignon als ordinale Variable mit 6 Elementen:

  • etwas, viel, keine, etwas, viel, keine

Dies entspricht der Reihenfolge der Pizzen: Speciale, Funghi, Margherita, Speciale, Funghi, Margherita. Gib den Vektor champignon aus.

# Schau Dir nochmal das Beispiel von oben zur Erstellung einer ordinalen 
# Variable an (geschmack)
champignon <- factor(x = c("etwas", "viel", "keine", "etwas", "viel", "keine"),
                     levels = c("keine", "etwas", "viel"),
                     ordered = TRUE)
champignon

Füge dem Dataframe die Variable champignon hinzu und gib den neuen Dataframe aus.

pi <- 3.14
preis <- c(9, 8, 6, 12.5, 11.5, 9.5)
durchmesser <- c(26, 26, 26, 32, 32, 32)
preis_pro_kubikcm <- preis / (pi*(durchmesser/2)^2 * 1)
name <- c("Speciale", "Funghi", "Margherita", "Speciale", "Funghi",
          "Margherita")
d <- data.frame(name, preis, durchmesser, preis_pro_kubikcm)
d <- cbind(d, geschmack =  factor(c("köstlich", "sehr lecker", "lecker",
                                    "köstlich", "sehr lecker", "lecker"),
                                  ordered = TRUE))
champignon <- factor(x = c("etwas", "viel", "keine", "etwas", "viel", "keine"),
                     levels = c("keine", "etwas", "viel"),
                     ordered = TRUE)
# füge nun dem Dataframe noch die Variable champignon hinzu, gib den Dataframe
# aus und lass Dir die Struktur anzeigen
pi <- 3.14
preis <- c(9, 8, 6, 12.5, 11.5, 9.5)
durchmesser <- c(26, 26, 26, 32, 32, 32)
preis_pro_kubikcm <- preis / (pi*(durchmesser/2)^2 * 1)
name <- c("Speciale", "Funghi", "Margherita", "Speciale", "Funghi",
          "Margherita")
d <- data.frame(name, preis, durchmesser, preis_pro_kubikcm)
d <- cbind(d, geschmack =  factor(c("köstlich", "sehr lecker", "lecker",
                                    "köstlich", "sehr lecker", "lecker"),
                                  ordered = TRUE))
# füge nun dem Dataframe noch die Variable champignon hinzu
champignon <- factor(x = c("etwas", "viel", "keine", "etwas", "viel", "keine"),
                     levels = c("keine", "etwas", "viel"),
                     ordered = TRUE)
d <- cbind(d, champignon)
d
# und Struktur anzeigen
str(d)

Super, Du weißt jetzt was ein Dateframe ist und kannst selbst welche erstellen. Über Dataframes ist es viel leichter zu erkennen, welche Pizzen zu teuer für Deinen Freund sind und auf welchen Champignons drauf sind. Man kann mit Dataframes noch mehr tolle Sachen machen, wie Du in Tag 2 sehen wirst. Nun wäre es aber noch ganz praktisch unseren generierten Dataframe für später zu speichern.

Speichern und Laden von Daten

Speichern

In diesem Tutorial kannst Du aus Sicherheitsgründen keine Daten abspeichern, denn dann hättest Du Schreib-Zugriff auf unseren Server. Das Abspeichern von Daten ist aber nicht weiter schwer, sodass ich Dir hier einfach nur den Befehle zeige:

write.csv(d, file = "data/pizzen.csv")

Das speichert unseren Dataframe unter dem Namen pizzen.csv im Verzeichnis data ab. Bei einer csv-Datei sind die Werte (values) durch Kommas (comma) getrennt (separated): comma separated values. Dieses Format ist sehr beliebt, da es sowohl für Menschen als auch Maschinen leicht zu lesen ist. Um den Datensatz wieder zu laden schreibst Du einfach:

pizzen <- read.csv("data/pizzen.csv")
pizzen

Du kannst natürlich auch eine andere Variable als pizzen für die Zuweisung benutzen.

R gibt uns auch die Möglichkeit Objekte in seinem eigenen Dateiformat zu speichern:

saveRDS(d, file = "data/pizza2.rds")

Das laden läuft dann so ab:

pizzen2 <- readRDS("data/pizza2.rds")
pizzen2

Willst Du alle Variablen, die gerade in R verfügbar sind abspeichern, dann benutze:

save.image("data/workspace.RData")

Zum Laden all dieser Variablen:

load("data/workspace.RData")

Beim letzten Befehl darfst Du den load-Befehl keiner Variablen zuweisen; vorher haben wir immer <- benutzt. Das ist diesmal nicht nötig, denn es sind ja ganz viele Variablen, die wir laden wollen. R macht das automatisch für uns.

Wie gesagt, kannst Du leider das Speichern von Daten hier nicht üben. Jedoch ist das Speichern nicht ganz so wichtig, denn später wirst Du Skripte schreiben, die Rohdaten einlesen und verarbeiten. Daher ist es viel wichtiger Daten zu laden als zu speichern.

Wenn Du dennoch üben willst, machst Du das am besten auf Deiner lokalen R-Version. Installier Dir R (eine Anleitung findet sich hier: https://jjallaire.shinyapps.io/learnr-tutorial-00-setup/). Dann starte R, generiere Dir einen Dataframe oder einen Vektor und versuche ihn abzuspeichern. Wenn das klappt, kommst Du einfach wieder zu diesem Tutorial zurück.

Laden

Obwohl Du in diesem Tutorial keine Schreibrechte hast, hast Du Zugriff auf den Ordner data. Schauen wir uns mal an, was alles unter data gespeichert ist mit dem Befehl dir (für directory):

dir("data")
##  [1] "imdb.rds"            "mea.sav"             "monate.csv"         
##  [4] "mordor.png"          "pizza.rds"           "pizza2.rds"         
##  [7] "pizzen_komplett.csv" "pizzen.csv"          "pizzen2.txt"        
## [10] "selfesteem.csv"      "starwars.rds"        "students.rds"       
## [13] "ws19.rds"            "youtuber.csv"

Das sind ein paar Datensätze, die wir später benutzen werden. Wie Du an den verschiedenen Dateiendungen siehst, gibt es in R viele verschiedene Möglichkeiten Daten zu speichern und zu laden. Insbesondere das Laden solltest Du drauf haben, denn verschiedene Software-Pakete, Forscher und Institutionen benutzen teilweise recht unterschiedliche Dateiformate. Daher üben wir jetzt ein paar gängige Datentypen einzulesen:

Aufgabe

Lies die Datei monate.csv aus dem Verzeichnis data ein und gib diesen anschließend über den Befehl head aus (hab ich Dir unten schon vorgegeben). head gibt die ersten paar Zeilen aus, was hier günstig ist da die Datensätze recht groß sind und sonst den Bildschirm zumüllen. Die Lücke ____ zeigt an, dass dort etwas fehlt.

monate <- ____
head(monate)
monate <- read.csv("data/monate.csv") # liest Daten ein
head(monate) # gibt die ersten paar Zeilen aus

Manchmal sind Daten nicht durch ein Komma getrennt und es fehlt die Kopfzeile, z. B. beim Datensatz pizzen2.txt (wieder unter data), der so aussieht:

"Speciale":9:26:0.02:"sehr lecker"
"Funghi":8:26:0.02:"köstlich"
"Margherita":6:26:0.01:"lecker"
"Speciale":12.5:32:0.02:"sehr lecker"
"Funghi":11.5:32:0.01:"köstlich"
"Margherita":9.5:32:0.01:"lecker"

Hier sind die Daten getrennt durch einen Doppelpunkt : – dies dient nur der Illustration und wird bei realen Daten wohl kaum vorkommen. Und, wie erwähnt, es fehlt die Kopfzeile. Mit read.csv kommt man hier also nicht weiter, da R jede Zeile als eine Variable einliest:

read.csv("data/pizzen2.txt")

Aufgabe

Schau Dir die Hilfe zu read.table aus (entweder über ?read.table oder eine Websuche) und finde heraus wie man den Datensatz pizzen2.txt einlesen kann.

pizzen2 <- read.table(____, ____, ____)
head(pizzen2)
pizzen2 <- read.table("data/pizzen2.txt", header = F, sep = ":")
head(pizzen2)

Aufgabe

Lies die Datei ws19.rds aus dem Verzeichnis data ein:

ws19 <- ____
head(ws19)
ws19 <- readRDS("data/ws19.rds")
head(ws19)

Aufgabe

Zu guter letzt, SPSS-Daten mit dem Namen mea.sav, wieder unter data. Wir lesen sie über das Hilfspaket foreign ein (mehr zu Paketen an Tag 2). Der Befehl heißt read.spss und wir wollen am Ende einen Dataframe bekommen, weshalb ich schon mal to.data.frame auf TRUE gesetzt habe (Details zu TRUE/FALSE kommen noch im Laufe des Tutorials).

mea <- ____(____, to.data.frame = TRUE)
head(mea)
mea <- read.spss("data/mea.sav", to.data.frame = TRUE)
head(mea)

Wow, jetzt kannst Du sogar Deine alten SPSS-Daten in R einlesen und SPSS wegschmeißen. Gar nicht übel, wie sich Deine Skills entwickeln:

  • Daten einlesen, yep.
  • Wissen, was ein Dataframe ist, kein Problem.
  • Einfache Datentypen in R kennen, boring.
  • Variablen Werte zuweisen und diese in R ausgeben, viel zu einfach.

Du kennst die Befehle:

  • c
  • data.frame
  • cbind
  • factor
  • str
  • write.csv
  • read.csv
  • saveRDS
  • readRDS
  • read.spss
  • head

Im Grunde werden wir in den nächsten Schritten einfach nur viele weitere Befehle solcher Art lernen. Genauer gesagt sind es nicht einfach Befehle, sondern es sind Funktionen, unser letztes Thema für Tag 1.

Funktionen-Analogie und Hilfe

Funktionen kennst Du schon aus der Mathematik. Das ist kein großer Unterschied zu R (oder anderen Programmiersprachen): Funktionen nehmen einen oder mehrere Parameter auf und geben einen Wert zurück, z. B.: \(f(x_1, x_2) = y(x_1, x_2) = 0.5x_1+3x_2^2\). Die Funktion nimmt \(x_1, x_2\) auf und gibt \(y\) zurück. So ist es auch in R: c(x_1, x_2, ..., x_n) nimmt \(n\) Werte auf und gibt einen Vektor bestehend aus diesen Werten zurück. factor(x, levels, ordered) nimmt drei Werte auf, einen Vektor x, einen Vektor levels und einen logischen Wert ordered, der entweder wahr (TRUE) oder falsch (FALSE) ist. Zurück gibt die Funktion eine nominale oder ordinale Version von x. In R weisen wir üblicherweise die Rückgabewerte dieser Funktionen einer Variablen zu und rechnen dann damit weiter.

Was ich über die Anzahl der Parameter geschrieben habe, stimmt nicht ganz, denn die Funktionen c() und factor() nehmen eigentlich noch mehr Parameter auf; man kann mit ihnen also noch viel mehr machen. Da Du schon bald viele neue Funktionen benutzen wirst, ist es gut zu wissen, welche Parameter diese Funktionen haben und was sie zurückgeben. Genauso wie bei einer mathematischen Funktion, bei der Du ja auch wissen willst, was \(x\) und \(y\) überhaupt sind. Hierfür ist es essentiell, dass Du verstehst wie man die Hilfe in R benutzt. Sagen wir mal, ich behaupte, dass es in R eine Funktion mean gibt. Dann kannst Du herausfinden wie man diese Funktion benutzt, indem Du Dir die Hilfe dazu anschaust (führe den Befehl einfach aus):

help(mean)

Die Sektion Arguments ist hierbei am interessantesten. Sie sagt uns, dass der erste Parameter x ein Vektor sein kann (aber auch andere Datentypen sind möglich). Die restlichen Parameter interessieren uns erst mal nicht. In der Sektion Value sehen wir, was die Funktion zurückgibt: Den Mittelwert aller Werte von x (“the arithmetic mean of the values in x is computed”). Probieren wir es:

mean(preis)
## [1] 9.416667

Der Durchschnittspreis der Pizzen beträgt 9.4166667 €. Die Funktion mean ist natürlich einfach zu benutzen, aber es gibt auch kompliziertere Funktionen. Immer wenn Du nicht weiter weißt, gib in die R-Konsole ein Fragezeichen ein, gefolgt von der Funktion, über die Du mehr erfahren möchtest.

Rufe die Hilfe zur Funktion mad auf und lies sie durch:

?mad

Oft weiß man gar nicht, wie eine Funktion heißt. In diesem Fall bringt die Hilfe über help wenig. Man kann in R zwar eine Volltextsuche machen, aber diese liefert üblicherweise eine ganze Fülle an unübersichtlichen Ergebnissen.

Im Normalfall wird es hilfreicher sein, bei einer Suchmaschine Deiner Wahl das Stichwort kombiniert mit “r stats” zu suchen. Die Seiten https://www.statmethods.net/ (quick-r) und https://stackoverflow.com/ sind auch sehr hilfreich. Es gibt allgemein sehr viele Online-Materialien zu R. Wenn Du also denkst, dass es eine bestimmte Funktionalität in R geben müsste, findest Du diese am schnellsten durch einen Websuche.

Eine weitere Möglichkeit sind Cheatsheets, die häufig benutzte Befehle knapp und klar und visuell ansprechend darstellen. Eine Sammlung von solchen Cheatsheets als Print-Version gibt es zum Beispiel hier: https://amzn.eu/d/4XsE1v0

Wir werden später nochmal über Funktionen sprechen, denn man kann auch eigene Funktionen schreiben, um Dinge zu tun, die R von alleine nicht kann. Dazu ist zu sagen, dass interessanterweise in R alles eine Funktion ist. Auch die Arithmetik-Symbole + - * / ^ sind Funktionen und auch der Zuweisungsoperator <-. Die Syntax dieser Funktionen ist etwas anders, aber im Grunde könnte man z. B. auch das Addieren als Funktion bezeichnen. Sie nimmt zwei Parameter auf (die Summanden) und gibt einen Wert zurück (die Summe). Du glaubst mir nicht? Dann führe mal folgende Code-Zeile aus:

`+`(4, 4)

Verrückt! Das schreibt aber natürlich keiner so. Es soll nur nochmal die Funktionen-Analogie deutlich machen. Da das + ein besonderes Symbol in R ist, müssen wir es in diese komischen Anführungszeichen setzen. Am besten vergisst Du das gleich wieder. Merke Dir nur, dass in R alles eine Funktion ist. Funktionen nehmen Parameter auf und geben einen Wert zurück und Funktionen haben natürlich einen Namen.

R zu beherrschen ist nichts anderes als sich Wissen über Funktionen anzueignen. Somit ist das erlernen einer Programmiersprache nicht viel anders als das erlernen einer normalen Sprache: Man muss die Vokabeln kennen und auch die Grammatik. Heute hast Du gelernt jemanden zu begrüßen, Deinen Namen und Dein Alter zu sagen. Am zweiten Tag erweitern wir unseren Vokabelschatz und lernen die Grammatik des Selektierens. Für den heutigen Tag bleibt eine Abschlussaufgabe übrig, die einige der Themen nochmal wiederholt.

Abschlussaufgabe Tag 1

Du interviewst mehrere Youtuber, um einen Bericht über deren Arbeitsbedingungen zu schreiben. 5 der Youtuber haben ein Monatseinkommen von rund 2500€, weitere 5 ein Monatseinkommen von rund: 2600€, 2700€, 2800€, 2900€ und 3000€. Der 11. Youtuber, den Du interviewst, ist ziemlich populär und hat ein Monatseinkommen von 100 000€. Welche Auswirkungen ergeben sich durch den Superstar auf den Modus, den Median und das arithmetische Mittel der Monatseinkommen aller interviewten Youtuber? Berechne zur Beantwortung der Frage die zentralen Lagemaße ohne und mit dem Youtube-Star.

Erstelle zunächst zwei Vektoren gehalt und gehalt_mit_star. Um die Erstellung zu vereinfachen, nutze die Funktion rep. Berechne die entsprechenden Lagemaße. Nutze hierfür notfalls die Hilfe und das www, um die richtigen Funktionen zu finden. Hinweis: Es gibt keine Modus-Funktion in R, benutze stattdessen die Funktion table.

gehalt <- c(rep(2500, 5), 2600, 2700, 2800, 2900, 3000)
gehalt_mit_star <- c(rep(2500, 5), 2600, 2700, 2800, 2900, 3000, 1e5)
gehalt <- c(rep(2500, 5), 2600, 2700, 2800, 2900, 3000)
gehalt_mit_star <- c(rep(2500, 5), 2600, 2700, 2800, 2900, 3000, 1e5)
# jetzt finde die entsprechenden Funktionen für Mittelwert und Median,
# für den Modus kannst Du die Funktion table benutzen
gehalt <- c(rep(2500, 5), 2600, 2700, 2800, 2900, 3000)
gehalt_mit_star <- c(rep(2500, 5), 2600, 2700, 2800, 2900, 3000, 1e5)
# mittelwerte
mean(gehalt)
mean(gehalt_mit_star)
# Differenz:
mean(gehalt) - mean(gehalt_mit_star)

# mediane
median(gehalt)
median(gehalt_mit_star)

# modi
table(gehalt)
table(gehalt_mit_star)
Quiz

Berechne das Jahresgehalt für jeden Youtuber (auch dem Star) und vergleiche die Standardabweichung (Funktion sd) des Monats- und Jahresgehaltes.

gehalt_mit_star <- c(rep(2500, 5), 2600, 2700, 2800, 2900, 3000, 1e5)
# und jetzt weiter:
# Für Teilaufgabe 1 musst Du die Gehälter nur mit 12 multiplizieren
# Für Teilaufgabe 2 musst Du die Funktion sd anwenden
gehalt_mit_star <- c(rep(2500, 5), 2600, 2700, 2800, 2900, 3000, 1e5)
jahreseinkommen <- gehalt_mit_star * 12
sd(gehalt_mit_star)
sd(jahreseinkommen)
Quiz

Erstelle einen Dataframe aus dem Monats- und Jahresgehalt aller Youtuber, sowie dem Geschlecht (die Reihenfolge entspricht der Gehaltsreihenfolge von oben):

  • weiblich, weiblich, weiblich, weiblich, männlich, weiblich, weiblich, männlich, männlich, männlich, männlich

Füge anschließend die ordinalskalierte Variable yterfahrung hinzu (die Reihenfolge entspricht der Gehaltsreihenfolge von oben):

  • wenig, wenig, wenig, mittel, wenig, mittel, mittel, wenig, mittel, mittel, hoch.

Gib den Dataframe aus und zeige Dir die Datentypen der Variablen an.

gehalt_mit_star <- c(rep(2500, 5), 2600, 2700, 2800, 2900, 3000, 1e5)
jahreseinkommen <- gehalt_mit_star * 12
# und jetzt weiter:
gehalt_mit_star <- c(rep(2500, 5), 2600, 2700, 2800, 2900, 3000, 1e5)
jahreseinkommen <- gehalt_mit_star * 12
geschlecht = c(rep("w", 4), "m", "w", "w", "m", "m", "m", "m")
data <- data.frame(gehalt_mit_star, jahreseinkommen, geschlecht)

# yterfahrung hinzufügen
yterfahrung = factor(x = c("wenig", "wenig", "wenig",
                           "mittel", "wenig", "mittel", "mittel",
                           "wenig", "mittel", "mittel", "hoch"),
                     levels = c("wenig", "mittel", "hoch"),
                     ordered = TRUE)
data <- cbind(data, yterfahrung)

# ausgeben
data
str(data)

Wie könntest Du den Dataframe abspeichern? Geh davon aus, dass der Dataframe data heißt; der Speicherort spielt keine Rolle solange es ein gültiger Pfad ist.

Der Datensatz wurde tatsächlich unter data/youtuber.csv gespeichert. Das Trennzeichen war ein Semikolon, es gibt keine Kopfzeile. Lies den Dataframe ein und gib ihn aus:

read.table("data/youtuber.csv", header = F, sep = ";")
# alternativ:
read.csv2("data/youtuber.csv", header = F)

Glückwunsch zum Überleben des ersten Tages! Hast Du Fragen oder Anregungen, dann schreibe eine Mail an frage at rlernen.de

1. Intro