Grundlagen in R

Abbildung 1: Diagramm über die unterschiedlichen Ausprägungen eines Objekts in R.

R ist eine objektorientierte, funktionale Programmiersprache. Oder um es in den Worten von John Chambers, Entwickler der Software S und ihres Nachfolgers R, zu sagen: „Alles, was existiert, ist ein Objekt. Alles, was passiert, ist ein Funktionsaufruf.“ Ob Sie also mit einer Zahl arbeiten oder mit einer Zeichenkette, ist im übergeordneten Sinne irrelevant – eine Zahl ist ebenso ein Objekt wie eine Zeichenkette. Darauf aufbauend ist eine Feinabstufung möglich: Bei einem Objekt kann es sich um eine Funktion handeln – oder um Daten. Daten wiederum erlauben eine Untergliederung in Datentypen und Datenstrukturen, die beide jeweils weitere Verästelungen nach sich ziehen (Abbildung 1).

Objekte und Zuweisungen

Ein Objekt auf Datenebene ist demzufolge nichts anderes als ein Auffangbehälter, der weitere Objekte unterschiedlichsten Typs und unterschiedlichster Struktur beinhalten kann. Für den Anfang stellen Sie sich jedoch erst einmal ein Objekt vor, das aus einem einzigen Wert (beispielsweise der Zahl 5) besteht. Möchten Sie dieses Objekt später für weitere Berechnungen verwenden, ohne permanent 5 eingeben zu müssen, können Sie ihm einen Namen zuweisen:

x <- 5
x
## [1] 5

Umgangssprachlich ausgedrückt teilen Sie R mit: Nehme den Namen x und übergebe ihm (<-) die Zahl 5. Das Objekt namens x enthält nun den Wert 5. Wie Sie durch Eingabe des vorhergehenden Codes vielleicht schon bemerkt haben, gibt Ihnen R den Inhalt eines Objekts nicht automatisch zurück – Sie müssen den Namen des Objekts in die Konsole eingeben und ausführen (hier x in Zeile 2). Im Prinzip speichern Sie ein Objekt durch Zuweisung eines Namens also immer nach folgendem Schema ab: name <- objekt.

Namen müssen folgenden Vorschriften genügen:

• Sie dürfen keine Leerzeichen enthalten.
• Sie dürfen nicht mit einer Zahl beginnen (1x ist nicht erlaubt).
• Auf Namen, die mit einem Punkt beginnen, darf keine Zahl folgen (.1x führt zu einer Fehlermeldung, .x1 verursacht jedoch keine Probleme).
• Sie dürfen nicht von R vorbelegt sein.

Bis auf diese Ausnahmen sind alle Buchstaben , alle Zahlen und die Zeichen _ (Unterstrich) und . (Punkt) erlaubt. Eine weitere Anmerkung: R unterscheidet grundsätzlich zwischen Groß- und Kleinschreibung. Ein Objekt namens A1 ist daher nicht identisch mit einem Objekt namens a1. In jedem Fall ist es jedoch empfehlenswert, sich für eine Konvention bei der Namenszuweisung zu entscheiden und diese im gesamten Skript einzuhalten. Sie können beispielsweise eine dieser Regeln verwenden:

• Namen bestehen nur aus Kleinbuchstaben. Bei mehreren Wörtern wird kein Trennzeichen verwendet (digitalhumanities).
• Namen bestehen nur aus Kleinbuchstaben. Als Trennzeichen wird ein Punkt (digital.humanities) oder Unterstrich (digital_humanities) verwendet.
• Namen mit einem Wort bestehen aus Kleinbuchstaben. Bei Namen mit mehreren Wörtern wird das erste Wort klein geschrieben, die restlichen Wörter leiten mit einem Großbuchstaben ein (digitalHumanities).
• Namen bestehen aus Klein- und Großbuchstaben. Ein Wort wird durch einen Großbuchstaben eingeleitet (DigitalHumanities).

Datentypen

Ein Objekt lässt sich auf elementarster Ebene näher spezifizieren – über seinen Datentyp. Die drei wichtigsten Datentypen in R lauten: numeric, character und logical. Handelt es sich bei Ihrem Objekt um eine Zahl, ordnen Sie den entsprechenden Datentyp also vermutlich bereits intuitiv richtig zu: numeric. Auch die weiteren zwei Typen sind annähernd selbsterklärend: character ist der Container für Zeichen (beispielsweise Buchstaben), logical der Container für Wahrheitswerte (TRUE, FALSE) .

Eine komprimierte Fassung finden Sie in nachfolgender Tabelle:

Beschreibung	Beispiel	Datentyp
Ganze und reelle Zahlen	3.17	numeric
Zeichen und Zeichenketten	"Bild"	character
Wahrheitswerte	TRUE, FALSE	logical

Zwei Beispiele dürften Sie zurecht irritieren: Zum einen wird ein Punkt als Dezimaltrennzeichen verwendet, zum anderen ist das Wort Bild von Anführungszeichen umschlossen ("..."). Diese Fälle betrachten wir nun genauer. Zunächst geben Sie die Zahl 3,17 in üblicher Notation mit Komma als Dezimaltrennzeichen in die Konsole ein und führen die Zeile aus:

3,17
## Error: unexpected ',' in "3,

Sie merken: RStudio gibt statt eines ordnungsgemäßen Outputs eine (durchaus kryptische) Fehlermeldung (Error) zurück. Um diese zu verstehen, müssen Sie sich bewusst machen, dass die Verwendung des Kommas in R vorbelegt ist: Das Zeichen kann Objekte eines Vektors ebenso abtrennen wie Argumente einer Funktion (mehr dazu in den Abschnitten Datenstrukturen und Funktionen). Reelle Zahlen (Zahlen mit Nachkommastellen) benötigen daher in R einen Punkt statt eines Kommas als Dezimaltrennzeichen.

Sehen Sie sich nun das zweite Beispiele an, indem Sie Bild in die Konsole eingeben und die Zeile ausführen:

Bild
## Error in eval(expr, envir, enclos): Objekt 'Bild' nicht gefunden

Auch hier zeigt uns RStudio einen Error an, dieses Mal jedoch mit einer konkreteren weiterführenden Information: Objekt 'Bild' nicht gefunden. Die Erklärung ist simpel: Ohne Anführungszeichen erwartet R beim Ausführen der Zeile ein Objekt namens Bild, das im Workspace bereits existiert – von Ihnen also, wie im Abschnitt Objekte und Zuweisungen beschrieben, erzeugt wurde. Achten Sie daher immer darauf, einen Wert mit Anführungszeichen ("Bild" oder 'Bild') zu umschließen, wenn es sich bei ihm um Buchstaben oder eine Zeichenkette handelt und R diese als solche erkennen soll.

Den Datentyp eines Objekts können Sie infolge über zwei Funktionen bestimmen: mode und is.datentyp (also is.numeric, is.character oder is.logical). Der Unterschied: mode gibt den genauen Datentyp zurück – is.datentyp prüft lediglich, ob es sich um den von Ihnen spezifizierten Datentyp handelt und spuckt einen Wahrheitswert aus. Sehen Sie sich dazu beispielhaft folgenden Code an:

x <- 5
mode(x)
## [1] "numeric"

is.character(x)
## [1] FALSE

Laut mode ist das Objekt x vom Typ numeric. Eine Prüfung, ob es sich bei x um ein Objekt des Typs character handelt, resultiert folgerichtig in der Rückgabe FALSE. Aber Achtung:

x <- "5"
mode(x)
## [1] "character"

is.character(x)
## [1] TRUE

Sie weisen x im vorhergehenden Code durch die umschließenden Anführungszeichen nicht mehr die Zahl sondern das Zeichen 5 zu – arithmetische Operationen wie im Abschnitt Operatoren können mit diesem Objekt nicht mehr durchgeführt werden. Eine nachträgliche Änderung des Datentyps ist über die Funktion as.datentyp möglich:

x <- "5"
mode(x)
## [1] "character"

x <- as.numeric(x)
mode(x)
## [1] "numeric"

Das Objekt x enthält zunächst wie bislang das Zeichen 5, dessen Datentyp Sie über mode testen. Im Anschluss entscheiden Sie sich mit dem Aufruf as.numeric(x), den Typ in numeric umzuwandeln und das Ergebnis wieder in einem Objekt namens x abzulegen. Die erneute Eingabe von mode sagt Ihnen daraufhin: Der Datentyp des Objekts x ist numeric.

Die Umwandlung einer Zahl oder eines Zeichens in einen Wahrheitswert funktioniert hingegen nicht ohne Weiteres:

x <- "5" 
x <- as.logical(x) 
x
## [1] NA

Das Objekt x enthält nach der Änderung des Datentyps die Angabe NA – statt eine Umwandlung des Zeichens 5 in einen Wahrheitswert vorzunehmen, hinterlegt R im Objekt x die Konstante für einen fehlenden Wert, NA (Not Available). NA kann in jeden beliebigen Datentyp umgewandelt werden, ohne seine Form zu verlieren:

x <- NA
as.numeric(x)
## [1] NA

as.character(x)
## [1] NA

as.logical(x)
## [1] NA

Datenstrukturen

Ein Level über den Datentypen liegen die Datenstrukturen: ein- bis mehrdimensionale Beschreibungen über die (der Name verrät es bereits) Struktur der Daten. Sie nehmen also Ihre bisherigen einzelnen Objekte und bündeln sie – in Vektoren (vector), Matrizen (matrix), Dataframes (data.frame) oder Listen (list). Jede Struktur besitzt die grundlegende Eigenschaft length. In mindestens zweidimensionalen Strukturen kommen weitere Eigenschaften hinzu, die über die Funktion attributes ermittelt werden können. Die Unterschiede und Merkmale der Strukturen seien im Folgenden erläutert.

Vektoren

Die einfachste Datenstruktur in R, den Vektor, kennen Sie bereits, ohne es zu wissen. Denn alle Objekte, die nur einen Wert beinhalten, sind Vektoren der Länge 1. Stellen Sie sich einen Vektor jedoch nicht im schulmathematischen oder abstrakten Sinne vor, sondern beispielsweise als Stapel von Büchern, deren Titel Sie alphabetisch notieren. Die entstandene Liste würde bei Eingabe in R schließlich einen Vektor ergeben. Betrachten Sie zunächst allerdings noch einmal folgenden Output:

x <- "Bild"
x
## [1] "Bild"

Vor der Zeichenkette "Bild" steht die Zahl 1 in eckigen Klammern: Es handelt sich um die Position des Wertes "Bild" im Objekt x. Und dieses Objekt x ist hier ein Vektor. Eine Information über die Länge eines Objekts (also die Anzahl der in einem Objekt enthaltenen Elemente) erhalten Sie mit der Funktion length:

length(x)
## [1] 1

Nun gehen wir einen Schritt weiter und legen einen Vektor an, der mehr als ein Element enthält:

x <- c(2,3,5,7)
x
## [1] 2 3 5 7

length(x)
## [1] 4

Betrachten Sie die erste Zeile und insbesondere den Befehl c(2,3,5,7): Die Funktion c (kurz für combine oder concatenate) legt mehrere durch Kommata getrennte Werte (hier die Zahlen 2,3,5,7) als Vektor ab (hier in das Objekt x). Anschließend geben Sie den Inhalt von x aus. Es fällt auf: Die Markierung [1] wird für alle folgenden Werte nicht weitergeführt – sie steht ausschließlich am Anfang jeder Zeile des Outputs. Die Länge des Vektors wird daraufhin geprüft: x enthält (wenig überraschend) vier Elemente.

Wenn Sie den Wert eines bestimmten Elements in einem Vektor extrahieren möchten, übergeben Sie die Position des besagten Elements nach dem Namen des Vektors in eckigen Klammern (hier das Element mit Index 3):

x[3]
## [1] 5

Mehrere Elemente können ebenso angesprochen werden. Handelt es sich um in einem Vektor aufeinander folgende Werte, verknüpfen Sie Start- und Endindex mit einem Doppelpunkt (hier die Elemente mit Index 2 bis 4):

x[2:4]
## [1] 3 5 7

Handelt es sich hingegen um Elemente, die in einem Vektor nicht aufeinander folgen, müssen Sie dem Vektor einen weiteren Vektor mit den entsprechenden Indizes übergeben (hier die Elemente mit Index 2 und 4):

x[c(2,4)]
## [1] 3 7

Warum dies nur scheinbar umständlich möglich ist (und nicht beispielsweise über den Befehl x[2,4] abgedeckt wird), bemerken Sie in Kürze, wenn Sie zweidimensionale Strukturen kennenlernen. Die Selektion einzelner Elemente mag Ihnen übrigens trivial und in diesem Stadium unnütz erscheinen – je mehr Elemente ein Vektor (oder eine Datenstruktur allgemein) allerdings besitzt, umso schwerer wird es Ihnen fallen, ein für Sie relevantes Element im betreffenden Vektor zu finden.

Eine weitere und überaus relevante Eigenschaft dieser Datenstruktur: Ein Vektor kann nur Elemente desselben Datentyps aufnehmen. Probieren Sie folgendes:

x <- c("Bild", 3)
x
## [1] "Bild" "3"

Da R die Zeichenkette "Bild" schlecht zu einer Zahl umfunktionieren kann, wird der Datentyp der Zahl 3 geändert – in das Zeichen 3. Den Datentyp aller in einem Vektor enthaltenen Elemente erhalten Sie wie bislang über die Funktion mode:

mode(x)
## [1] "character"

Ein Vektor kann ferner vorne und hinten durch beliebig viele weitere Elemente ergänzt werden:

x <- c(2,3,5,7)
x
## [1] 2 3 5 7

x <- c("Bild", x, 3)
x
## [1] "Bild" "2" "3" "5" "7" "3"

Kurzum können wir daher sagen: Ein Vektor ist eine geordnete Sammlung von Objekten mit gleichem Datentyp.

An dieser Stelle ist auch die Einführung eines weiteren Datentyps sinnvoll: der des Faktors. Dieser Datentyp erleichtert die Arbeit mit qualitativen Merkmalen, die verschiedene Merkmalsausprägungen besitzen. Stellen Sie sich folgendes, stark vereinfachtes Beispiel vor: Ein Film kann exakt einem von drei Genres zugeordnet werden – Drama, Komödie, Thriller. In einem Vektor des Datentyps character, der Informationen über acht Filme enthält, sieht dies möglicherweise so aus:

x <- c("Komödie", "Komödie", "Drama", "Thriller", "Drama", "Komödie", "Drama", "Drama")

x
## [1] "Komödie" "Komödie" "Drama" "Thriller" "Drama" "Komödie" "Drama" "Drama"

Für weitere Analysen ist jene Ausgangssituation jedoch unpraktisch: R wird aus einem Vektor dieser Art nur beschwerlich eine simple Tabelle mit den absoluten Häufigkeiten pro Genre erstellen können; Ihre Merkmalsausprägungen werden nicht als solche erkannt – sie sind reiner Text ohne zusätzliche Eigenschaften. Überführen Sie den Datentyp des Vektors daher mit dem Befehl factor zu einem Faktor:

x <- factor(x)

x
## [1] Komödie Komödie Drama Thriller Drama Komödie Drama Drama
## Levels: Drama Komödie Thriller

Die erste Zeile des Outputs ist Ihnen bereits bekannt: Sie gibt die Inhalte des Vektors wieder. In der zweiten Zeile erhalten Sie hingegen eine neue Information: Ihr Vektor besitzt die drei Ausprägungen (Levels) Drama, Komödie und Thriller. Nützlich wird hier auch die Funktion str, welche die Struktur Ihres Vektors feinstufiger abbildet:

str(x)
## Factor w/ 3 levels "Drama","Komödie",..: 2 2 1 3 1 2 1 1

Dass Sie einen Vektor des Datentyps factor mit drei Ausprägungen erzeugt hatten, wussten Sie bereits. Der Output zeigt Ihnen allerdings auch, wie R mit diesen Ausprägungen umgeht: Sie werden zu Zahlen umkodiert (1,2,3), die einen Namen besitzen ("Drama","Komödie","Thriller"). Jene sogenannten kategorialen Variablen ermöglichen es Ihnen, R die von Ihnen vorgesehene Gruppierung zu übergeben. Insbesondere bei numerisch hinterlegten, qualitativen Ausprägungen besteht ansonsten die Gefahr, sie mit einer quantitativen Variable zu verwechseln. Machen Sie sich den Unterschied bewusst, indem Sie mit der Funktion mean das arithmetische Mittel eines Vektors vom Typ numeric und eines Vektors vom Typ factor berechnen:

x <- c(1,1,4,5,4)
mean(x)
## [1] 3

y <- factor(x)
mean(y)
## Warning in mean.default(y): argument is not numeric or logical: returning NA
## [1] NA

Für Vektoren vom Typ factor ist eine Berechnung des arithmetischen Mittels (ebenso wie viele weitere Berechnungen) nicht möglich – Abstände zwischen Faktoren sind nicht im üblichen numerischen Sinne interpretierbar. Ob es sich um einen Faktor handelt, können Sie wie bislang prüfen:

x <- c(1,1,4,5,4)
x <- factor(x)
is.factor(x)
## [1] TRUE

Die Ausprägungen können Sie ferner auch separat über den Befehl levels einsehen:

levels(x)
## [1] "1" "4" "5"

Und in diesem Zuge auch verändern:

levels(x) <- c(3,4,5)

x
## [1] 3 3 4 5 4
## Levels: 3 4 5

Entfernen Sie nun im Vektor x die Ausprägung 5 an Stelle 4:

x <- x[-4]

x
## [1] 3 3 4 4
## Levels: 3 4 5

Die Information über die Ausprägung 5 bleibt im Vektor also enthalten, obwohl in ihm keine Werte dieser Ausprägung mehr vorhanden sind. Möchten Sie die Ausprägung ebenso entfernen, übergeben Sie dem Vektor das Argument drop=TRUE:

x <- x[drop=TRUE]

x
## [1] 3 3 4 4
## Levels: 3 4

Matrizen

Gehen wir einen Schritt weiter: Statt eindimensionalen Vektoren widmen wir uns jetzt zweidimensionalen Matrizen. Zweidimensional heißt im anschaulichen Sinne nichts anderes als: Es wird eine Tabelle mit Zeilen (waagerecht) und Spalten (senkrecht) aufgespannt. In Code ausgedrückt bedeutet dies:

x <- matrix(data=5:10, nrow=3, ncol=2)
x

##      [,1] [,2]
## [1,]    5    8
## [2,]    6    9
## [3,]    7   10

Mit der Funktion matrix teilen Sie R mit, eine Matrix zu erstellen, die in diesem Fall mit den Werten 5 bis 10 (data=5:10) über drei Zeilen (nrow=3) und zwei Spalten (ncol=2) bestückt werden soll. Die Argumente der Funktion werden durch Kommata abgetrennt. Die Reihenfolge der Argumente spielt im Grunde keine Rolle, wenn Sie die entspechenden Argumente nicht abkürzen (also matrix(5:10, 3, 2) statt matrix(data=5:10, nrow=3, ncol=2) schreiben).

Der Output macht Ihnen auch deutlich: Die Daten, bestehend aus den Zahlen 5 bis 10, füllen die Matrix spaltenweise auf – zunächst wird die erste Spalte vervollständigt (im Output markiert durch [,1]), dann die zweite Spalte ([,2]). Diese Voreinstellung ändern Sie, indem Sie der Funktion matrix das Argument byrow=TRUE übergeben:

x <- matrix(data=5:10, nrow=3, ncol=2, byrow=TRUE)
x

##      [,1] [,2]
## [1,]    5    6
## [2,]    7    8
## [3,]    9   10

Eine Matrix hat zudem immer auch eine Dimension, welche über die Funktion dim ausgegeben werden kann:

dim(x)
## [1] 3 2

Die Dimension der Matrix x besteht aus der Anzahl der Zeilen an Position 1 (3) und der Anzahl der Spalten an Position 2 (2). Diese Angaben erhalten Sie zudem mit den Befehlen nrow und ncol separat:

nrow(x)
## [1] 3

ncol(x)
## [1] 2

Die Länge derselben Matrix bildet sich folglich aus der Multiplikation der Anzahl der Zeilen mit der Anzahl der Spalten:

length(x)
## [1] 6

Was passiert nun aber, wenn sich die Anzahl der Elemente, die in eine Matrix eingefügt werden sollen, von der Dimension der aufzuspannenden Matrix unterscheidet? Sehen Sie selbst:

matrix(data=5:11, nrow=3, ncol=2)

##      [,1] [,2]
## [1,]    5    8
## [2,]    6    9
## [3,]    7   10

## Warning in matrix(5:11, nrow = 3, ncol = 2): data length [7] is not a sub-multiple or multiple of the number of rows [3]

Im vorhergehenden Fall versuchen Sie, einen Vektor der Länge 7 (die Zahlen 5 bis 11) in einer Matrix der Länge 6 unterzubringen: R gibt eine Warnung zurück (Warning) und ignoriert das Element an Position 7 des Vektors (die Zahl 11), da 7 kein Vielfaches von 3 (der Anzahl der Zeilen) ist – es werden wie bislang nur die Werte 5 bis 10 an die Matrix übergeben.

Für den Fall, dass die Anzahl der einzufügenden Elemente die Länge der Matrix unterschreitet, ergibt sich folgendes Bild:

matrix(data=5:9, nrow=3, ncol=2)

##      [,1] [,2]
## [1,]    5    8
## [2,]    6    9
## [3,]    7    5

## Warning in matrix(5:9, nrow = 3, ncol = 2): data length [5] is not a sub-multiple or multiple of the number of rows [3]

Das erste Element des Vektors (die Zahl 5) wird in letzterem Beispiel recycelt – es tritt in Ermangelung eines weiteren Elements an Position 10 des Vektors. Damit ist das Resultat identisch zu folgendem Befehl:

matrix(data=c(5:9,5), nrow=3, ncol=2)

##      [,1] [,2]
## [1,]    5    8
## [2,]    6    9
## [3,]    7    5

Kommen wir zu der Selektion eines oder mehrerer Elemente in einer Matrix. Die Struktur lässt sich im zweidimensionalen Fall mit folgendem Schema beschreiben: matrix[zeile,spalte]. Das Element in der zweiten Zeile der ersten Spalte erhalten Sie daher mit dem Befehl:

x[2,1]
## [1] 7

Alle Regelungen für die Indexierung eines Elements in einem Vektor gelten analog auf Zeilen- und Spaltenebene in einer Matrix. Möchten Sie die Werte einer bestimmten Spalte extrahieren, müssen Sie keine Angabe über die benötigten Zeilen treffen:

x[,1]
## [1] 5 7 9

Der Befehl gibt Ihnen die erste Spalte der Matrix x zurück. Wenn Sie Interesse an den Werten der zweiten Zeile haben, gehen Sie wie folgt vor:

x[2,]
## [1] 7 8

Um den Umgang zu erleichtern, ist es zudem möglich, den Zeilen und Spalten Namen zuzuweisen. Entweder spezifizieren Sie diese zusätzlichen Informationen gleich bei Anlage der Matrix:

x <- matrix(data=5:10, nrow=3, ncol=2, dimnames=list(c("Zeile1", "Zeile2", "Zeile3"), c("Spalte1", "Spalte2")))
x

##        Spalte1 Spalte2
## Zeile1       5       8
## Zeile2       6       9
## Zeile3       7      10

Oder im Nachhinein mit der Funktion dimnames:

x <- matrix(data=5:10, nrow=3, ncol=2)
dimnames(x) <- list(c("Zeile1", "Zeile2", "Zeile3"), c("Spalte1", "Spalte2"))
x

##        Spalte1 Spalte2
## Zeile1       5       8
## Zeile2       6       9
## Zeile3       7      10

In beiden Fällen übergeben Sie dimnames eine Liste, die aus einem Vektor mit den Zeilennamen und einem Vektor mit den Spaltennamen besteht. Weiteres zum Thema Listen finden Sie am Ende dieses Abschnitts. Über die vergebenen Namen können Sie ebenso auf die Zeilen und Spalten zugreifen:

x["Zeile3",]
## Spalte1 Spalte2
##       7      10

x[,"Spalte2"]
## Zeile1 Zeile2 Zeile3
##      8      9     10

Natürlich können auf diese Weise auch mehrere Zeilen oder Spalten angesprochen werden, indem Sie die gewünschten Zeilen- oder Spaltennamen an einen Vektor übergeben:

x[c("Zeile2", "Zeile3"),]

##        Spalte1 Spalte2
## Zeile2       6       9
## Zeile3       7      10

Ebenso ist es über die Befehle rownames beziehungsweise colnames möglich, nur die Zeilen- beziehungsweise Spaltennamen abzufragen:

rownames(x)
## [1] "Zeile1" "Zeile2" "Zeile3"

colnames(x)
## [1] "Spalte1" "Spalte2"

Möchten Sie nun den Namen der zweiten Zeile ändern, übergeben Sie einfach den entsprechenden Index an den Vektor der Zeilennamen (rownames(x)) und weisen ihm den neuen Wert zu ("ZeileZwei"):

rownames(x)[2] <- "ZeileZwei"
rownames(x)
## [1] "Zeile1" "ZeileZwei" "Zeile3"

Wenn Sie eine weitere Spalte benötigen, die bei Erstellen der Matrix noch nicht berücksichtigt wurde, hilft Ihnen die Funktion cbind (column bind), an die Sie die bisherige Matrix und einen Vektor mit den Werten der neuen Spalte übergeben:

y <- cbind(x, c(15:17))
y

##           Spalte1 Spalte2
## Zeile1          5       8 15
## ZeileZwei       6       9 16
## Zeile3          7      10 17

Mit dem Befehl rbind (row bind) fügen Sie analog eine neue Zeile hinzu:

z <- rbind(y, c(11:13))
z

##           Spalte1 Spalte2
## Zeile1          5       8 15
## ZeileZwei       6       9 16
## Zeile3          7      10 17
##                11      12 13

In beiden Fällen fällt auf: Über rbind beziehungsweise cbind wird bei Anlage einer neuen Zeile beziehungsweise Spalte nicht automatisch ein entsprechender Zeilenbeziehungsweise Spaltenname generiert. Diesen müssen Sie manuell übergeben:

rownames(z)[4] <- "Zeile4"
rownames(z)
## [1] "Zeile1" "ZeileZwei" "Zeile3" "Zeile4"

colnames(z)[3] <- "Spalte3"
colnames(z)
## [1] "Spalte1" "Spalte2" "Spalte3"

z

##           Spalte1 Spalte2 Spalte3
## Zeile1          5       8      15
## ZeileZwei       6       9      16
## Zeile3          7      10      17
## Zeile4         11      12      13

Eine Matrix ist somit vergleichbar mit einem zweidimensionalen Vektor und nimmt wie dieser nur Objekte gleichen Datentyps auf.

Dataframes

Bei spaltenweise unterschiedlichen Datentypen empfiehlt sich im zweidimensionalen Fall die Verwendung eines Dataframes – eine Spalte kann dort beispielsweise Zahlen aufnehmen, eine andere Zeichenketten. Wie bisher gilt: Die einzelnen Spalten eines Dataframes weisen dieselbe Länge auf, fehlende Werte müssen explizit gekennzeichnet werden. Generieren wir nun einen Dataframe aus der Sequenz der Zahlen 5 bis 10 mit denselben Argumenten, die wir bei der ursprünglichen Beispielmatrix verwendet haben:

x <- data.frame(data=5:10, nrow=3, ncol=2)
x

##   data nrow ncol
## 1    5    3    2
## 2    6    3    2
## 3    7    3    2
## 4    8    3    2
## 5    9    3    2
## 6   10    3    2

Dataframes funktionieren offensichtlich anders als Matrizen: Jedes zusätzliche Argument der Funktion data.frame resultiert in einer neuen Spalte. Der Spaltenname wird aus der Angabe vor dem = extrahiert (beispielsweise data), die Daten wie bislang aus der Angabe nach dem = (beispielsweise 5:10). Wenn Sie also einen Dataframe ähnlich der vorhergehenden Matrix aufspannen möchten, übergeben Sie die Werte spaltenweise:

x <- data.frame(Spalte1=c(5:7), Spalte2=c(8:10))
x

##   Spalte1 Spalte2
## 1       5       8
## 2       6       9
## 3       7      10

Die Dimension eines Dataframes ist, bei gleicher Befüllung, identisch zu der Dimension einer Matrix:

dim(x)
## [1] 3 2

Passen Sie jedoch bei dem Befehl length auf:

length(x)
## [1] 2

Die Länge eines Dataframes ergibt sich nicht wie im Falle einer Matrix aus der Multiplikation der Anzahl der Zeilen und Spalten, sondern – möglicherweise ahnen Sie es bereits – nur aus der Anzahl der Spalten. Die Befehle nrow und ncol können jedoch wie bislang angewandt werden:

nrow(x)
## [1] 3

ncol(x)
## [1] 2

Ebenso ohne Unterschiede verhält sich das Prinzip des Recycling sowie die Befehle rownames und colnames (die Spaltennamen lesen wir ausnahmsweise nur aus und verändern sie nicht):

rownames(x) # Zeilennamen vorher
## [1] "1" "2" "3"

rownames(x) <- c("Zeile1", "Zeile2", "Zeile3")
rownames(x) # Zeilennamen nachher
## [1] "Zeile1" "Zeile2" "Zeile3"

colnames(x)
## [1] "Spalte1" "Spalte2"

x

##        Spalte1 Spalte2
## Zeile1       5       8
## Zeile2       6       9
## Zeile3       7      10

Zusätzlich zu der Ihnen bekannten Selektionsform für zweidimensionale Datenstrukturen (über object[zeile,spalte]) bietet ein Dataframe für Spalten auch die praktischere Selektion über den Dollar-Operator an:

x$Spalte2
## [1] 8 9 10

Dieselbe Methode funktioniert allerdings nicht auf Zeilenebene:

x$Zeile3 # Neue Variante
## NULL

x["Zeile3",] # Alte Variante
##        Spalte1 Spalte2
## Zeile3       7      10

Ein Element einer Spalte kann folglich wieder mit den entsprechenden Indizes extrahiert werden:

x$Spalte2[2]
## [1] 9

Beachten Sie jedoch, dass dieser Operator nicht für Matrizen zur Verfügung steht:

y <- matrix(c(5:7, 8:10), nrow = 3, ncol = 2)
colnames(y) <- c("Spalte1", "Spalte2")

y
##      Spalte1 Spalte2
## [1,]       5       8
## [2,]       6       9
## [3,]       7      10

y$Spalte1
## Error in y$Spalte1 : $ operator is invalid for atomic vectors

Warum in diesem Fall eine Fehlermeldung erscheint, teilt Ihnen die interne Hilfefunktion bei Aufruf des Befehls ?"$" mit: „$ is only valid for recursive objects [...].“ Handelt es sich bei unserer Matrix y um ein rekursives Objekt?

is.recursive(y)
## [1] FALSE

Wenn y kein rekursives Objekt ist und somit keine listenähnliche Struktur aufweist, müsste es stattdessen ein atomares Objekt sein:

is.atomic(y)
## [1] TRUE

Da eine Matrix, wie Sie am Anfang dieses Abschnitts bemerkt haben, auf Vektoren aufsetzt, ist der Dollar-Operator für diese in R nicht implementiert. Ein Dataframe hingegen bildet eine Sonderform der demnächst erläuterten Datenstruktur der Liste aus – und kann demzufolge den Dollar-Operator nutzen.

Spannen Sie nun einen Dataframe auf, der in einer Spalte Elemente des Typs character und in einer weiteren Spalte Elemente des Typs numeric enthält:

artist <- data.frame(Name = c("Peter Paul Rubens", "Ludwig Mies van der Rohe", "Adolph Menzel"), Geburtsjahr = c(1619, 1950, 1851))

artist
##                       Name Geburtsjahr
## 1        Peter Paul Rubens        1619
## 2 Ludwig Mies van der Rohe        1950
## 3            Adolph Menzel        1851

Fügen Sie jetzt einen weiteren Künstler hinzu:

artist[4,1] <- "William Poole"
## Warning in ‘[<-.factor‘(‘*tmp*‘, iseq, value = "William Poole"): invalid factor level, NA generated

Merkwürdig, oder? Prüfen Sie doch einmal den Datentyp der Spalte Name:

mode(artist$Name)
## [1] "numeric"

Der Befehl mode scheint uns nicht zu helfen – testen Sie daher, um welche Klasse es sich bei der Spalte handelt:

class(artist$Name)
## [1] "factor"

Da Faktoren in R keine atomaren Datentypen sind, sie sich also in numerische Werte weiter zerlegen lassen, ist zur Erkennung eines Faktors der Befehl class vonnöten. Warum aber verursacht die eigentlich simple Aktion, einen weiteren Künstler mit Name und Geburtsjahr hinzufügen zu wollen, solche Probleme? Die Antwort: Standardmäßig legt R Spalten eines Dataframes mit dem Datentyp factor an. Entweder Sie erstellen den Dataframe nochmals mit dem zusätzlichen Argument stringsAsFactors = FALSE und fügen im Anschluss den neuen Künstler hinzu:

artist <- data.frame(Name = c("Peter Paul Rubens", "Ludwig Mies van der Rohe", "Adolph Menzel"), Geburtsjahr = c(1577, 1886, 1815), stringsAsFactors = FALSE)

artist
##                       Name Geburtsjahr
## 1        Peter Paul Rubens        1577
## 2 Ludwig Mies van der Rohe        1886
## 3            Adolph Menzel        1815

artist[4,1] <- "William Poole"
artist[4,2] <- 1774

artist
##                       Name Geburtsjahr
## 1        Peter Paul Rubens        1577
## 2 Ludwig Mies van der Rohe        1886
## 3            Adolph Menzel        1815
## 4            William Poole        1774

Oder Sie wandeln stattdessen die Spalte Name in den Datentyp character um:

artist$Name <- as.character(artist$Name)
artist[4,1] <- "William Poole"
artist[4,2] <- 1774

artist
##                       Name Geburtsjahr
## 1        Peter Paul Rubens        1577
## 2 Ludwig Mies van der Rohe        1886
## 3            Adolph Menzel        1815
## 4            William Poole        1774

Mithilfe des Dollar-Operators können Sie im Übrigen auch eine neue Spalte erstellen, sofern der übergebene Spaltenname noch nicht vergeben wurde:

artist$Geschlecht <- "männlich"
artist

##                       Name Geburtsjahr Geschlecht
## 1        Peter Paul Rubens        1577   männlich
## 2 Ludwig Mies van der Rohe        1886   männlich
## 3            Adolph Menzel        1815   männlich
## 4            William Poole        1774   männlich

Widmen wir uns endlich fortgeschrittenen Analysemethoden – nämlich der Selektion von Teilmengen. Eine Möglichkeit ist die bereits ausgeführte Form der Indizierung:

artist[artist$Name == "Adolph Menzel",]

##            Name Geburtsjahr Geschlecht
## 3 Adolph Menzel        1815   männlich

Über artist$Name == "Adolph Menzel" stellen Sie fest, welche Zellen der Spalte Name im Dataframe artist exakt (==) den Inhalt "Adolph Menzel" aufweisen:

artist$Name == "Adolph Menzel"
## [1] FALSE FALSE TRUE FALSE

Das Prozedere ist daher folgendes: R nimmt zunächst den Künstlernamen an Position 1 des Vektors (Peter Paul Rubens) und gleicht ihn mit dem anschließend notierten Namen (Adolph Menzel) ab. Liegt eine Übereinstimmung vor, gibt R den Wahrheitswert TRUE zurück, liegt keine Übereinstimmung vor, den Wahrheitswert FALSE. Solange nicht geprüfte Elemente im Vektor artist$Name vorhanden sind, wird dieser Vorgang für jedes verbleibende Element wiederholt.

Laut Output kommt der gesuchte Name nicht (FALSE) in den Zellen 1, 2 und 4 vor. Zelle 3 jedoch liefert einen Treffer durch die Rückgabe TRUE zurück. Die genaue Position des mit Wahrheitswert TRUE hinterlegten Wertes erhalten Sie ebenso über den Befehl which, der Ihre bisherige Abfrage umschließt:

which(artist$Name == "Adolph Menzel")
## [1] 3

Demzufolge ist Ihre Selektionsabfrage nichts anderes als:

artist[3,]

##            Name Geburtsjahr Geschlecht
## 3 Adolph Menzel        1815   männlich

Wenn Sie nun jene Zeilen ausgeben möchten, welche die Künstler Adolph Menzel und Peter Paul Rubens enthalten, würden Sie annehmen, dass dies mit folgendem Befehl möglich ist:

artist[artist$Name == c("Peter Paul Rubens", "Adolph Menzel"),]

##                Name Geburtsjahr Geschlecht
## 1 Peter Paul Rubens        1577   männlich

Der Operator == wertet allerdings nur eine Übereinstimmung mit dem ersten Element des Vektors c("Peter Paul Rubens", "Adolph Menzel") aus. Daher müssen Sie einen anderen Operator einsetzen:

artist[artist$Name %in% c("Peter Paul Rubens", "Adolph Menzel"),]

##                Name Geburtsjahr Geschlecht
## 1 Peter Paul Rubens        1577   männlich
## 3     Adolph Menzel        1815   männlich

Jedes Element des Vektors artist$Name wird nun gegen die Menge c("Peter Paul Rubens", "Adolph Menzel") auf Übereinstimmung geprüft. Aber auch diese Methode hilft Ihnen nicht weiter, sofern Sie an einzelnen Zellbestandteilen interessiert sind. Dafür eignet sich jedoch die Funktion grepl:

artist[grepl("en", artist$Name),]

##                Name Geburtsjahr Geschlecht
## 1 Peter Paul Rubens        1577   männlich
## 3     Adolph Menzel        1815   männlich

Diese Funktion ist eine Allzweckwaffe, wenn es darum geht, Elemente jeglicher Form auf vorhandene Zeichenketten oder Muster zu überprüfen – es ist sogar möglich, sie mit regulären Ausdrücken zu bestücken . Im vorliegenden Fall suchen Sie nach der Zeichenfolge en im Vektor artist$Name und erhalten zwei Ergebnisse: die Künstler Peter Paul Rubens und Adolph Menzel.

Ein Dataframe ist somit vergleichbar mit einer Matrix. Im Gegensatz zu dieser nimmt er jedoch spaltenweise Objekte unterschiedlichen Datentyps auf und ist aus diesem Grund die für Datenanalysen am Häufigsten genutzte Datenstruktur.

Listen

Um aus unseren bislang maximal zweidimensionalen Strukturen auszubrechen oder unterschiedliche Strukturen effektiv verknüpfen zu können, bietet R eine weitere Struktur an: die Liste. Eine Liste ist im Grunde nichts anderes als ein Container, in dem sich andere Container befinden – beispielsweise Vektoren, Matrizen und Dataframes. Sie wird über den Befehl list initialisiert:

liste <- list()
liste
## list()

In diesem Zuge kann sie ebenso befüllt werden:

liste <- list(c("Buch", "Zeitschrift"), c(1:4), matrix(11:14, 2))
liste

## [[1]]
## [1] "Buch" "Zeitschrift"
##
## [[2]]
## [1] 1 2 3 4
##
## [[3]]
##      [,1] [,2]
## [1,]   11   13
## [2,]   12   14

Im Output sehen Sie, dass die Elemente der soeben kreierten Liste jeweils über doppelte eckige Klammern indiziert werden. Folglich können Sie über diese auch die Inhalte der Elemente extrahieren:

liste[[2]]
## [1] 1 2 3 4

Oder Sie benennen sie zunächst:

liste <- list(Element1 = c("Buch", "Zeitschrift"), Element2 = c(1:4), Element3 = matrix(11:14, 2))

liste
## $Element1
## [1] "Buch" "Zeitschrift"
##
## $Element2
## [1] 1 2 3 4
##
## $Element3
##      [,1] [,2]
## [1,]   11   13
## [2,]   12   14

Und nutzen infolge wie gehabt den Dollar-Operator:

liste$Element3
##      [,1] [,2]
## [1,]   11   13
## [2,]   12   14

Eine spezifische Spalte der Matrix Element3 selektieren Sie nun durch eine Kombination der bislang erlernten Befehle:

liste$Element3[,2]
## [1] 13 14

Fügen Sie der Liste doch auch noch einen Dataframe hinzu:

liste$Element4 <- data.frame(Kinostart = c("26.05.2016", "02.06.2016"), Titel = c("Der Nachtmahr", "The Nice Guys"))

liste
## $Element1
## [1] "Buch" "Zeitschrift"
##
## $Element2
## [1] 1 2 3 4
##
## $Element3
##      [,1] [,2]
## [1,]   11   13
## [2,]   12   14
##
## $Element4
##    Kinostart         Titel
## 1 26.05.2016 Der Nachtmahr
## 2 02.06.2016 The Nice Guys

Mit diesem testen Sie jetzt, ob eine Selektion über zwei nacheinander deklarierte Dollar-Operatoren funktioniert:

liste$Element4$Titel

## [1] Der Nachtmahr The Nice Guys
## Levels: Der Nachtmahr The Nice Guys

Mehrere Elemente einer Liste können auf bekanntem Wege durch Übergabe eines Vektors mit den entsprechenden Namen der Elemente angewählt werden:

liste[c("Element1", "Element2")]

## $Element1
## [1] "Buch" "Zeitschrift"
##
## $Element2
## [1] 1 2 3 4

Wie aber wählen Sie mehrere Elemente über deren Indizes aus?

liste[[1:2]]
## [1] "Zeitschrift"

Diese Variante funktioniert offensichtlich nicht. Die Ihnen bekannte Möglichkeit über einfache eckige Klammern aber schon:

liste[1:2]

## $Element1
## [1] "Buch" "Zeitschrift"
##
## $Element2
## [1] 1 2 3 4

Eine Liste ermöglicht es demnach, unterschiedliche Datenstrukturen und deren Elemente in einem Objekt zu verknüpfen und auf diese weiterhin zugreifen zu können.

Funktionen

Coming Soon.

Operatoren

Coming Soon.