Grundsätzlich lässt sich R
als Taschenrechner verwenden
und hat hierzu verschiedene Funktionen anzubieten:
2 * 3 + 10
[1] 16
33 + 5 * 22) / 4 (
[1] 35.75
sqrt(4) + 1
[1] 3
cos(pi / 4)
[1] 0.7071068
Objekte lassen sich mit =
oder <-
zuweisen. Um Objekte auf der Konsole auszugeben, können Sie einfach den
Namen schreiben und ausführen:
<- 12 * 4
x = 3 * 6
y x
[1] 48
y
[1] 18
Um die Verwechslung mit der Parameterzuweisung in Funktionen zu
vermeiden, sollten Sie immer <-
verwenden, um Objekte zu
erstellen. Mit Hilfe des Shortcuts Alt + '-'
können Sie
ebenfalls direkt den Operator <-
erhalten.
mean(x = c(1, 3, 5, 11, 2)) # '=' bei Funktionen
[1] 4.4
<- 3 # '<-' bei Zuweisungen
z z
[1] 3
Die allgemeine Syntax für Zuweisungen sieht dann so aus:
<- wert objekt_name
Die Namen von Variablen müssen mit einem Buchstaben beginnen und
dürfen ausschließlich Buchstaben, Zahlen, _
und
.
enthalten. Namen sollten bereits ihre Bedeutung
beschreiben.
Verschiedene Konventionen für Variablennamen sehen so aus:
das_ist_snake_case
mancheLeuteMögenCamelCase
andere.benutzen.punkte ein_kleinerRest.verwendet_alles.zurSelbenZeit
Verwenden Sie bevorzugt snake_case
.
Ähnlich wie bei diversen Messenger-oder Keyboard-Applikationen kann RStudio Namen/Funktionen vervollständigen.
Angenommen, es liegt ein sehr langer Name vor:
<- 55.3 das_ist_wohl_ein_sehr_langer_name
Wenn der Anfang eines Namens in RStudio eingetippt wird,
beispielsweise das
, und dann TAB gedrückt wird, werden die
passenden Namen/Funktionen vorgeschlagen oder gegebenfalls direkt
vervollständigt.
Ein weiterer Shortcut ist über Str + ↑
verfügbar. Wenn
wir den Anfang eines Befehls eingeben (z. B. das
) und
Str + ↑
drücken, erhalten wir mögliche Vorschläge, welche
zuvor ausgeführt worden. So könnten wir direkt den Wert von
das_ist_wohl_ein_sehr_langer_name
anpassen, wenn das
notwendig wäre.
In jeder Programmiersprache, so auch in R, ist das korrekte, präzise Schreiben von Namen und Funktionen notwendig.
Tippfehler sowie Groß-und Kleinschreibung sind sehr relevant, denn sonst wird R Ihren Befehl nicht verstehen:
<- 2 ^ 3 * sqrt(4) anzahl_steine
Folgende Befehle geben Fehler aus. Warum?
anzahl_stein
Fehler: Objekt 'anzahl_stein' nicht gefunden
Anzahl_steine
Fehler: Objekt 'Anzahl_steine' nicht gefunden
Als Hilfestellung dient hier die Autovervollständigung.
In R stehen bereits eine Vielzahl an Funktionen standardmäßig zur Verfügung, welche wie folgt aufgerufen werden:
funktions_name(argument1 = wert1, argument2 = wert2, ...)
Auch bei Funktionen ist die automatische Vervollständigung sehr
hilfreich. Wenn Sie beispielsweise se
eingeben und TAB
drücken, erhalten Sie direkt Vorschläge für alle möglichen Optionen
(Funktionen, Objekte, usw.), welche Sie mit den Pfeiltasten oder der
Maus auswählen können. Wenn wir hierbei seq()
auswählen,
können wir ebenfalls Hilfestellungen zu der Funktion einsehen. Ebenfalls
werden die notwendigen Klammern (
und )
bereits nach der Funktion gesetzt:
seq(1, 10)
[1] 1 2 3 4 5 6 7 8 9 10
Ebenfalls werden Zeichenketten, die zwischen zwei Anführungszeichen
"
stehen müssen, automatisch von RStudio als Paar
ergänzt:
<- "Hallo Welt!" hallo_welt
Anführungszeichen und Klammern müssen immer in einem Paar auftreten
(Funktionen, Zeichenketten, usw.). Bei einem fehlenden Symbol wird
RStudio in der Konsole ein +
ergänzen, d. h. RStudio wartet
auf eine geschlossene Klammer oder fehlende Anführungszeichen:
> hallo_welt <- "Hallo Welt!
+
Falls Sie ein +
in der Konsole sehen, drücken Sie
ESCAPE
oder vervollständigen Sie den Ausdruck und drücken
Sie ENTER
.
Falls Sie den Wert einer Zuweisung direkt einsehen wollen, können Sie eine von zwei Optionen auswählen:
<- seq(1, 10, length.out = 5)
sequenz sequenz
[1] 1.00 3.25 5.50 7.75 10.00
<- seq(1, 10, length.out = 5)) (sequenz
[1] 1.00 3.25 5.50 7.75 10.00
Wenn Sie eine Klammer um einen Ausdruck legen, wird der Wert ebenfalls zurückgegeben.
flights
DatensatzIn diesem Kapitel wird der Datensatz flights
betrachtet,
welcher alle Abflüge aus New York City des Jahres 2013 umfasst.
Der Datensatz ist in der Bibliothek nycflights13
enthalten und weitere Information lässt sich mit ?flights
erhalten.
Zuerst muss nycflights13
installiert werden:
library(tidyverse)
Registered S3 methods overwritten by 'dbplyr':
method from
print.tbl_lazy
print.tbl_sql
── Attaching packages ──────────────────────────────────────────────────────────────────────────────────────────────────────────────── tidyverse 1.3.2 ──✔ ggplot2 3.3.6 ✔ purrr 0.3.4
✔ tibble 3.1.8 ✔ dplyr 1.0.10
✔ tidyr 1.2.1 ✔ stringr 1.4.1
✔ readr 2.1.3 ✔ forcats 0.5.2 ── Conflicts ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────── tidyverse_conflicts() ──
✖ dplyr::filter() masks stats::filter()
✖ dplyr::lag() masks stats::lag()
if(!"nycflights13" %in% installed.packages())
install.packages("nycflights13")
library(nycflights13)
Dann lässt sich der Datensatz betrachten:
flights
Hier sehen wir erneut, dass es sich bei flights
um ein
Objekt names tibble
handelt:
is(flights)
[1] "tbl_df" "tbl" "data.frame" "list" "oldClass" "vector"
tibble
?tibble
(intern tbl_df
) gelten als
Erweiterung von Dataframes (data.frame
) und erleichtern die
Einsicht und Arbeit mit Dataframes durch mehr Einheitlichkeit. Mit
wenigen Ausnahmen lassen sich tibble
genauso wie Dataframes
verwenden.
Der tibble
zeigt bei der Ausgabe bereits alle wichtigen
Eigenschaften der Tabelle:
Die Dimension (Anzahl Spalten und Reihen) steht an oberster Stelle
(Abgekürzte) Spaltennamen und deren Datentyp
Eine begrenzte Ansicht auf die ersten Einträge
Analog zu Dataframes lassen sich bei tibbles
die
kompletten Tabellen mit View()
(z. B.
View(flights)
) anzeigen.
Die Datentypen umfassen:
int
steht für Ganzzahlen.
dbl
steht für Gleitkommazahlen bzw. reelle
Zahlen.
chr
steht für character
Vektoren oder
Zeichtenketten (strings).
dttm
steht für Datum-Zeit (Datum +
Uhrzeit).
lgl
steht für logisch, d. h. Vektoren aus
TRUE
oder FALSE
.
fctr
steht für Faktoren factors
, was
eine R-interne Repräsentation für Kategorien ist.
date
steht für Datum.
tibble
erstellenIn den meisten Fällen liegen Daten als Dataframes vor. Diese lassen
sich mit as_tibble()
direkt in einen tibble
umwandeln:
as_tibble(iris)
Dieses Beispiel hatten wir bereits am Anfang des Kurses gesehen.
Analog zu Dataframes lassen sich tibble
mit der
tibble()
Funktion erstellen, wobei die Spalten als Vektoren
angegeben werden und Spalten mit einer Länge von 1 automatisch
wiederholt werden:
tibble(
blumen = c("Iris", "Margerite", "Nelke", "Orchidee"),
farbe = c("lila", "weiß", "purpur", "gelb"),
anzahl = 3,
kelchblatt_laenge = c(5.2, 6.1, 3.2, 2.2),
kelchblatt_breite = c(3.5, 4.8, 4, 2.1),
kelchblatt_flaeche = kelchblatt_laenge * kelchblatt_breite - 1
)
Zusätzlich lassen sich bei tibble
auch unübliche
Variablennamen verwenden, die mit Zahlen oder Leerzeichen anfangen:
<- tibble(
tb `=)` = "longsmile",
` ` = "emptyspace",
`9` = "number"
) tb
$`9` tb
[1] "number"
Diese untypischen Namen müssen jedoch mit ``
umklammert
werden.
Es gibt noch weitere Möglichkeiten, tibble
zu erstellen,
z. B. durch tribble()
.
tibble
vs data.frame
tibble
zeigen vereinfacht die ersten 10 Einträge und die
Datentypen an. Mit Hilfe von print()
lässt sich hierbei
ebenfalls die Ausgabe verändern:
print(flights, n = 15, width = INF)
Die Ausgabeoptionen lassen sich ebenfalls nach belieben anpassen (siehe hier und hier).
Dataframes hingegen sind hier relativ unübersichtlich.
Bei Dataframes wird der []
Operator oder $
verwendet, um die Vektoren der Spalten zu erhalten
Bei tibble
verwenden wir hingegen [[]]
sowie $
, um Spalten durch ihre Position bzw. ihren Namen zu
erhalten:
<- tibble(var1 = 1:5, var2 = 6:10)
df
# tibble Spalten durch Name auswählen
$var1 df
[1] 1 2 3 4 5
"var1"]] df[[
[1] 1 2 3 4 5
# Spalte durch Position auswählen
1]] df[[
[1] 1 2 3 4 5
Zusätzlich gibt []
bei tibble
einheitlich
einen tibble
wieder:
1] df[
Da die Handhabung dieser Operatoren sehr mühselig ist und ab einer
bestimmten Komplexität sehr unübersichtlich, werden in
dplyr
Funktionen an deren Stelle verwendet
(filter()
oder select()
). Durch die Verwendung
von dyplr
wird der Code übersichtlicher und durch die
Funktionsnamen “spricht der Code”.
dplyr
Die Bibliothek dplyr
weist eine Vielzahl an Funktionen
auf, um Daten zu manipulieren. Einige davon sind sehr spezifisch und
andere werden so gut wie in jeder Analyse verwendet.
Die wichtigsten Funktionen sind:
filter()
: Beobachtungen (Reihen) anhand ihrer Werte
filtern.
arrange()
: Beobachtungen anordnen
(sortieren).
select()
: Variablen (Spalten) anhand ihres Namens
entnehmen.
mutate()
: Neue Variablen (anhand von Funktionen)
erstellen.
summarise()
: Werte auf eine Zusammenfassung
reduzieren (z. B. durch ihren Mittelwert).
Vorgehensweise:
Das erste Argument ist ein Dataframe (oder
tibble
)
Weitere Argumente beschreiben, wie die Daten manipuliert werden anhand der Variablennamen (ohne Anführungszeichen)
Als Ergebnis wird ein Dataframe geliefert (oder
tibble
)
Mit der Funktion filter()
lassen sich Beobachtungen
anhand ihrer Werte filtern. Das erste Argument ist stets der Dataframe,
gefolgt von Bedinungen, mit denen gefiltert werden soll:
filter(flights, month == 1 , day == 1)
Hierbei wird ein neuer Dataframe wiedergegeben. Sie sehen, dass der erste Tag des ersten Monats entnommen wird (erster Januar).
Um den neuen Dataframe zu speichern, muss erneut eine Variable angelegt (oder die alte überschrieben) werden:
<- filter(flights, month == 2, day == 10)
zehnter_februar zehnter_februar
Mit Hilfe der Operatoren >
, >=
, <
, <=
, !=
(ungleich), und ==
(gleich) lassen sich in R Beobachtungen filtern.
Um Gleichheit zu testen wird ==
verwendet und nicht der
Zuweisungsoperator =
:
filter(flights, month = 3)
Zusätzlich können Gleitkommazahlen bei Vergleichen zu Problemen führen (siehe hier).
Argumente von filter()
werden mit einem “UND” verknüpft,
d. h. alle Bedinungen müssen wahr sein, damit die Reihe betrachtet
wird.
Um weitere Kombinationen zu betrachten, werden logische Operationen verwendet:
&
: UND
|
: ODER
!
: NICHT
Die Bedeutung verschiedener logischer Operationen sehen Sie in der folgenden Grafik:
Wenn alle Abflüge im Januar oder Februar betrachtet werden sollen, so
muss das logische Oder |
verwendet werden:
filter(flights, month == 1 | month == 2)
Explizit muss hier nach beiden Monaten gefiltert werden und mit dem
oder |
verknüpft werden. Das entspricht nicht ganz dem
umgangssprachlichen Gebrauch.
Eine alternative Verwendung, um nach mehreren Kategorien gleichzeitig
zu filtern, ist die Verwendung von x %in% y
.
filter(flights, month %in% c(1, 2))
Diese Bedingung entspricht der Umgangssprache: “Der Monat soll Januar (1) oder Februar (2) liegen.)
Weiter Informationen zu logischen Ausdrücken lässt sich der booleschen Algebra entnehmen.
NAs
Fehlende Werte werden in R durch NA
markiert und sind
eine Schwierigkeit bei logischen Operationen, denn ihr Ergebnis ist
stets NA
:
NA > 10
[1] NA
NA == 10
[1] NA
10 + NA
[1] NA
NA / 10
[1] NA
NA == NA
[1] NA
Um nach NA
“Ausschau” zu halten, wird die
is.na()
Funktion verwendet:
<- NA
x is.na(x)
[1] TRUE
filter()
entfernt Bedingungen, die FALSE
oder NA
sind automatisch, können aber explizit mit
ausgewertet werden:
filter(flights, is.na(dep_time) & day > 3)
Ähnlich wie filter()
lassen sich mit
arrange()
Reihen verändern. Hierbei wird ein Dataframe nach
einer oder mehrerer Spalten angeordnet (z. B. absteigende
Sortierung).
Falls mehrere Spalten ausgewählt werden, wird auch nach allen Spalten sortiert und unterschieden:
arrange(flights, year, month, day)
Sie sehen, dass die Spalten nach dem Jahr, dem Monat und dem Tag (aufsteigend) sortiert werden. Angefangen wird hierbei mit den kleinsten Werten für den Monat und den Tag (hier: erster Januar).
Absteigend lässt sich ein Dataframe anhand von desc()
anordnen:
arrange(flights, desc(dep_delay))
Wenn wir für mehrere Spalten gleichzeitig absteigend sortieren
wollen, muss desc()
für jede Spalte angewandt werden:
arrange(flights, desc(year), desc(month), desc(day))
Es kann entsprechend auch für jede Spalte unterschiedlich sortiert werden:
arrange(flights, desc(month), day)
In diesem Beispiel wird der Dataframe absteigend nach dem Monat und aufsteigend nach dem Tag angeordnet.
NA
-Werte bilden hier wieder eine Ausnahme, denn sie
werden an letzter Stelle angeordnet:
<- tibble(x = c(5, 2, NA))
df arrange(df, x)
arrange(df, desc(x))
Um mit verschiedenen Daten umgehen zu können, müssen Sie auch verschiedene Daten/Datenstrukturen gesehen haben, daher betrachten wir immer unterschiedliche Datensätze.
In den folgenden Aufgaben wollen wir weiterhin den Datensatz
flights
betrachten, da dieser aufgrund seiner Größe etwas
komplexer ist:
library(tidyverse)
flights
Machen Sie sich mit dem Datensatz und den einzelnen Variablen
vertraut. Falls Sie Hilfe benötigen, verwenden Sie erneut
?flights
.
<- 10
irgendeine_variable irgendeine_varıable
lirbrary(tidyverse)
ggplot(dota = iris) +
geom_point(mapping = aes(x = Sepal.Length, y = Sepal.Width))
filter(mpg, cyl = 7)
filter(diamond, carat != 3)
flights
Datensatzes anhand
der folgenden Bedingungen:
Flüge mit einer Ankunftsverspätung arr_delay
von
über 10 Stunden
Flüge nach Seattle oder Kansas City (SEA
und
MCI
)
Flüge der Airlines United (UA
), American
(AA
) oder Delta (DL
)
Flüge im Winter (Dezember, Januar, Februar)
Flüge mit einer Verspätung arr_delay
von mehr als 3
Stunden, wobei der Abflug nicht verspätet war
(dep_delay
)
Flüge mit einer Abflugverspätung dep_delay
von mehr
als einer Stunde, die mehr als die Hälfte des Delays durch den Flug
wettmachen konnten
Flüge am späten Abend zwischen 22 Uhr und 24 Uhr
?between()
und ihre
Funktionalität. Würde diese Ihnen bei den vorherigen Aufgaben
helfen?dep_time
?
Was fällt Ihnen auf und wie können Sie sich diese Einträge
erklären?Finden Sie die Flüge mit der kleinsten und größten
Abflugverspätung dep_delay
Finden Sie den kürzesten und längsten Flug (bezogen auf die
Distanz distance
)
Finden Sie den schnellsten Flug (bezogen auf die Geschwindigkeit)