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:

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

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

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

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

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

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

load("data/workspace.RData")

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"

monate <- ____
head(monate)

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

"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"

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

pizzen2 <- read.table(____, ____, ____)
head(pizzen2)

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

ws19 <- ____
head(ws19)

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

mea <- ____(____, to.data.frame = TRUE)
head(mea)

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

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)

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)

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