Organisatorisches und R Basics

1. Einfache Rechenoperationen

R kann viel, darf aber auch als einfacher Rechner verwendet werden:

# Einfache Rechenoperationen
1+1
3*3
4/6
2<8
2>8
2=8
2==8
2!=2
2!=8
2>8 | 2<8
2>8 & 2<8
3*3==9
10^2
sqrt(81)

2. Wertelisten bzw. “Vektoren”

Einzelne Spalten oder Zeilen einer Datenmatrix können auch als “Wertelisten” verstanden werden. Wir erstellen nun einfache Wertelisten, um den Umgang mit Datenmatrixen vorzubereiten:

1:10
1,2,3,4,5,6,7,8,9,10  # Wo ist hier der Fehler?
c(1,2,3,4,5,6,7,8,9,10)
seq(from = 1, to = 10, by = 1)
seq(from = 1, to = 10, length = 19)

Der Befehl seq() erstellt eine Zahlensequenz. In der Klammer wird die Ober- und Untergrenze sowie die Grösse der Abstände zwischen den Zahlen festgelegt.

rep(x = 1, times = 10)

##  [1] 1 1 1 1 1 1 1 1 1 1

rep(x = c(1, 0) , times = 10)

##  [1] 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0

rep(x = c(1, 2, 3), times = 5)

##  [1] 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3

Mit rep() erstellen wir eine Wertefolge, bei der ein Wert beliebig oft wiederholt wird. Mit dem Argument “x=…” wird festgelegt, was wiederholt wird, während man über das Argument “times=” spezifiziert, wie oft die Wiederholung stattfindet.

Übrigens: Wenn du die Funktionsweise oder Grammatik eines Befehls nicht kennst, kannst du in der Konsole ein “?” vor den Befehl setzen: ?seq(). Dadurch wird die Dokumentation des Befehls gezeigt. Hier erfährst du, was der Befehl macht und welche Argumente du im Befehl spezifizieren kannst bzw. musst

3. Variablen

Eine zentrale Operation in R ist die Zuweisung “<-”. Das Objekt vor dem Pfeil kann man sich wie einen Behälter vorstellen, der durch die Anweisung hinter dem Pfeil definiert und gefüllt wird. Wertelisten können so beispielsweise unter dem Deckmantel eines Buchstabens abgespeichert werden (bzw. “als ein Objekt angelegt werden”).

v <- 1:10
x <- 1:20
w <- c("ZH", "BA", "LU", "ZH")
a <- seq(from = 1, to = 10, by = 1)
y <- seq(from = 11, to = 30, by = 2) 

Formal handelt es sich bei v, x, w, a und y um Wertelisten bzw. “Vektoren”. Werden solche Wertelisten durch Zuweisung als Objekt angelegt, bezeichnen wir sie zumeist aber als Variablen. Wichtig:

• Werte können sowohl numerisch als auch alphabetisch sein.
  
• Nicht-numerischen Werte müssen in Anführungszeichen gesetzt werden. Alles Alphabetische, was nicht nach einer Raute geschrieben oder in Anführungszeichen gesetzt wird, deutet R als Befehl.
  
• Der combine-Befehl c() bindet verschiedene Elemente bzw. Werte zusammen.

Wir haben nun fünf verschiedene Variablen erstellt:

v

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

x

##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20

w

## [1] "ZH" "BA" "LU" "ZH"

a

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

y

##  [1] 11 13 15 17 19 21 23 25 27 29

4. Attribute von Variablen

Mit dem Befehl class() bekommen wir genauere Angaben zu den Variablen:

class(x)

## [1] "integer"

class(y)

## [1] "numeric"

class(w)

## [1] "character"

x und y bestehen nur aus Zahlen und werden somit von R automatisch der Variablenklasse “numeric” (bzw. deren Unterklasse “integer”) zugeordnet, während es sich bei den Werten von w um Text handelt: w wird somit der Klasse “character” zugeordnet. Die Variablenklassen in R sind lose mit den Variablentypen gekoppelt, die ihr in der Vorlesung kennen gelernt habt. Die folgende Darstellung zeigt die typischen Korrespondenzen auf:

Mit unterschiedlichen Variablenklassen lassen sich manche Operationen jeweils besser oder schlechter durchführen. Daher ist es praktisch, dass wir Variablen mit den Befehlen as.factor(), as.character() und as.numeric() jeweils in einen anderen Variablentyp umwandeln können. Dabei stellt der Typ “factor” eine Art Deluxe-Version des “characters” dar, die sich in viele Befehle etwas besser einbinden lässt. Während der Variablentyp durch die Eigenschaften eines Merkmals definiert ist, gibt es es bei der R-spezifischen Zuweisung der Variablenklasse also gewisse Entscheidungsfreiheiten für Euch - die Zuordnung Variablentyp<->Variablenklasse ist also nicht fix.

Mit dem Befehl length() können wir nun herausfinden, wie viele Werte unsere Variable enthält. Der Befehl levels() ist ähnlich aufgebaut und gibt an, welche unterschiedlichen Werte unsere Variable enthält.

length(w)

## [1] 4

levels(w)

## NULL

Wir wissen nun, dass unsere Variable w vier Werte enthält. Beim levels()-Befehl haben wir zu w kein Ergebnis erhalten, da unsere Variable dem Typ “character” zugeordnet wird, der Befehl allerdings nur mit dem Typ “factor” umgesetzt wird (warum? unklar!) - ein Beispiel dafür, dass es manchmal tatsächlich sinnvoll ist, die Variablenklasse zu wechseln. Um den levels()-Befehl also ausführen zu können, wandeln wir unsere Variable mit dem as.factor()-Befehl in eine Faktorvariable um.

w_factor <- as.factor(w)
class(w_factor)

## [1] "factor"

levels(w_factor)

## [1] "BA" "LU" "ZH"

Die Variable w_factor ist nun vom Typ “factor”. Der levels()-Befehl gibt uns an, dass sich diese Faktorvariable aus den Werten “BA”, “LU” und “ZH” zusammensetzt.

Umwandlungen können übrigens auch in der Variable selber angelegt werden (ohne eine neue Variable zu bilden):

x <- as.factor(x)
class(x)

## [1] "factor"

5. Rechnen mit Variablen

In der Praxis kommt es oft vor, dass zwei Variablen miteinander verbunden oder kombiniert werden - zum Beispiel, wenn mehrere Einkommenskomponenten einer Person zusammengezählt werden sollen. Eine wichtige Eigenschaft von Wertelisten bzw. Variablen in R ist daher, dass wir sie miteinander verrechnen können:

v

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

y

##  [1] 11 13 15 17 19 21 23 25 27 29

v + y 

##  [1] 12 15 18 21 24 27 30 33 36 39

v * y 

##  [1]  11  26  45  68  95 126 161 200 243 290

Wie du siehst, werden bei diesen Berechnungen die Element der Werteliste der Reihe nach miteinander verrechnet.

Man kann auch überprüfen, ob die Elemente zweier Variablen identisch sind.

x <- "ZH"
z = "ZH"
w == "ZH"

## [1]  TRUE FALSE FALSE  TRUE

w == x

## [1]  TRUE FALSE FALSE  TRUE

w == y

## Warning in w == y: Länge des längeren Objektes
##       ist kein Vielfaches der Länge des kürzeren Objektes

##  [1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE

Die Variable x wurde zunächst überschrieben und enthält nun nur noch einen Wert (“ZH”). Im zweiten Schritt wurde geprüft, welche Werte der Variablenliste w diesem Wert entsprechen.

6. Verbindung von Variablen (Dataframes/Datamatrix)

Um mehrere Variablen zu einer Datenmatrix zu verbinden, benützen wir den Befehl data.frame():

df1 <- data.frame(a, y)
class(df1)

## [1] "data.frame"

df1

##     a  y
## 1   1 11
## 2   2 13
## 3   3 15
## 4   4 17
## 5   5 19
## 6   6 21
## 7   7 23
## 8   8 25
## 9   9 27
## 10 10 29

View(df1)

Wir haben nun eine typische Datenmatrix generiert: Die Variablen befinden sich in den Spalten, die Zeilen lassen sich als Fälle, bzw, Merkmalsträger oder Beobachtungen deuten.

7. Inspektion von Datenmatrixen

Es gibt mehrere Befehle, die der Inspektion einer Datenmatrix dienen. Einige davon sind:

dim(df1)

## [1] 10  2

head(df1)

##   a  y
## 1 1 11
## 2 2 13
## 3 3 15
## 4 4 17
## 5 5 19
## 6 6 21

tail(df1)

##     a  y
## 5   5 19
## 6   6 21
## 7   7 23
## 8   8 25
## 9   9 27
## 10 10 29

Der Befehl dim() gibt uns an, aus wie vielen Variablen und Fällen unser Dataframe besteht. In unserem Fall besteht unser Dataframe aus zwei Variablen und 10 Beobachtungen. Zudem können wir uns mit den Befehlen head() und tail() die ersten sechs resp. letzten sechs Fälle unseres Dataframes anzeigen lassen.

8. Ansteuern einzelner Variablen im Dataframe

Wir können Zuweisungen und Rechenoperationen auch auf einzelne Variablen einer Datenmatrix anwenden, müssen dazu aber sowohl die Matrix als auch die konkrete Variable innerhalb des Befehls kennzeichnen. Ähnlich wie das Backslash bei Pfadangaben in Windows fungiert das Dollarzeichen in der R-Sprache als Trennzeichen zwischen den beiden Kennzeichnungen: df1$y addressiert also die Variable y in der Datenmatrix df1.

class(df1$y)

## [1] "numeric"

df1$Summe <- df1$a + df1$y
df1$Summe

##  [1] 12 15 18 21 24 27 30 33 36 39

… anders formuliert: mit $ können wir spezifizieren, welche Variable in unserer Datenmatrix im Befehl angesteuert werden soll. So können wir beispielsweise eine neue Variable Summe in unsere Datenmatrix integrieren, welche sich aus der Addition der Werte von a und y zusammensetzt.