R-Basics

2.1 Generierung von (Phantasie-)Variablen

In unserer Praxis mit R arbeiten wir meistens mit extern zur Verfügung gestellten Daten. Für ein paar einfache Demonstrationen wollen wir jedoch Beispieldaten selbst erstellen. Dies geht auf verschiedene Arten.

# Statistik 2: R Tutorat
# Übungsskript 1
# Datum: XX.XX.XXXX
# AutorIn: XXX

# Personennummer
1:5
pid <- 1:5
pid

Der Befehl 1:5 generiert eine einfache Zahlensequenz. Dieser Zahlenreihe können wir mit <- einen Namen geben und sie damit als Objekt bzw. Variable abspeichern. Hier nennen wir diese Variable pid. Im “Environment” von RStudio (Kachel oben rechts) sind gespeicherte Objekte protokolliert, hier erscheint daher nun auch die von uns generierte Variable.

c(1, 2, 3, 4, 5)
pid2 <- c(1, 2, 3, 4, 5)
pid2

Wir können eine identische Variable auch durch manuelle Belegung der einzelnen Wertepositionen generieren. Dazu stellen wir einer einfachen Aufreihung der Werte den Befehl c() voran.

# Kanton
c("ZH", "BE", "LU", "UR", "SZ")
kid <- c("ZH", "BE", "LU", "UR", "SZ")
kid

Auf dieselbe Weise können wir eine Sequenz von Zeichen erstellen und diese ebenfalls als Variable bzw. Objekt abspeichern. Wir nutzen diese Funktion hier, um eine Variable zum Wohnort zu erstellen.

seq (from = 1, to = 5, by = 1)
pid3 <- seq (from = 1, to = 5, by = 1)

Auch das Kommando seq() generiert automatisiert eine Zahlensequenz…

# Köpergrösse Eltern
vg <- seq(from = 176, to = 184, by = 2)
mg <- seq(from = 171, to = 175, by = 1)

Wir nutzen diese Funktion hier, um Variablen zur Körpergrösse von Eltern zu erstellen (vg = Vater / mg = Mutter).

Weitere Beispiele:

# Geburtsjahr und Befragungsjahr 
yrbrn <- 2001:2005
date <- 2022

# Monatliches Einkommen in CHF
minc <- seq(from = 4500, to = 9000, by = 1000)

2.2 Attribute von Variablen

Die Objekte bzw. Zahlen-/Zeichenreihen, die wir gerade erstellt haben, werden in R häufig auch als Vektoren bezeichnet. Für uns sind sie die zentralen Bausteine eines analysefähigen Datensatzes, wir betrachten und benennen sie daher immer als Variablen. In R gehören Variablen verschiedenen Variablenklassen an:

# Attribute der Variablen
class(pid)

## [1] "integer"

class(minc)

## [1] "numeric"

class(kid)

## [1] "character"

kid_f<-as.factor(kid)
class(kid_f)

## [1] "factor"

Mit dem Befehl class() können wir die Variablenklasse ermitteln: Die Variable pid besteht aus numerischen Werten und gehört somit zur Klasse integer. Die Variable minc enthält ebenfalls numerische Werte, gehört aber zur Klasse numeric. integer und numeric sind eng verwandte Variablenklassen, die beide metrische Variablen repräsentieren (genau genommen handelt es sich bei integers um eine Unterklasse der numerics). Die Unterschiede sind für unsere Praxis kaum relevant.

Die Variable kid gehört zur Klasse character, weil sie keine numerischen Werte, sondern Schriftzeichen enthält. Mit dem Befehl as.factor können wir sie in eine Variable der Klasse factor umwandeln. Sowohl factors als auch numerics repräsentieren kategoriale Variablen. Gleichwohl unterscheiden sich bestimmte Speicherattribute der beiden Klassen. In Folge sprechen factors und numerics etwas unterschiedlich auf verschiedene Befehle an und sind daher für bestimmte Operationen mehr oder weniger gut geeignet. Häufig können wir die Faktorklasse als eine Art Deluxe-Version des Characters auffassen, weshalb wir im Kontext multivariater Analysen oftmals entsprechende Transformationen des Variablentyps über …<-as.factor(…), wie oben, durchführen. Für detailliertere Ausführungen zu den Variablentypen siehe Statistik I Kapitel II. Datenintegration.

2.3 Rechnen mit Variablen

Variablen können über einfache Rechenbefehle weiterverarbeitet oder verändert werden. Beispielsweise zur Umwandlung bzw. zur Reskalierung:

# Monatliches Einkommen in Jahreseinkommen
minc * 12
yinc <- minc * 12
yinc

# Generierung einer Altersvariable
age <- date - yrbrn
age

# Generierung einer Variable zur Messung der durchschnittlichen elterliche Körpergrösse
pg <- (vg + mg)/2
pg

2.4 Verbindung von Variablen zu Datenmatrizen

Wir kommen zum wichtigsten Schritt dieser kleinen Versuchsreihe. Anhand des cbind()-Befehls können wir mehrere Vektoren bzw. Variablen zu einer Datamatrix verbinden. Die Variablen werden dabei automatisch Spalte für Spalte aneinandergereiht:

m <- cbind(pid, kid, vg, mg, pg, minc, yinc, date, yrbrn, age)
class(m)

## [1] "matrix" "array"

Durch cbind() wurden mehrere Vektoren aneinandergereiht, die so generierte Datenmatrix erscheint nun auch im Environment von RStudio.

Der Befehl class() zeigt den Typ der Datenmatrix an. Wiederum gilt, dass sich verschiedene Datenmatrix-Typen inhaltlich nicht voneinander unterscheiden, aber etwas unterschiedliche Analyseeigenschaften haben und daher für bestimmte Operationen mehr oder weniger gut geeignet sind. Das Objekt m wird von R im Moment als einfache Matrix interpretiert. Wir werden im Tutorat normalerweise mit Datenmatrixen arbeiten, die als Dataframe definiert sind. Wir können eine entsprechende Umwandlung leicht mithilfe von as.data.frame() vornehmen:

mdat <- as.data.frame(m)
class(mdat)

## [1] "data.frame"

View(mdat)

Erster Schritt bei jeder neu angelegten oder eingelesenen Datenmatrix: die visuelle Inspektion: die Person mit pid=1 wohnt im Kanton Zürich, verdient jährlich 54.000 CHF, ist im Jahr 2001 geboren um zum Befragungszeitpunkt (2022) somit 21 Jahre alt.

Aus der Anordnung von Variablen in der Datenmatrix ergibt sich eine erweiterte Befehls- bzw. Zuweisungslogik: Mithilfe des Dollarzeichens $ steuern wir Variablen innerhalb der Datenmatrix an und binden sie in Befehle wie oben ein. Das Dollarzeichen hilft also bei der befehlsbezogenen Navigation innerhalb des Datensatzes. Es besagt in etwa “Ich möchte etwas mit der Variable rechts von mir aus dem Datensatz links von mir anstellen”. Wir können uns so zum Beispiel die Variable minc aus der Datenmatrix mdat anzeigen lassen oder modifizieren:

mdat$minc

## [1] "4500" "5500" "6500" "7500" "8500"

class (mdat$minc)

## [1] "character"

mean (mdat$minc)

## Warning in mean.default(mdat$minc): Argument ist weder numerisch noch boolesch:
## gebe NA zurück

## [1] NA

# Notwendiger Zwischenschritt, nur falls Variable als Faktor angelegt wurde: mdat$minc<-as.character(mdat$minc)
mdat$minc<-as.numeric(mdat$minc)
class (mdat$minc)

## [1] "numeric"

mean (mdat$minc)

## [1] 6500

… da bei der Generierung der Datenmatrix erfolgte offenbar automatisch ein Vereinheitlichung der Variablenklasse. Je nach R-Version und Variablenreihung liegen nun alle Variablen entweder als factor oder character vor. Wir nehmen daher eine Re-Klassifizierungen insb. der metrischen Variablen vor. Achtung: Sollen bei der Umwandlung factor nach numeric die Werte einer Variable erhalten bleiben, muss oft zunächst die Transformation in einen character erfolgen.

2.5 Variablenmanagement in der Matrix

mdat$kid[mdat$kid == "ZH"] <- "BE"
mdat$kid

## [1] "BE" "BE" "LU" "UR" "SZ"

View(mdat)

Mit dem Zuweisungsoperator <- lassen sich Variablen nicht nur kreieren, sondern auch, was für unsere Praxis wichtiger ist, modifizieren. Oben wird die Ausprägung “ZH” der Variable kid in “BE” umgewandelt - Details zur hier praktizierten bedingten Zuweisungsoperation in R folgen in der nächsten Einheit.

Mit dem Dollar-Operator lassen sich neben Typ-Transformationen und bedingten Zuweisungen insbesondere auch algebraische Modifikationen auf einzelne Variablen innerhalb einer Datenmatrix beziehen.

• z.B. Monatliches Einkommen in Stundenlohn:

# Generiere Stundenlohn aus Monatslohn
mdat$hour_wage <- mdat$minc/160
mdat$hour_wage

## [1] 28.125 34.375 40.625 46.875 53.125

View(mdat)

• oder die Körpergrösse in cm in Körpergrösse in Zoll (Inches):

# Generiere Grösse in Zoll aus Grösse in Zentimetern
mdat$pg <- as.character(mdat$pg)
mdat$pg <- as.numeric(mdat$pg)
mdat$pgz <- mdat$pg/2.54
mdat$pgz

## [1] 68.30709 68.89764 69.48819 70.07874 70.66929

View(mdat)

• sowie die Körpergrösse von Zoll nach Fuss (Feet):

mdat$pgf <- mdat$pgz/12
mdat$pgf

## [1] 5.692257 5.741470 5.790682 5.839895 5.889108

View(mdat)

2.6 Verschachtelungen von Code

Bei der Programmierung in R beziehen sich oft mehrere Codezeilen auf dieselbe Variable (wie im Beispiel oben):

# Grösse in Zoll
mdat$pg <- as.character(mdat$pg)
mdat$pg <- as.numeric(mdat$pg)
mdat$pgi <- mdat$pg/2.54

Solche Befehlssequenzen können effizienter organisiert werden, indem Sie verschachtelt werden. Dieses ist möglich über die Einbindung in eine Klammerlogik:

# Grösse in Zoll: Alternative Codeorganisation "Klammer"
mdat$pgi <- as.numeric(as.character(mdat$pg))/2.54
mdat$pgi

## [1] 68.30709 68.89764 69.48819 70.07874 70.66929

Die Sequentialität der Befehle ist nun in einer Codezeile organisiert und ergibt sich durch Entschachtelung der Klammer von innen nach aussen: Die Ausgangsvariable wird 1. characterisiert, 2. numerisiert und schliesslich 3. algebraisch transformiert. Es ergibt sich dieselbe Zielvariable.

Auf ähnliche Weise ermöglicht ein R-spezifischer Verschachtelungsoperator, die sogenannte Pipe, die Organisation mehrere bezugsgleicher Befehle in einer Zeile:

# Grösse in Zoll: Alternative Codeorganisation "Pipe"
library (tidyverse)
mdat$pgi <- as.character(mdat$pg) %>% as.numeric %>% { . / 2.54 }
mdat$pgi

## [1] 68.30709 68.89764 69.48819 70.07874 70.66929

Das Pipe-Symbol %>% lässt sich als Übergabebefehl deuten: “Übergebe das Ergebnis der Operation links als Eingabeobjekt in den Befehl rechts”. Die charakterisierte Variable mdat$pg wird also zum Argument einer Numerisierung. Das Ergebnisobjekt dieser Numerisierung wird als nächstes zum Argument einer Division. Die Pipe %>% ist eine tidyverse-spezifische Operation und bedingt daher den entsprechenden Package-Aufruf.

Durch Verschachtelung einer Befehlssequenz per Klammer oder Pipe kann der Code an Kompaktheit und gegebenenfalls auch an Übersichtlichkeit gewinnen. Ob dies jedoch sinnvoll und praktikabel ist, hängt von persönlichen kognitiven Zugängen zum Coding und vom individuellen Abstraktionsvermögen ab. Denkst du eher linear oder verschachtelt? Willst du lieber jeden Schritt als Einzelschritt verbuchen oder lieber mehrere Etappen in einem Satz nehmen? Es bleibt dir überlassen: Alle drei Varianten (Codesequenz, Klammer, Pipe) sind ok, praktikabel und führen stets zum selben Ergebnis.

5.1 Visuelle Inspektion

View(ess8)

Der Befehl View() öffnet den Datensatz in einem separaten Fenster. Alternativ könnte im Environment der Datensatz direkt angeklickt werden. In einem ersten Schritt ist wichtig, einen Blick auf die Daten, mit denen man arbeiten will, zu werfen:

• Wurde die Matrix korrekt kodiert?
  • Befinden sich die Merkmale in den Spalten?
  • Befinden sich die Merkmalsträger in den Zeilen?
  • Befinden sich die Werte in den Zellen?
• Sind fehlende Werte als “NA” (not available) kodiert?
  • R erkennt fehlende Werte nur als solche, wenn sie als “NA” kodiert wurden.
  • Wenn Zellen leer sind, oder mit einem anderen Symbol belegt wurden, müssen diese als “NA” umkodiert werden.

5.2 Systematische Inspektion

# Anzahl Fälle und Variablen
dim(ess8)

## [1] 44387   534

Der Befehl dim() zeigt uns sowohl die Anzahl an Observationen, als auch die Anzahl an Variablen an, welche im Datensatz enthalten sind. Dieselbe Information steht im Environment neben dem Namen des Datensatzes; ess8 | 44387 obs. of 534 variables.

5.3 Variablensuche und Variableninspektion

install.packages("labelled")
library(labelled)
varlist <- look_for(ess8)
View(varlist)

Der Befehl look_for() aus dem labelled Package, welches wir vor der ersten Anwendung des Befehls noch installieren und aktivieren müssen, ermöglicht es uns eine Variablenliste zu generieren, die wir mit View() aufrufen und dann systematisch nach Variablennamen oder Schlagwörtern durchsuchen können. Tipp: Innerhalb des generierten Outputs könnt ihr dann frei Scrollen oder mithilfe von ctrl + f (bzw. dem Lupen-Icon-Feld) die Suchfunktion aktivieren. Die Informationen, die ihr Euch auf diese Weise verfügbar macht, entsprechen in etwa denen im Codebook auf der HP des ESS.

Eine weitere Option zur datensatzbezogenen Variablensuche bietet der Befehl contents() aus dem Hmisc-package:

library(Hmisc)
contents(ess8)

Wichtig: Wenn ihr eine Variable mit passenden Labels gefunden habt, untersucht auch deren grundlegenden Verteilungseigenschaften. Gelegentlich befinden sich Phantomvariablen in grossen Datensätzen, die kaum gültige Werte aufweisen oder lediglich als Systemvariable zur internen Weiterverarbeitung angelegt sind.

Mit der Funktion summary() werden die Übersichtsstatistiken aller im Datensatz enthaltenen Variablen angezeigt. Mit dem $-Argument lässt sich die Übersichtsstatistik auf eine einzelne Variable, in diesem Fall nwspol, begrenzen.

summary(ess8)

summary(ess8$nwspol)

##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max.    NA's 
##    0.00   30.00   60.00   85.43   90.00 1428.00     524

Alternativ wird der Mittelwert eines Merkmals mit der Funktion mean() und die Standardabweichung mit der Funktion sd() angezeigt.

sd(ess8$nwspol, na.rm=TRUE)
mean(ess8$nwspol, na.rm=TRUE)
class(ess8)
class(ess8$nwspol)

Vereinzelte Befehle (etwa der sd() oder mean() Befehl funktionieren - wenn NAs enthalten sind - nur unter der Anwendung des Zusatz na.rm=TRUE.

Bei kategorialen Variablen ist es sinnvoll, zur Variableninspektion die Häufigkeitsverteilung heranzuziehen und auf grundlegende Plausibilität zu prüfen:

table(ess8$prtvtfch)

## 
##   1   2   3   4   5   6   7   8   9  10  11  16  18  19  55 
## 148 131 141 118  65  43  25  13   4   2   3   8  46  13   1

table(as_factor(ess8$prtvtfch))

## 
##          Swiss People's Party       Social Democratic Party 
##                           148                           131 
##             FDP. The Liberals    Christian Democratic Party 
##                           141                           118 
##                   Green Party           Green Liberal Party 
##                            65                            43 
## Conservative Democratic Party    Evangelical People's Party 
##                            25                            13 
##      Federal Democratic Union                 Ticino League 
##                             4                             2 
##            Swiss Labour Party      Pirate Party Switzerland 
##                             3                             8 
##                   Other party                   Blank paper 
##                            46                            13 
##                      No party                Not applicable 
##                             1                           676 
##                       Refusal                    Don't know 
##                            18                            70 
##                     No answer 
##                             0

class(ess8)

## [1] "tbl_df"     "tbl"        "data.frame"

class(ess8$nwspol)

## [1] "haven_labelled" "vctrs_vctr"     "double"

Achtet dabei insbesondere auf plausible Fallzahlen. Hier wäre nun z.B. auf Basis des Codebooks des ESS zu klären, weshalb mehr als 1/3 der Fälle in dieser Variable einen fehlenden Wert aufweist.