R Intro
RStudio ist eine konstenlose und sehr komfortable Oberfläche zur Nutzung von R. Das Programm bietet verschiedene Vorteile im Vergleich mit der herkömmlichen R Oberfläche, welche sich beim Arbeiten mit R bemerkbar machen und von denen wir einige im Rahmen dieser Einführung kennen lernen werden. Nachdem im Folgenden kurz die Oberfläche von RStudio erläutert wird, steigen wir direkt in die Arbeit mit R ein.
 |
 |
Wie wir an den beiden oberen Screenshots sehen, ist die Oberfläche von RStudio beim Start in drei oder vier Fenster unterteilt (je nachdem, ob bereits ein Skript geöffnet ist oder nicht):
Die Konsole bietet eine direkte Schnittstelle zum eigentlichen R Kern, welcher die Berechnungen bzw. den R Code ausführt. Die hier eingegebenen Befehle werden direkt von R bearbeitet und mit Ausnahme von Grafiken erfolgt die Ausgabe standardmäßig in diesem Fenster. Wir werden zu Beginn direkt in der Konsole arbeiten. Anweisungen, die man in die Konsole eingibt, bestätigt man mit Enter. Der Rückgabewert der Anweisung (z.B. das Ergebnis einer Berechnung) erscheint dann direkt unter der eigenen Eingabe.
Dieser Bereich ist einer der besonderen Vorteile an der RStudio Oberfläche. Der Bereich ist in sich noch einmal mit zwei Reitern unterteilt. Der erste Reiter Environment zeigt dem Benutzer alle momentan geladenen Objekte und deren Namen an. Dazu gehören Variablen, Funktionen und Datensätze, mit denen wir arbeiten wollen. Durch diese Übersicht muss man sich nicht alle Namen merken oder umständlich in den eigenen Anweisungen suchen. Eine vergleichbare Übersicht bietet die normale R Oberfläche nicht.
Der zweite Reiter History enthält den Verlauf der aktuellen R Session, d.h. alle bisher an den R Kern übermittelten Anweisungen und Eingaben. So können Benutzer ihre eigenen Schritte zurückverfolgen, um z.B. Fehler zu suchen.
Im unteren rechten Teil des RStudio Fensters wird der Hilfsbereich angezeigt. Dieser Bereich ist unterteilt in fünf verschiedene Reiter:
- Files: Hier wird das aktuelle Arbeitsverzeichnis angezeigt. Es lassen sich Dateien auf der Festplatte suchen und laden
- Plots: Hier werden von R erstellte Grafiken angezeigt, wenn Benutzer solche anfordern
- Packages: Hier werden die momentan geladenen Hilfspakete angezeigt (Erläuterung folgt später)
- Help: Hier werden die R Hilfedateien angezeigt, z.B. wenn Benutzer die Hilfe zu einem Befehl anfordern
- Viewer: Im Viewer können lokale HTML-Dateien angezeigt werden, die man mit R erstellen kann
Für Einsteiger ist im Hilfsbereich zunächst einmal nur der Reiter Hilfe interessant. Die anderen Bestandteile dieses Fensters werden erst bei weitergehender Nutzung von R und RStudio relevant.
Der Skriptbereich oben links ist der eigentliche Arbeitsbereich von RStudio. Hier können verschiedene Arten von Skripten geladen und ausgeführt werden. Wenn mehrere Dateien parallel geöffnet sind, sieht man die Dateinamen in den Reitern im oberen Bereich dieses Fensters und kann zwischen den Dateien hin- und herwechseln.
Die einfachste Art R zu benutzen ist die direkte Eingabe von Befehlen in die Konsole:
Nach der Eingabe der Anweisung wird diese durch Drücken von Enter direkt ausgeführt und die Rückgabe erscheint unmittelbar. Es gibt keine Einschränkungen bei der direkten Konsoleneingabe, allerdings wird schnell klar, dass sich kompliziertere Berechnungen und Datenauswertungsprozeduren nur sehr umständlich direkt über die Konsole durchführen lassen. Die direkte Arbeit in der Konsole ist daher nur in wenigen Fällen sinnvoll, z.B. für kurze Abfragen und den Aufruf einzelner Hilfedateien.
Benutzer, die Daten mit R auswerten wollen, erstellen im Normalfall eine Skriptdatei, welche alle zur Auswertung notwendigen Anweisungen in der richtigen Reihenfolge enthalten. R Skripte lassen sich genau so an den R Kern übermitteln wie direkte Eingaben in die Konsole. Die Rückmeldungen und Ergebnisse von ausgeführten R Skripten werden daher im Normalfall auch in der Konsole angezeigt.
Der große Vorteil von R Skripten ist natürlich, dass wir hier alle Anweisungen in einer übersichtlichen Form angezeigt bekommen und unseren Auswertungsprozess komplett dokumentieren. Anhand eines R Skripts lässt sich jeder Schritt der Datenauswertung leicht nachvollziehen und außerdem lassen sich Fehler einfach korrigieren, ohne dass alle Befehle danach einzeln neu ausgeführt werden. Im Idealfall werden R Skripte so geschrieben, dass sich eine komplette Auswertung mit einem einzelnen Klick reproduzieren lässt.
Eine neue Skriptdatei können wir über das File Menü erstellen:
Die neue Datei erscheint im Skriptbereich oben links und erhält einen eigenen Reiter. Sobald die Datei zum ersten Mal gespeichert wurde, wird auch der Dateiname im Reiter angezeigt.
Sobald man einige Anweisungen in ein Skript geschrieben hat, lassen sich einzelne Zeilen oder das gesamt Skript über die Buttons oben rechts im Skriptbereich ausführen:
Wie man sieht lassen sich entweder einzelne Zeilen oder ein markierter Bereich ausführen. Anstelle des Buttons kann auch die Tastenkombination Strg+Enter genutzt werden. Ein ganzes Skript lässe sich ausführen, in dem man zunächst Strg+A drückt, um den gesamten Skriptinhalt zu markieren und dann erst Strg+Enter zur Ausführung dieser Markierung.
Ein zentraler Bestandteil jedes R Skripts sind Kommentare, die Benutzer an beliebigen Stellen einfügen können, um den eigenen Code zu erläutern. In einer Skriptdatei werden Kommentare immer durch # eingeleitet. Alle Zeichen, die in derselben Zeile nach dem # folgen, werden von R als Kommentar erkannt und folglich nicht an den R Kern zur Auswertung weitergeleitet.
Die Kommentierung eigener Skripte ist extrem wichtig, um diese zu einem späteren Zeitpunkt wieder leicht zu verstehen und um Struktur in den Auswertungscode zu bringen:
1+1+1 # Dies ist ein Kommentar
# Hier folgt ein neuer Abschnitt der Auswertung
2*50-30 # Noch ein Kommentar
# Mehrzeilige Kommentare müssen
# in jeder Zeile mit einem neuen
# '#' beginnen!Bei R handelt es sich um eine Programmiersprache, die zwar speziell für mathematische Anwendungen konzipiert ist, aber dennoch eine große Menge an Anwendungsmöglichkeiten und Flexibilität bietet. Wie in anderen Programmiersprachen auch arbeiten wir in R mit verschiedenen Arten von Variablen, die wir auch Objekte nennen. Dazu gehören einzelne gespeicherte Werte, ganze Datensätze, oder sogar Funktionen und ganze Skripte.
Zum Einstieg interessieren uns nur ein paar Grundarten von Variablen, die wir in den meisten Datensätzen antreffen und mit denen wir häufig arbeiten:
Numerische Variablen sind einfache Zahlen, mit denen sich arithmetische Operationen durchführen lassen:
20 * 30 # Hier haben wir zwei Zahlen, die farbig hervorgehoben werden.Wichtig ist, dass das Dezimaltrennzeichen bei R immer ein . ist und kein ,! Das Komma hat in R eine andere Funktion (Trennzeichen in Listenelementen).
Strings sind Zeichenketten, die von ' oder " begrenzt werden:
'Test eines Strings' # Strings werden ebenfalls farbig hervorgehobenMit Zeichenketten lassen sich nicht ohne weiteres arithmetische Operatrionen durchführen, sie sind trotzdem häufig in Datensätzen enthalten und werden vielseitig in R verwendet.
Viele Berechnungen und Überprüfungen in R liefern als Ergebnis einen Boolwert zurück, d.h. sie sind entweder wahr oder falsch. Hier ein simples Beispiel:
1 == 1 # Wir benutzen einen Vergleichsoperator, um zu testen, ob 1 gleich 1 ist.## [1] TRUE
Im oberen Beispiel gibt R ein TRUE zurück. Im folgenden Beispiel gibt R dagegen FALSE zurück:
1 == 2 # Wir benutzen einen Vergleichsoperator, um zu testen, ob 1 gleich 2 ist.## [1] FALSE
Wenn man mit Boolvariablen arbeitet ist es sehr wichtig, dass man daran denkt TRUE und FALSE komplett groß zu schreiben oder mit T und F abzukürzen. Falsche Schreibweisen werden von R nicht erkannt und es kommt zu Fehlermeldungen.
Bislang haben wir Nummern, Strings und Boolvariablen direkt benutzt. Diese und andere R Objekte, z.B. Datensätze, können wir auch unter beliebigen Namen abspeichern, so dass sie für eine spätere Verwendung zur Verfügung stehen. Im folgenden Screenshot benutzen wir das Zuweisungszeichen <-, um die numerische Zahl 100 unter dem Namen test abzuspeichern:
Die Variable, welche uns nun permanent zur Verfügung steht, taucht bei Ausführung der Anweisung direkt in der Speicheranzeige (oben rechts) von RStudio auf. Wir haben nun erfolgreich die Variable test erstellt, bei der es sich um eine Zahl mit dem Wert 100 handelt.
ACHTUNG: Anstelle von <- (eckige Klammer auf und ein Bindestrich direkt dahinter) kann man auch einfach ein Gleichheitszeichen (=) benutzen.
Wenn wir nun mit unserer neu erstellten Variable arbeiten wollen, können wir diese durch Eingabe des Namens direkt aufrufen:
test## [1] 100
Wir können nun auch Berechnungen mit der Variable durchführen:
test*5## [1] 500
Neben den einfachen Variablen gibt es natürlich wesentlich komplexere Objekte in R, mit denen wir uns vertraut machen müssen, um später mit größeren Datensätzen arbeiten zu können. Ein wichtiges R Objekt sind Vektoren, die gleich mehrere Werte enthalten können. In anderen Programmiersprachen werden diese häufig als Arrays oder Listen bezeichnet. Vektoren können beliebig viele Variablen enthalten, allerdings müssen diese Variablen alle vom gleichen Variablentyp sein. Wir können also Vektoren von Zahlen oder Strings oder Boolwerten erstellen, aber wenn wir die Variablenarten innerhalb eines Vektors mischen, werden diese im Normalfall alle zu Strings umgewandelt, mit denen sich später nicht rechnen lässt:
string_vektor <- c('Text1', 'String2', 'Beispiel3', 'Beliebiger Text von beliebiger Länge 4')
nummern_vektor <- c(120, 134, 56.5, 82, 13, 37.456)
bool_vektor <- c(T,T,T,F,F,T)# T steht für TRUE und F für FALSE
gemischter_vektor <- c(T,F,123,145,'Text') # Das hier wird alles in Strings umgewandelt
### Ausgabe der Vektoren
string_vektor## [1] "Text1"
## [2] "String2"
## [3] "Beispiel3"
## [4] "Beliebiger Text von beliebiger Länge 4"
nummern_vektor## [1] 120.00 134.00 56.50 82.00 13.00 37.46
bool_vektor## [1] TRUE TRUE TRUE FALSE FALSE TRUE
gemischter_vektor## [1] "TRUE" "FALSE" "123" "145" "Text"
Bei der Ausgabe des gemischten Vektors erkennen wir an den ", dass es sich bei allen Werten um Strings handelt.
Wie man schon an den obigen Beispielen erkennen kann, wird ein Vektor in R einfach erstellt, in dem die beinhalteten Elemente in Runde Klammern geschrieben und durch Kommata getrennt werden. Außerdem muss vor der öffnenden Klammer ein c stehen (immer klein geschrieben!):
test_vektor <- c(1,2,3,4)Wir können uns einzelne Variablen in einem Datensatz als Vektoren von Werten vorstellen. Man könnte sich natürlich auch Versuchspersonen als einzelne Vektoren vorstellen, allerdings ist das in R ungünstig, da ja ein Vektor nicht unterschiedliche Variablenarten enthalten darf, aber ein einzelner VP-Datensatz mit sehr großer Wahrscheinlichkeit mehrere unterschiedliche Variablenarten enthält. Im Gegensatz dazu ist die Vorstellung, dass eine Variable, z.B. das Geschlecht, einem Vektor entspricht, der alle Versuchspersonenwerte beinhaltet, ohne Probleme mit den Vektorkonventionen von R vereinbar.
Im Folgenden wollen wir nun ein paar Vektoren erstellen, mit denen wir erste Berechnungen durchführen können:
Wir erstellen einen numerischen Vektor, der das Alter von 10 Versuchspersonen enthält, welche wir in der Folge näher betrachten wollen:
alter <- c(20,34,24,28,28,22,20,20,34,20)Unsere Versuchspersonen haben auch eigene VP-Nummern erhalten. Diese haben praktischerweise Werte von 1 bis 10. Eine solche Sequenz lässt sich in R sehr einfach durch Verwendung von : erzeugen:
vp_nummer <- c(1,2,3,4,5,6,7,8,9,10) # Die herkömmliche Methode
vp_nummer <- c(1:10) # Erzeugen einer einfachen Sequenz von 1 bis 10Wir stellen uns nun vor, dass das Geschlecht unserer Versuchspersonen als ein Vektor von Strings vorliegt. Männer erhalten dabei den Wert 'male' und Frauen 'female':
geschlecht <- c('male','female','male','female','female','female','female','male','male','male')Für unsere weiteren Beispiele und Aufgaben nehmen wir an, dass unsere Teilnehmer einen Intelligenztest bearbeitet haben, der in zwei Subskalen unterteilt ist. Einmal haben wir einen IQ-Wert für fluide und einmal für kristalline Intelligenz erhoben. Die Testwerte schreiben wir nun in zwei numerische Vektoren, jeweils einen für jede Subskala:
iq_fluid <- c(107,113,118,99,99,90,105,96,119,116)
iq_kristallin <- c(104,114,106,94,93,63,94,91,124,106)Im Folgenden wollen wir nun beginnen, verschiedene einfache Berechnungen durchzuführen, die uns häufig genutzte Kennwerte zu unseren Variablen liefern.
Viele mathematische Anwendungen (z.B. statistische Auswertungsverfahren) sind in R innerhalb von Funktionen implementiert. Das bedeutet, dass wir z.B. einen t-Test nicht von Hand einprogrammieren müssen, sondern dies bereits für uns gemacht worden ist. Funktionen sind im Prinzip nichts anderes als kleine Skripte mit vorgefertigtem Code, die ganz bestimmten Zwecken dienen. Wie andere R Objekte (z.B. Variablen) haben Funktionen immer einen Namen, über den sie erreicht werden können. Funktionen ruft man auf, in dem man ihren Namen eingibt und (in den allermeisten Fällen) runde Klammern folgen lässt. Innerhalb dieser runden Klammern übergibt man sogenannte Argumente (oder Parameter):
funktion_x(parameter1='test', parameter2=100) # Ein klassischer FunktionsaufrufDie meisten Funktionen, die in R bereit gestellt sind und die uns interessieren, benötigen spezifische Anweisungen dazu, wie sie bei ihrer Ausführung funktionieren sollen. Dazu gehört mindestens, auf welche Daten eine mathematische Operation angwendet werden muss. Eine Funktion, die uns den Mittelwert einer Menge von numerischen Variablen zurückliefert, muss natürlich wissen, welche numerischen Variablen gemittelt werden sollen:
mean(c(1,2,3,4)) # Wir benutzen die Mittelwertsfunktion mean() und übergeben einen Vektor mit 4 Zahlen## [1] 2.5
Darüber hinaus gibt es in der Regel noch eine Menge weiterer Argumente, die man nutzen kann, um das Verhalten von Funktionen zu steuern. Eine (nicht immer vollständige) Liste dieser Argumente erhält man durch den Aufruf der Hilfedatei für eine spezifische Funktion. Die Hilfedatei lässt sich über den Operator ? oder die Funktion help() öffnen, wie man in den folgenden Beispielen sehen kann. Für eine Volltextsuche innerhalb der Hilfedateien kann die Funktion help.search() genutzt werden:
?mean # Ruft die Hilfedatei für die Funktion mean() auf
help(mean) # Ruft auch die Hilfedatei für die Funktion mean() auf
help.search('mean') # Volltextsuche nach mean innerhalb aller HilfedateienDie Hilfedatei wird im Reiter Help des Hilfsbereichs unten rechts in RStudio angezeigt, nachdem man den Befehl ausführt.
Die Funktion mean() gibt uns den Mittelwert einer Menge von Zahlen, z.B. in einem Vektor, zurück. Hier noch einmal das obige Beispiel zur Verwendung von mean():
mean(c(1,2,3,4))## [1] 2.5
test_vektor = c(1,2,3,4)
mean(test_vektor) # Aufruf über eine Variable## [1] 2.5
Die Funktion median() gibt uns den Median einer Menge von Zahlen zurück:
median(c(1,2,3,4,5))## [1] 3
Die Funktion var() gibt uns die Varianz einer Menge von Zahlen zurück:
var(c(1,2,3,4))## [1] 1.667
Die Funktion sd() gibt uns die Standardabweichung einer Menge von Zahlen zurück:
sd(c(1,2,3,4))## [1] 1.291
Die Funktion sum() gibt uns die Summe einer Menge von Zahlen zurück:
sum(c(1,2,3,4))## [1] 10
Die Funktion sum() kann auch dafür genutzt werden, in einem Vektor von Boolwerten die Häufigkeit von TRUE auszuzählen:
sum(c(T,F,T,F))## [1] 2
Bislang haben wir uns die Rückgabewerte der ausgeführten Funktionen lediglich in der Konsole anzeigen lassen. Die meisten Funktionen erlauben es uns aber auch, die Rückgabewerte als eigene Variablen zu speichern:
standardabweichung <- sd(c(1,2,3,4))Mit den gespeicherten Werten lassen sich wiederum Berechnungen anstellen:
standardabweichung^2## [1] 1.667
Es kommt auch durchaus vor, dass wir als Rückgabewert nicht eine einzelne Variable, sondern komplexere Objekte wie Vektoren erhalten:
v1 <- c(1,2,3,4)
v2 <- c(1,2,3,4)
colMeans(cbind(v1,v2)) # Die Funktion colMeans() gibt uns die Mittelwerte unserer Zusammengefassten Vektoren als Vektor zurück## v1 v2
## 2.5 2.5
Die Funktionen colMeans() und cbind() werden an anderer Stelle erläutert. Wichtig ist erstmal nur, dass eine Funktion durchaus auch andere Dinge zurückgeben kann als einfache Nummern oder Boolwerte.
Nachdem wir nun wissen, wie wir Funktionen aufrufen können, die für uns bestimmte Operationen mit Daten durchführen, müssen wir uns tiefergehend mit der Auswahl unserer Daten befassen. Bislang haben wir einfach komplette Vektoren an Funktionen übergeben. Aber was ist, wenn wir nur Teile von Vektoren übergeben wollen?
Die Auswahl der relevanten Daten (Versuchspersonen, Variablen, etc.) in Datensätzen ist einer der zentralsten Vorgänge in der Arbeit mit R und die Fähigkeit hierzu entscheided darüber, wie schnell und einfach man mit seinen Daten in R arbeiten kann. Im folgenden Stellen wir daher einige zentrale Auswahlmechanismen vor.
Einzelne Werte oder Wertebereiche innerhalb von Vektoren lassen sich in R mit Hilfe von [ ] auswählen. Dabei hängt man die eckigen Klammern direkt hinter den Vektornamen:
vektor <- c(1,2,3,4,5,6,7,8,9,10)
vektor[1] # Auswahl des ersten Vektorelements## [1] 1
vektor[1:5] # Auswahl der ersten 5 Vektorelemente## [1] 1 2 3 4 5
vektor[c(1,4,7,9)] # Auswahl einer Menge von Vektorelementen mit Hilfe eines weiteren Vektors## [1] 1 4 7 9
Durch die Angabe von Zahlen oder Sequenzen mit Hilfe des : lassen sich wie man sieht einzelne Elemente oder Teilmengen von Vektorelementen auswählen. Durch die Übergabe einer Liste in den eckigen Klammern, lassen sich gezielt mehrere einzelne Elemente auswählen.
Häufig sind unsere Datensätze leider nicht so sortiert, dass wir einfach bestimmte Wertebereiche auswählen können, um eine relevante Teilmenge von Datensätzen auszuwählen (z.B. alle Frauen oder alle Männer in einem Datensatz). Bei langen Vektoren ist die gezielte Auswahl und Nennung der einzelnen Elemente in einem Vektor viel zu aufwendig. Um komfortabel auf relevante Daten zuzugreifen verwendet man daher das logical indexing, d.h. die Datenauswahl anhand logischer Vergleichsoperationen.
Wir haben bereits == als Vergleichsoperator ist gleich kennen gelernt. Es gibt darüber hinaus natürlich weitere Vergleichsoperatoren:
- == Ist gleich
- != Ist nicht gleich
- < Kleiner als
- <= Kleiner oder gleich
- > Größer als
- >= Größer oder gleich
Mit Hilfe dieser Operatoren lassen sich nun Daten hinsichtlich vordefinierter Kriterien auswählen:
vektor <- c(1,2,3,4,5,6,7,8,9,10)
vektor[vektor > 5] # Alle Vektoreinträge, die größer als 5 sind## [1] 6 7 8 9 10
vektor[vektor == 3] # Die Vektoreinträge, die genau 3 betragen## [1] 3
vektor[vektor <= 2] # Alle Vektoreinträge keliner gleich 2## [1] 1 2
vektor[vektor > mean(vektor)] # Funktionsaufruf beim logical indexing## [1] 6 7 8 9 10
Durch logical indexing lassen sich also relevante Einträge in Vektoren identifizieren.
R bietet die Möglichkeit, mehrere logische Vergleiche durch Verknüpfungen miteinander zu verbinden. Wir können hierfür & (und) sowie | (oder) verwenden:
vektor[vektor > 5 & vektor < 8] # Alle Vektoreinträge, die größer als 5 und kleiner als 8 sind## [1] 6 7
vektor[vektor < 5 | vektor > 8] # Alle Vektoreinträge, die kleiner als 5 oder größer als 8 sind## [1] 1 2 3 4 9 10
Die Folgenden Aufgaben sollen dabei helfen, den Umgang mit logical indexing in der Variablenauswahl zu üben:
A1) Greife auf das 3. Element des zuvor erstellten Altersvektors zu.
A2) Lasse dir das Geschlecht der 4 letzten Versuchspersonen anzeigen.
A3) Lasse dir die IQ-Werte für fluide Intelligenz der jüngeren Hälfte von Probanden anzeigen.
A4) Lasse dir die IQ-Werte für kristalline Intelligenz aller Männer anzeigen.
Die Lösungen sind auf folgender Seite zu finden:
Wir können Rechenoperationen auf ganze Vektoren anwenden und müssen nicht jedes Vektorelement einzeln bearbeiten. So lassen sich einfache wie auch komplexe Bearbeitung mit relativ einfachen Befehlen ausführen. Folgende Beispiele zeigen, wie wir mit Vektoren rechnen und arbeiten können:
Einfache transformationen sind eine Bearbeitungsmöglichkeit für Vektoren:
vektor <- c(1,2,3,4)
vektor + 1 # Wir addieren 1 zu jedem Vektorelement## [1] 2 3 4 5
Es lassen sich auch Vektoren durch Rechenoperationen miteinander verbinden:
vektor1 <- c(1,2,3,4)
vektor2 <- c(5,6,7,8)
vektor1 * vektor2## [1] 5 12 21 32
Auch beim Rechnen mit Vektoren ermöglicht uns logical indexing die gezielte Bearbeitung einer Untergruppe von Elementen:
vektor <- c(1,2,3,4,5,6,7,8,9,10)
vektor[vektor >= 7] +1 # Wir addieren 1 zu allen Zahlen größer gleich 7 und lassen uns das Ergebnis zurückliefern.## [1] 8 9 10 11
Im Folgenden üben wir das Rechnen mit und Bearbeiten von Vektoren:
A5) Erstelle einen neuen Vektor, der für jede Versuchsperson den Mittelwert der beiden IQ-Skalen darstellt.
A6) Erstelle einen neuen Vektor, der die z-standardisierten Gesamt-IQ-Werte für jede Versuchsperson enthält.
a) Standardisiere die Werte anhand der Vorgabewerte im Testmanual (m=100, sd=15).
b) Standardisiere die Werte anhand der Stichprobenwerte.
A7) Überprüfe für A6b, ob die z-Standardisierung erfolgreich war (m ca. 0?, sd ca. 1?).
A8) Wie häufig ist der z-Wert in A6a größer als der z-Wert in A6b?
Die Lösungen sind auf folgender Seite zu finden:
Wir können uns viele herkömmliche Datensätze als Aneinaderreihung von Vektoren darstellen, bei denen jeder Vektor eine Variable enthält. Aus den von uns erstellten Vektoren sollte sich also eigentlich leicht ein Datensatz bauen lassen, der strukturell dem entspricht, was wir auch von anderen Statistikprogrammen her kennen.
Wir können den Zusammenbau unserer Vektoren zu einem Datensatz mit zwei verschiedenen Funktionen durchführen, die nun kurz erläutert werden:
Die Funktion cbind() ermnöglicht es Benutzern mehrere Vektoren als Spalten (columns; cbind leitet sich von column bind her) aneinander zu fügen. Wenn wir cbind() benutzen, wird aus unseren Vektoren ein neues R Objekt vom Typ matrix. Die Ergebnismatrix ist im Gegensatz zu den einzelnen Vektoren zweidimensional und in unseren Datensätzen in aller Regel so aufgebaut, dass jede Spalte eine Variable darstellt und jede Zeile eine Versuchsperson:
data_matrix <- cbind(vp_nummer, alter, geschlecht, iq_fluid, iq_kristallin)Die Ergebnismatrix ist übrigens vom Typ String (in der Speicheransicht steht chr für character) und alle numerischen Variablen wurden in Strings umgewandelt, weil Matrizen in R nur einen Datentyp enthalten durfen (so wie Vektoren).
Die Funktion data.frame() erlaubt es uns, aus unseren Vektoren ein neues Objekt vom Typ data frame zu erstellen. Im Gegensatz zu Matrizen dürfen Dataframes unterschiedliche Variablentypen enthalten und beim Aufruf können wir außerdem neue Variablennamen vergeben:
data_frame <- data.frame(Vp = vp_nummer, Alter = alter, Geschlecht = geschlecht)A9) Erstelle ein data frame aus vp_nummer, alter, geschlecht und Gesamt-IQ-Wert aus A5.
A10) Ergänze das Frame aus A9 um die beiden Vektoren mit den unterschiedlich z-standardisierten Gesamt-IQ-Werten.
Die Lösungen sind auf folgender Seite zu finden:
Der Zugriff auf relevante Daten in Datenframes und Matrizen erfolgt ähnlich wie der Zugriff auf Daten in Vektoren, allerdings muss hier die zweite Dimension berücksichtigt werden, so dass sich die Zugriffsyntax leicht verändert
Wir können bei Datenframes und Matrizen wieder mit [ ] arbeiten, allerdings wird in den eckigen Klammern nun zunächst eine Angabe zu den auszuwählenden Reihen und dann, getrennt durch ein Komma, eine Angabe zu den auszuwählenden Spalten gemacht:
data_matrix[1,] # Auswahl der ersten Reihe der Matrix## vp_nummer alter geschlecht iq_fluid iq_kristallin
## "1" "20" "male" "107" "104"
data_matrix[,2] # Auswahl der zweiten Spalte der Matrix## [1] "20" "34" "24" "28" "28" "22" "20" "20" "34" "20"
data_matrix[1,2] # Auswahl der ersten Reihe und zweiten Spalte der Matrix. Hiermit wird eine einzelne Zelle ausgewählt## alter
## "20"
data_matrix[1:3,] # Reihen 1 bis 3 der Matrix## vp_nummer alter geschlecht iq_fluid iq_kristallin
## [1,] "1" "20" "male" "107" "104"
## [2,] "2" "34" "female" "113" "114"
## [3,] "3" "24" "male" "118" "106"
Zu beachten ist, dass das Komma in der eckigen Klammer nie weggelassen werden darf, auch wenn nur Angaben bezüglich der Reihe oder nur Angaben bezüglich der Spalte gemacht werden. Wenn für Zeilen oder Spalten keine Angaben gemacht werden, bleibt der Raum zwischen der entsprechenden Klammer und dem Komma einfach leer, z.B. [,1] oder [1,].
Natürlich können wir auch bei Matrizen und Datenframes wieder logical indexing verwenden, um nur bestimmte Daten auszuwählen:
data_matrix[data_matrix[,1]>7,] # Wähle alle Reihen aus, in denen die Spalte 1 der Matrix größer 7 ist.## vp_nummer alter geschlecht iq_fluid iq_kristallin
## [1,] "8" "20" "male" "96" "91"
## [2,] "9" "34" "male" "119" "124"
Bei Datenframes (nicht bei Matrizen!) können wir auch den $-Operator verwenden, um einzelne Spalten unserer Matrix anhand ihres Variablennamens auszuwählen:
data_frame$Alter # Auswahl der Altersvariable anhand des Variablennamens## [1] 20 34 24 28 28 22 20 20 34 20
A11) Lasse dir aus dem Datenframe den Gesamt-IQ-Wert der dritten Person im Datensatz anzeigen.
A12) Lasse dir aus der Datenmatrix die Spalte mit den Alterswerten anzeigen.
A13) Erstelle einen neuen Datenframe, der nur die Werte der ersten beiden Versuchspersonen enthält.
A14) Erstelle einen neuen Datenframe, der nur die Werte weiblichen Versuchspersonen enthält.
Die Lösungen sind auf folgender Seite zu finden:
Der Befehl subset() ermöglicht es uns spezifische Zeilen oder Spalten aus einem Datensatz auszuwählen, wobei diese Funktion deutlich komfortabler und weniger fehleranfällig ist, als das herkömmliche logical indexing mit [ ]. Wir müssen beim Aufruf von subset() mindestens zwei Argumente übergeben. Zum einen muss die Funktion wissen, von welchem Datensatz wir einzelne Teile auswählen wollen und zum anderen brauchen wir einen logischen Ausdruck zur Auswahl einzelner Zeilen oder Spalten:
subset(data_frame,subset= Geschlecht=='female') # Wir wählen mit dem Argument subset die weiblichen Versuchspersonen aus## Vp Alter Geschlecht
## 2 2 34 female
## 4 4 28 female
## 5 5 28 female
## 6 6 22 female
## 7 7 20 female
subset(data_frame,select=c(Geschlecht, Alter)) # Das Argument select ermöglicht die Auswahl spezifischer Spalten## Geschlecht Alter
## 1 male 20
## 2 female 34
## 3 male 24
## 4 female 28
## 5 female 28
## 6 female 22
## 7 female 20
## 8 male 20
## 9 male 34
## 10 male 20
subset(data_frame, subset= Geschlecht=='female', select=c(Geschlecht, Alter)) # Wir können die Parameter subset und select auch zusammen verwenden## Geschlecht Alter
## 2 female 34
## 4 female 28
## 5 female 28
## 6 female 22
## 7 female 20
Häufig müssen wir in unseren Datensätzen zunächst Variablen rekodieren oder anderweitig transformieren, um sinnvolle Auswertungen durchführen zu können. Damit dabei keine Fehler passieren sollte man immer neue Variablen erstellen und nicht die vorhandenen überschreiben!
Eine neue Variable lässt sich auf verschiedene Arten zu einem Datenframe hinzufügen. Durch den folgenden Befehl wird unser aus bislang drei Variablen bestehendes Datenframe um eine vierte Variable erweitert, die in allen Zeilen den Wert 1 hat:
data_frame <- data.frame(Vp = vp_nummer, Alter = alter, Geschlecht = geschlecht) # Ein einfaches Datenframe
data_frame[,4] <- 1 Wir können auch ganze Vektoren in unser Datenframe einfügen. Das funktioniert sowohl über den Index in den eckigen Klammern als auch über die Funktion cbind(), die wir bereits kennen gelernt haben:
test_vektor <- c(1,2,3,4,5,6,7,8,9,10)
data_frame[,5] <- test_vektor
data_frame <- cbind(data_frame, test_vektor)Die Zuweisung einer neuen Variablen kann auch mit dem $-Operator erfolgen. Dabei kann man den Variablennamen hinter dem $ selbst wählen:
data_frame$newVar <- 1 Wir können nun neue Variablen erstellen und dabei genau so rechnen, wie wir das bislang schon mit einzelnen Vektoren gemacht haben. Zum Beispiel lässt sich ohne Weiteres die z-Standardisierung, welche wir bereits an einem einzelnen Vektor von IQ-Werten durchgeführt haben, auch innerhalb eines Datenframes vornehmen:
data_frame <- data.frame(Vp = vp_nummer, Alter = alter, Geschlecht = geschlecht, IQ_Fluid = iq_fluid)
data_frame$zScore_Fluid <- (data_frame$IQ_Fluid-100)/15Wie man sieht greifen wir auf eine Variable innerhalb des Frames zu, um eine neue Variable zu erstellen. Wir können natürlich auch auf mehrere Variablen zugreifen, z.B. um noch einmal den Gesamt-IQ-Wert zu berechnen:
data_frame <- data.frame(Vp = vp_nummer, Alter = alter, Geschlecht = geschlecht, IQ_Fluid = iq_fluid, IQ_Kristallin = iq_kristallin)
data_frame$Mean_IQ <- (data_frame$IQ_Fluid + data_frame$IQ_Kristallin)/2Auf diese Art und weise können wir also ganze Variablen transformieren und neue Variablen erstellen.
Durch die Nutzung von logical indexing können wir wie schon gesehen einzelne Teile von Datenframes auswählen und gezielt verändern. Dieser Umstand ermöglicht es uns zum Beispiel negativ gepolte Variablen zu rekodieren. Wir erstellen dazu zunächst einen sehr einfachen Beispieldatensatz, der für 10 Probanden jeweils 4 Variablen enthält. Die Variablen sind Antworten auf einer 5-stufigen Likertskala, die jeder Proband gegeben hat. 2 der Items sind negativ gepolt und müssen daher rekodiert werden:
item_1 <- c(2,1,4,3,5,4,2,2,5,5)
item_2 <- c(5,4,3,3,1,5,2,4,3,5) # Wir wissen, dass dieses Item rekodiert werden muss
item_3 <- c(1,1,1,2,1,3,2,1,1,1)
item_4 <- c(3,1,4,2,5,3,1,1,5,4) # Auch dieses Item muss rekodiert werden!
data_frame <- data.frame(item1 = item_1, item2 = item_2, item3 = item_3, item4 = item_4)Da wir mit dem Messinstrument vetraut sind wissen wir auch, welche Variablen negativ gepolt sind, ohne dass diese speziell gekennzeichnet sind. Wir wollen nun das zweite Item rekodieren:
data_frame$item_2_recode <- NA # Wir initialisieren eine fünfte Variable (die automatisch rechts an das bestehende Frame gehängt wird)
item_2 = NA
data_frame$item_2_recode[data_frame$item2 == 1] <- 5
data_frame$item_2_recode[data_frame$item2 == 2] <- 4
data_frame$item_2_recode[data_frame$item2 == 3] <- 3
data_frame$item_2_recode[data_frame$item2 == 4] <- 2
data_frame$item_2_recode[data_frame$item2 == 5] <- 1Es ist zwar nicht zwingend notwendig eine neue Variable mit NAs zu erstellen, hat aber den Vorteil, dass wir nach der Rekodierung sehen können, ob es fehlende Werte gibt, oder ob es zu Fehlern gekommen ist, wenn nach wie vor NAs in der rekodierten Variable vorhanden sind. Die Umpolung erfolgt für jede Ausprägung der Skala einzeln. Wir wählen z.B. alle Fälle aus, in denen item_2 den Wert 2 annimmt und schreiben in unsere neue Variable in diesen Fällen den Wert 4. So verfahren wir dann mit allen Ausprägungen und erhalten schließlich unsere vollständig rekodierte neue Variable.
data_frame## item1 item2 item3 item4 item_2_recode
## 1 2 5 1 3 1
## 2 1 4 1 1 2
## 3 4 3 1 4 3
## 4 3 3 2 2 3
## 5 5 1 1 5 5
## 6 4 5 3 3 1
## 7 2 2 2 1 4
## 8 2 4 1 1 2
## 9 5 3 1 5 3
## 10 5 5 1 4 1
A15) Rekodiere die vierte Variable des obigen Datenframes nach folgendem Muster: 1=-2, 2=-1, 3=0, 4=1, 5=2.
A16) Erweitere das Datenframe um den Geschlechtsvektor, den wir zuvor verwendet haben. Rekodiere den Vektor nach folgendem Muster: 'male'=0, 'female'=1.
A17) Erstelle im Datenframe eine neue Variable, die die Summe der beiden nun rekodierten Items (item2 und item4) sowie der beiden nicht rekodierten Items (item1 und item3) enthält.
Die Lösungen sind auf folgender Seite zu finden:
Um negativ gepolte Variablen einfacher umzuwandeln können wir die Funktion recode() benutzen. Da diese Funktion nicht in der Basisinstallation von R enthalten ist, muss aber zunächst ein Erweiterungspaket installiert und geladen werden. Dieser Vorgang wird im nächsten Abschnitt des Skripts erklärt.
Zum nächsten Abschnitt springen
Sobald das Erweiterungspaket car geladen wurde, steht die Funktion recode() zur Verfügung. Beim Aufruf müssen wir zunächst die zu rekodierende Variable angeben und dann jedem Originalwert einen neuen Wert zuweisen. Diese Zuweisung muss in einer bestimmten Syntax in einen String geschrieben werden:
gender_recoded <- recode(geschlecht, "'male'=1; 'female'=2")Die einzelnen Rekodieranweisungen innerhalb des Strings werden hier durch ; getrennt. Zu beachten ist außerdem, dass man unterschiedliche Stringzeichen benutzen muss, um Strings innerhalb der einzelnen Rekodieranweisungen kenntlich zu machen.
Die Standardinstallation von R beinhaltet zwar eine große Menge unterschiedlicher Funktionen, da es sich bei R aber um eine sehr allgemeine Entwicklungsumgebung für mathematische Anwendungen handelt, kann in der Standardinstallation nur ein kleiner Ausschnitt des möglichen Funktionsumfangs geliefert werden. Benutzer können ihre R Installation deshalb an ihre eigenen Anforderungen und Spezialgebiete anpassen, in dem sie zusätzliche Funktionspakete installieren und laden. Um ein R Paket zu installieren verwenden wir die Funktion install.packages():
install.packages('car') # Installiert das Paket car (companion to applied regression)Im obigen Beispiel installieren wir das Paket car, welches uns eine Reihe nützlicher Funktionen bietet. Bei der Installation mit install.packages() müssen wir den Namen des Pakets (mit korrekter Groß- und Kleinschreibung!) als String angeben. Ein R Paket muss man auf jedem Rechner immer nur jeweils einmal installieren, deshalb sollte man Befehle wie install.packages()* nicht in normale Auswertungsskripte schreiben. Das Paket würde dann bei jeder Ausführung des Skripts immer wieder neu installiert werden. Alternativ kann man nach der ersten Ausführung die Anweisung auch auskommentieren.
Sobald ein Paket installiert wurde, lässt es sich mit dem Befehl library() laden:
library(car) # Das Paket wird geladenBeim Aufruf von library() muss der Paketname mit korrekter Groß- und Kleinschreibung angegeben werden, jedoch ist die Übergabe als String wie man sieht nicht zwingend erforderlich (aber dennoch möglich). Erweiterungspakete müssen in jeder R Session neu geladen werden, daher können die Ladebefehle einfach im normalen Auswertungsskript stehen. Auch ein wiederholtes Laden der Pakete ist (im Gegensatz zur ständigen Neuinstallation) kein Problem. Sobald ein Paket geladen wurde, stehen die darin enthaltenen Funktionen zur Verfügung.
Bislang haben wir uns im Rahmen dieser Einführung einfach kleine Datensätze aus einzelnen Vektoren gebastelt. In unserer alltäglichen Arbeit wollen wir allerdings in der Regel mit bestehenden Datensätzen arbeiten, die z.B. als Dateien im SAV-Format (Das Dateiformat von SPSS Datensätzen) oder im CSV-Format (Comma Separated Value, ein Tabellenformat) vorliefen. R bietet uns (wenn wir im Bedarfsfall noch das eine oder andere benötigte Paket laden) diverse Funktionen, die viele unterschiedliche Dateiformate in Datenframes einlesen können. Im Folgenden wollen wir uns ansehen, wie sich zwei der Dateiformate einlesen lassen, die wir sehr häufig gebrauchen. Es handelt sich um die schon erwähnten CSV- und SAV-Dateien.
Das CSV-Format ist ein einfaches Tabellenformat, in dem jede Reihe einer Tabelle eine Zeile in der Datei darstellt und alle Spalten durch ein spezifisches Trennzeichen voneinander unterschieden werden können (Daher der Name comma separated value). Es ist hierbei nicht zwingend so, dass die Zellen innerhalb einer Zeile durch Kommata getrennt sein müssen. Häufig wird auch das Semikolon als Trennzeichen benutzt, damit das Komma als Dezimalzeichen dienen kann.
R bietet schon in der Basisversion zwei Funktionen, die uns das Einlesen von Daten aus CSV-Dateien ermöglichen. Die Funktion read.csv() liest standardmäßig CSV-Dateien ein, deren Zellen durch Kommata getrennt werden und die den Punkt als Dezimaltrennzeichen verwenden. Die Funktion read.csv2 hingegen liest CSV-Dateien ein, die ein Semikolon als Trennzeichen und das Komma als Dezimalzeichen verwenden. Beide Funktionen sind eigentlich identisch. Sie unterscheiden sich lediglich in den Standardeinstellungen bestimmter Parameter (nämlich genau dem standardmäßigen Trennzeichen und dem standardmäßigen Dezimalzeichen), was man auch in der Hilfedatei zu dieser Funktion sieht. Beim Aufrufen der Funktionen muss in jedem Fall der Speicherort der Datei angegeben werden. Dabei werden auch Internetadressen (URL) unterstützt:
data <- read.csv2('http://e-scientifics.de/content/datasets/Big5_GEMI_R.csv') # Einlesen eines BeispieldatensatzesDie Angabe des Speicherortes erfolgt immer als String, der entweder den Ordnerpfad auf der Festplatte oder die URL eines Datensatzes enthält. Sofern der Datensatz mit den Standardeinstellungen kompatibel ist, brauchen wir keine weiteren Argumente. Es gibt jedoch zusätzliche Parameter, die wir bei der Funktion read.csv2() einstellen können.
Das Argument header kann auf FALSE gesetzt, wenn die Datei keine Variablennamen in der ersten Zeile enthält:
data <- read.csv2('http://e-scientifics.de/content/datasets/Big5_GEMI_R.csv', header=FALSE)Natürlich können auch benutzerdefinierte Dezimal- und Trennzeichen eingestellt werden. Im folgenden Beispiel laden wir unseren Datensatz, der eigentlich mit read.csv2() kompatibel ist, einfach mit read.csv() und stellen die Argumente für das Trennzeichen (sep) und das Dezimalzeichen (dec) selber ein:
# Jetzt sind die Standardeinstellung so wie bei read.csv2():
data <- read.csv('http://e-scientifics.de/content/datasets/Big5_GEMI_R.csv', sep=';', dec=',') Wir können in R auch das Paket foreign laden, welches uns Funktionen zum Einlesen von SAV-Dateien, also SPSS-Datensätzen, ermöglicht. Nachdem das Paket geladen wurde, können wir die Funktion read.spss() benutzen:
library('foreign')data <- read.spss('http://e-scientifics.de/content/datasets/Big5_GEMI_R.sav', to.data.frame=TRUE) ## Warning: C:\Users\CTREFF~1.LAP\AppData\Local\Temp\RtmpAVEGaL\file15142d7f4fad: Unrecognized record type 7, subtype 18 encountered in system file
## Warning: C:\Users\CTREFF~1.LAP\AppData\Local\Temp\RtmpAVEGaL\file15142d7f4fad: Unrecognized record type 7, subtype 24 encountered in system file
Wir setzen das Argument to.data.frame auf TRUE, damit wir ein Datenframe als Rückgabewert erhalten. Andernfalls würde die Funktion einen Listentyp zurückgeben. Obwohl der Funktionsaufruf einige Warnungen anzeigt, funktioniert das Einlesen des Datensatzes.
Achtung: Beim Import von Daten mit der Funktion read.spss() aus dem Paket foreign ist immer Vorsicht geboten! Neben den schon gezeigten Warnmeldungen kann es schnell zu Fehlern kommen, wenn Datensätze Sonderzeichen enthalten. Weitere Importfehler entstehen, wenn lange Stringvariablen (z.B. aus offenen Antwortfeldern) importiert werden müssen. In solchen Fällen ist es immer wichtig sich zu vergewissern, dass der Import der Daten fehlerfrei funktioniert hat, auch wenn keine Warnungen diesbezüglich angezeigt werden.
Eine mögliche und von vielen Anwendern bevorzugte Alternative zu read.spss() ist der Export von SPSS-Dateien aus SPSS selbst heraus, z.B. in ein CSV-Format, welches dann problemlos von read.csv2() gelesen werden kann. Dies ist zwar umständlicher als der direkte Import von SPSS-Dateien, funktioniert dafür in den allermeisten Fällen ohne Warnungen oder Fehler.
Nachdem wir nun gelernt haben, wie man einen bestehenden Datensatz in R lädt, können wir uns einige Funktionen ansehen, die uns bei der Aufbereitung eines Datensatzes unterstützen können. Dazu gehört natürlich auch die Funktion recode() aus dem Paket car, mit der wir Variablen sehr einfach rekodieren können. Es gibt über die folgenden Beispiele hinaus natürlich noch diverse andere Funktionen und Pakete, die sich sinnvoll bei der Datenaufbereitung einsetzen lassen. Als Benutzer sollte man immer dann, wenn man mit einem neuen Problem bzw. einer neuen Aufgabe in R konfrontiert wird zunächst einmal eine Suche nach möglichen Funktionen durchführen, die bei der Lösung behilflich sein können. So lernt man Schritt für Schritt mehr Funktionen kennen, die sich im alltäglichen Gebrauch gut einsetzen lassen. Die folgenden zwei Beispiele stellen daher nur einen sehr kleinen Ausschnitt der Möglichkeiten dar, die wir mit R haben.
Oftmals wollen wir die Namen neu erstellter, aber auch alter Variablen in unserem Datensatz anpassen. Dies können wir ganz einfach über die Funktion names() bei Datenframes erreichen. Wir können diese Funktion einerseits benutzen, um uns alle Variablennamen in einem Datensatz ausgeben zu lassen und andererseits, um die Namen einzelner oder aller Variablen auf einmal zu Überschreiben:
names(data) # Gibt uns alle Variablennamen in data zurück## [1] "vpage" "vpsex" "neo_ffi_1" "neo_ffi_2" "neo_ffi_3"
## [6] "neo_ffi_4" "neo_ffi_5" "neo_ffi_6" "neo_ffi_7" "neo_ffi_8"
## [11] "neo_ffi_9" "neo_ffi_10" "neo_ffi_11" "neo_ffi_12" "neo_ffi_13"
## [16] "neo_ffi_14" "neo_ffi_15" "neo_ffi_16" "neo_ffi_17" "neo_ffi_18"
## [21] "neo_ffi_19" "neo_ffi_20" "neo_ffi_21" "neo_ffi_22" "neo_ffi_23"
## [26] "neo_ffi_24" "neo_ffi_25" "neo_ffi_26" "neo_ffi_27" "neo_ffi_28"
## [31] "neo_ffi_29" "neo_ffi_30" "neo_ffi_31" "neo_ffi_32" "neo_ffi_33"
## [36] "neo_ffi_34" "neo_ffi_35" "neo_ffi_36" "neo_ffi_37" "neo_ffi_38"
## [41] "neo_ffi_39" "neo_ffi_40" "neo_ffi_41" "neo_ffi_42" "neo_ffi_43"
## [46] "neo_ffi_44" "neo_ffi_45" "neo_ffi_46" "neo_ffi_47" "neo_ffi_48"
## [51] "neo_ffi_49" "neo_ffi_50" "neo_ffi_51" "neo_ffi_52" "neo_ffi_53"
## [56] "neo_ffi_54" "neo_ffi_55" "neo_ffi_56" "neo_ffi_57" "neo_ffi_58"
## [61] "neo_ffi_59" "neo_ffi_60"
names(data)[2] # Gibt uns einen einzelnen Variablennamen zurück## [1] "vpsex"
names(data)[c(1,3,5,7)] # Gibt uns den Variablennamen mehrerer spezifischer Variablen zurück## [1] "vpage" "neo_ffi_1" "neo_ffi_3" "neo_ffi_5"
names(data) <- c(1:62) # Überschreibt alle Variablennamen auf einmal mit den Zahlen von 1 bis 62In aller Regel wollen wir nicht alle Variablennamen, sondern nur einzelne Variablennamen verändern. Hierzu benutzen wir einfach die eckigen Indexklammern:
names(data)[1] <- 'Alter'
names(data)[2] <- 'Geschlecht'Wir wir in der Ausgabe sehen, wurden die Variablennamen für das Alter und das Geschlecht der Versuchspersonen mit unseren neuen Namen überschrieben:
## [1] "Alter" "Geschlecht" "neo_ffi_1" "neo_ffi_2" "neo_ffi_3"
## [6] "neo_ffi_4" "neo_ffi_5" "neo_ffi_6" "neo_ffi_7" "neo_ffi_8"
## [11] "neo_ffi_9" "neo_ffi_10" "neo_ffi_11" "neo_ffi_12" "neo_ffi_13"
## [16] "neo_ffi_14" "neo_ffi_15" "neo_ffi_16" "neo_ffi_17" "neo_ffi_18"
## [21] "neo_ffi_19" "neo_ffi_20" "neo_ffi_21" "neo_ffi_22" "neo_ffi_23"
## [26] "neo_ffi_24" "neo_ffi_25" "neo_ffi_26" "neo_ffi_27" "neo_ffi_28"
## [31] "neo_ffi_29" "neo_ffi_30" "neo_ffi_31" "neo_ffi_32" "neo_ffi_33"
## [36] "neo_ffi_34" "neo_ffi_35" "neo_ffi_36" "neo_ffi_37" "neo_ffi_38"
## [41] "neo_ffi_39" "neo_ffi_40" "neo_ffi_41" "neo_ffi_42" "neo_ffi_43"
## [46] "neo_ffi_44" "neo_ffi_45" "neo_ffi_46" "neo_ffi_47" "neo_ffi_48"
## [51] "neo_ffi_49" "neo_ffi_50" "neo_ffi_51" "neo_ffi_52" "neo_ffi_53"
## [56] "neo_ffi_54" "neo_ffi_55" "neo_ffi_56" "neo_ffi_57" "neo_ffi_58"
## [61] "neo_ffi_59" "neo_ffi_60"
In dem zuvor geladenen Beispieldatensatz finden wir die Datensätze von 160 Versuchspersonen, die den NEO-FFI bearbeitet haben. Um die Fragebogendaten auswerten zu können, müssen wir Skalenwerte auf Basis der einzelnen Items berechnen. Zuvor müssen wir jedoch einige der Items rekodieren, so wie wir es zuvor gelernt haben. Wir verwenden dafür die Funktion recode().
A18) Rekodiere folgende Variablen so um, dass ihre negative Polung umgekehrt wird:
- neo_ffi_1
- neo_ffi_3
- neo_ffi_8
- neo_ffi_9
- neo_ffi_12
- neo_ffi_14
- neo_ffi_15
- neo_ffi_16
- neo_ffi_18
- neo_ffi_23
- neo_ffi_24
- neo_ffi_27
- neo_ffi_29
- neo_ffi_30
- neo_ffi_31
- neo_ffi_33
- neo_ffi_38
- neo_ffi_39
- neo_ffi_42
- neo_ffi_44
- neo_ffi_45
- neo_ffi_46
- neo_ffi_48
- neo_ffi_54
- neo_ffi_55
- neo_ffi_57
- neo_ffi_59
Hinweise: Das Paket car muss geladen werden, um Zugriff auf die Funktion recode zu erhalten. Verschiedene Lösungen sind auf folgender Seite zu finden:
Wir lesen der Einfacheit halber einen neuen Datensatz ein, der die rekodierten Items des NEO-FFI bereits enthält. Dieser Datensatz ist allerdings im Gegensatz zu unserer vorherigen Übung so aufgebaut, dass die rekodierten Variablen die ursprünglichen Variablen ersetzt haben. Daher hat dieser Datensatz genau so viele Variablen wie die nicht rekodierten Rohdaten. Lediglich die Variablennamen weisen darauf hin, welche Variablen rekodiert wurden und welche nicht:
data <- read.csv2('http://e-scientifics.de/content/datasets/Big5_GEMI_R_recoded.csv') # Einlesen des rekodierten BeispieldatensatzesWir wollen nun die Skalenwerte für die 5 Skalen Neurotizismus, Extraversion, Offenheit für Erfahrung, Verträglichkeit und Gewissenhaftigkeit berechnen. Die sind definiert als die Mittelwerte von jeweils 12 der 60 Items. Bei der Berechnung hilft uns die Funktion rowMeans(), die es erlaubt, den Mittelwert für eine spezifische Menge von Variablen pro Zeile einfacher zu berechnen, als diesen Mittelwert manuell zu bilden, wie wir es zuvor z.B. mit der Funktion mean() schon getan haben:
Skala_N <- rowMeans(data[,c(1,6,11,16,21,26,31,36,41,46,51,56)+2])Da wir genau wissen, an welcher Stelle in unserem Datensatz sich die benötigten Items befinden, können wir leicht mit den Indexklammern und einer Liste der Spaltennummern arbeiten (das +2 kommt daher, dass die ersten beiden Variablen im Datensatz das Alter und das Geschlecht sind, welche wir durch das +2 einfach überpsringen). Die Items des NEO-FFI sind so aufgebaut, dass die Skalen in einer festen Reihenfolge immer wieder mit einem Item abgefragt werden, d.h. die ersten 5 Items fragen jede Skala einmal ab, die zweiten fünf Items, usw. Dieser Umstand ermöglicht es uns auch die Funktion seq() einzusetzen, um unseren Code akzukürzen:
Skala_E <- rowMeans(data[,seq(from=4,to=59,by=5)]) Beim Aufruf von seq() übergeben wir drei Argumente. Die Argumente from und to bezeichnen den Anfangs- und den Endpunkt unserer gewünschten Sequenz. Mit dem Argument by können wir die Schrittgröße innerhalb der Sequenz festlegen. Da wir wissen, dass nach 5 Items die Sequenz unserer Skalen neu beginnt, lässt sich unser Aufruf von rowMeans() wie oben gezeigt anpassen.
A19) Berechne die Skalenwerte für die drei verbleibenden Skalen des NEO-FFI. Füge die 5 neuen Variablen zum bestehenden Datensatz hinzu.
Die Lösung ist auf folgender Seite zu finden:
Nachdem wir nun einen Datensatz geladen, rekodiert und aufbereitet haben, wollen wir uns die für uns relevanten Variablen genauer ansehen. Dazu berechnen wir im Folgenden einige deskriptive Informationen. Als Grundlage dient uns der zuvor erstellte Datensatz mit den NEO-FFI-Skalenwerten.
Deskriptive Statistiken zu einzelnen Variablen können wir mit Hilfe einiger der Funktionen berechnen, die wir bereits kennen gelernt haben. Zusätzlich gibt es im folgenden Beispiel einige Funktionen, die wir zwar noch nicht kennen, die aber genau so funktionieren wie mean() oder sd(). Im Zweifelsfall hilft ein Blick in die Hilfedatei der jeweiligen Funktion:
mean(data$Skala_N) # Gibt uns den Mittelwert der Skala in unserer Stichprobe zurück## [1] -0.2807
sd(data$Skala_N) # Standardabweichung## [1] 0.7036
median(data$Skala_N) # Median## [1] -0.3333
min(data$Skala_N) # Kleinster Wert in der Stichprobe## [1] -1.833
max(data$Skala_N)# Größter Wert in der Stichprobe## [1] 1.75
range(data$Skala_N) # Range der Skalenwerte## [1] -1.833 1.750
A20) Suche im Internet oder der R-Hilfe nach einer Funktion, die dir die Kurtosis einer Verteilung zurückgibt. Berechne die Kurtosis der Variable Skala_N im Datensatz. Hinweis: Du musst hierfür ein extra Paket laden.
A21) Suche im Internet oder der R-Hilfe nach einer Funktion, die dir die Schiefe einer Verteilung zurückgibt. Berechne die Kurtosis der Variable Skala_N im Datensatz. Hinweis: Du musst hierfür ein extra Paket laden.
A22) Berechne alle beschriebenen deskriptiven Kennzahlen für die Variable Skala_E im Datensatz.
Nachdem wir nun diverse deskriptive Statistiken zu einzelnen Variablen per Hand berechnet haben ist klar, dass wir dauerhaft nicht für jede einzelne Variable alle Kennwerte so berechnen wollen. Das Paket psych, welches wir schon in den Lösungen zu den vorherigen Übungsaufgaben kennen gelernt haben, kann uns hier das Leben deutlich erleichtern. Wir laden zunächst das Paket und nutzen dann dessen Funktion describe(), welche uns für eine oder mehrere Variablen gleichzeitig diverse deskriptive Kennzahlen zurückliefert:
# install.packages('psych') # Wir können diesen Befehl nutzen, falls das Paket psych noch nicht installiert ist
library('psych')describe(data$Skala_N) # Deskriptive Statistiken zu einer einzelnen Variable## vars n mean sd median trimmed mad min max range skew kurtosis
## 1 1 160 -0.28 0.7 -0.33 -0.3 0.74 -1.83 1.75 3.58 0.28 -0.31
## se
## 1 0.06
describe(data[,63:67]) # Auswahl aller 5 Skalenwerte mit den Indexklammern## vars n mean sd median trimmed mad min max range skew
## Skala_N 1 160 -0.28 0.70 -0.33 -0.30 0.74 -1.83 1.75 3.58 0.28
## Skala_E 2 160 0.49 0.48 0.50 0.49 0.37 -1.08 1.58 2.67 -0.18
## Skala_O 3 160 0.68 0.54 0.75 0.71 0.56 -0.83 1.83 2.67 -0.39
## Skala_V 4 160 0.62 0.49 0.67 0.63 0.49 -0.58 1.83 2.42 -0.16
## Skala_G 5 160 0.65 0.61 0.75 0.67 0.62 -1.08 1.92 3.00 -0.33
## kurtosis se
## Skala_N -0.31 0.06
## Skala_E 0.28 0.04
## Skala_O -0.31 0.04
## Skala_V -0.29 0.04
## Skala_G -0.32 0.05
Wie wir sehen, wird die Berechnung und Ausgabe deskriptiver Statistiken durch describe() deutlich vereinfacht.
Bei kategorialen Daten wollen wir uns in der Regel auch Häufigkeitstabellen ansehen. R bietet uns hier mit der Funktion table() einen schnellen Weg, solche Tabellen zu erstellen. Dabei beschränkt sich die anwendbarkeit natürlich nicht nur auf kategoriale Variablen:
table(data$vpsex , data$vpage )##
## 18 19 20 21 22 23 24 25 26 27 28 29 32 33 34 36 39 45 46
## 0 1 5 19 16 15 4 3 5 3 3 2 1 1 0 0 0 0 1 1
## 1 0 1 9 20 12 15 4 6 3 2 3 1 0 1 1 1 1 0 0
Neben deskriptiven Statistiken interessiert uns oft auch die grafische Darstellung von Variablen, z.B. um deren Verteilung zu untersuchen. R bietet uns mit der Funktion hist() eine sehr einfache Möglichkeit Histogramme zu erstellen:
hist(data$Skala_N)
R bietet eine Fülle von Funktionen, die uns Daten grafisch aufbereiten. Im Rahmen dieser Einführung können wir uns leider nicht weitergehend damit beschäftigen. Allen, die sich für das Erstellen von Grafiken mit R interessieren, sei aber das entsprechende Skript zu diesem Thema empfohlen:
Die Analyse von Zusammenhängen zwischen Variablen ist natürlich ein essentieller Aspekt der Datenauswertung. Einfache Korrelationen lassen sich in R mit der Funktion cor() berechnen:
cor(data$Skala_N, data$Skala_E)## [1] -0.2528
Wie wir sehen, gibt uns die Funktion lediglich den Korrelationskoeffizienten zurück. Um einen Signifikanztest der Korrelation durchzuführen, benutzen wir die Funktion cor.test():
cor.test(data$Skala_N, data$Skala_E)##
## Pearson's product-moment correlation
##
## data: data$Skala_N and data$Skala_E
## t = -3.285, df = 158, p-value = 0.001257
## alternative hypothesis: true correlation is not equal to 0
## 95 percent confidence interval:
## -0.3926 -0.1017
## sample estimates:
## cor
## -0.2528
Diese Funktion liefert uns neben dem Korrelationskoeffizienten auch eine Teststatistik. Sowohl bei cor() als auch bei cor.test() lässt sich die Art des Korrelationskoeffizienten ('Pearson', 'Kendall' oder 'Spearman') über den Parameter method einstellen. Hierzu finden sich weitere Informationen in den Hilfedateien zu beiden Funktionen.
Neben den deskriptiven Kennzahlen und Zusammenhangsmaßen wollen wir natürlich bei der Auswertung von Daten auf klassische inferenzstatistische Verfahren zurückgreifen, die uns die statistische Überprüfung von Hypothesen ermöglichen. In der Folge werden einige der wichtigsten Funktionen zur Anwendung solcher Verfahren erläutert.
Einen Chi²-Test führen wir mit der Funktion chisq.test() für tabellierte Häufigkeiten durch. Wir übergeben dabei direkt die gewünschte Tablle, die wir zuvor mit der Funktion table() erstellen:
data$vpage_cat <- cut(data$vpage, breaks=c(0,20,40,60)) # Erzeugen einer kategorischen Altersvariable
freq_table <- table(data$vpage_cat, data$vpsex)
chisq.test(freq_table)## Warning: Chi-squared approximation may be incorrect
##
## Pearson's Chi-squared test
##
## data: freq_table
## X-squared = 10.78, df = 2, p-value = 0.004566
Um einen t-Test zum Vergleich zweier Stichproben bzw. einen Einstichproben-t-Test durchzuführen, können wir in R die Funktion t.test() verwenden. Dabei wird t.test() je nach Art des gewünschten Tests mit unterschiedlichen Argumenten aufgerufen.
Ein t-Test für unabhängige Stichproben nutzt eine Formelsyntax, bei der die zu testende Variable links steht und die Gruppierungsvariable rechts. Getrennt werden beide Variablen durch ein ~:
t.test(data$Skala_N ~ data$vpsex) # Ein klassischer t-Test für unabhängige Variablen##
## Welch Two Sample t-test
##
## data: data$Skala_N by data$vpsex
## t = 2.033, df = 157.7, p-value = 0.04373
## alternative hypothesis: true difference in means is not equal to 0
## 95 percent confidence interval:
## 0.006376 0.441540
## sample estimates:
## mean in group 0 mean in group 1
## -0.1688 -0.3927
Bei einem t-Test für abhängige Variablen werden beide Variablen durch ein Komma getrennt als Argumente an die Funktion übergeben:
t.test(data$Skala_N, data$Skala_E) # Ein klassischer t-Test für abhängige Variablen##
## Welch Two Sample t-test
##
## data: data$Skala_N and data$Skala_E
## t = -11.4, df = 281.6, p-value < 2.2e-16
## alternative hypothesis: true difference in means is not equal to 0
## 95 percent confidence interval:
## -0.9021 -0.6365
## sample estimates:
## mean of x mean of y
## -0.2807 0.4885
Ein Einstichproben-t-Test benötigt neben der zu testenden Variable noch den Parameter mu, welcher die Konstante ist, gegen die die Veriable getestet werden soll:
t.test(data$Skala_N, mu=0) # Ein Einstichproben-t-Test gegen 0##
## One Sample t-test
##
## data: data$Skala_N
## t = -5.047, df = 159, p-value = 1.214e-06
## alternative hypothesis: true mean is not equal to 0
## 95 percent confidence interval:
## -0.3906 -0.1709
## sample estimates:
## mean of x
## -0.2807
Regressionsanalysen können wir in R mit der Funktion lm() durchführen. Die Funktion erwartet mindestens die Übergabe der beiden Parameter formula und data. Der Parameter formula enthält dabei das zu testende Regressionsmodell und der Parameter data bezeichnet den Datensatz, der die in der Formel angegebenen Variablen enthalten muss:
model_1 <- lm(formula = Skala_N ~ Skala_E, data = data)Der zuerst übergebene Fomelparameter muss immer auf der linken Seite die vorherzusagende Variable aufweisen und auf der rechten Seite, getrennt durch ~, die Prädiktoren des Modells. Im obigen Beispiel versuchen wir also die Neurotizismuswerte (Skala_N) unserer Versuchspersonen anhand ihrer Extraversionswerte (Skala_E) vorherzusagen. Man kann die Parameternamen auch weglassen und die Werte direkt in die Klammern schreiben:
model_1 <- lm(Skala_N ~ Skala_E, data)Durch die Ausführung der oberen Codezeile, erhalten wir zunächst noch keine Ausgabe der Ergebnisse unserer Regressionsanalyse. Stattdessen wird das gerechnete Regressionsmodell mit den Ergebnissen in der Variablen model_1 gespeichert. Diese Variable können wir nun als Parameter an die Funktion summary() übergeben, welche uns die Ergebnisse der Regressionsanalyse aufbereitet und in der Konsole anzeigt:
summary(model_1)##
## Call:
## lm(formula = Skala_N ~ Skala_E, data = data)
##
## Residuals:
## Min 1Q Median 3Q Max
## -1.430 -0.521 -0.101 0.453 1.820
##
## Coefficients:
## Estimate Std. Error t value Pr(>|t|)
## (Intercept) -0.1008 0.0769 -1.31 0.1919
## Skala_E -0.3683 0.1121 -3.28 0.0013 **
## ---
## Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
##
## Residual standard error: 0.683 on 158 degrees of freedom
## Multiple R-squared: 0.0639, Adjusted R-squared: 0.058
## F-statistic: 10.8 on 1 and 158 DF, p-value: 0.00126
Wir können unser einfaches Regressionsmodell nun mit anderen Prädiktoren zu einer multiplen Regression erweitern. Weitere Prädiktoren können auf der rechten Seite der Formelseite mit Hilfe von + hinzugefügt werden:
model_2 <- lm(Skala_N ~ Skala_E + Skala_G, data)
summary(model_2)##
## Call:
## lm(formula = Skala_N ~ Skala_E + Skala_G, data = data)
##
## Residuals:
## Min 1Q Median 3Q Max
## -1.5691 -0.5011 -0.0768 0.4066 1.6770
##
## Coefficients:
## Estimate Std. Error t value Pr(>|t|)
## (Intercept) 0.000592 0.091794 0.01 0.9949
## Skala_E -0.341288 0.111933 -3.05 0.0027 **
## Skala_G -0.176007 0.088841 -1.98 0.0493 *
## ---
## Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
##
## Residual standard error: 0.677 on 157 degrees of freedom
## Multiple R-squared: 0.0868, Adjusted R-squared: 0.0751
## F-statistic: 7.46 on 2 and 157 DF, p-value: 0.000805
Um Interaktionseffekte zwischen Prädiktoren in das Modell mit aufzunehmen, benutzen wir *:
model_3 <- lm(Skala_N ~ Skala_E * Skala_G, data)
summary(model_3)##
## Call:
## lm(formula = Skala_N ~ Skala_E * Skala_G, data = data)
##
## Residuals:
## Min 1Q Median 3Q Max
## -1.5667 -0.5032 -0.0708 0.4049 1.7106
##
## Coefficients:
## Estimate Std. Error t value Pr(>|t|)
## (Intercept) -0.0198 0.1126 -0.18 0.86
## Skala_E -0.2952 0.1848 -1.60 0.11
## Skala_G -0.1439 0.1357 -1.06 0.29
## Skala_E:Skala_G -0.0653 0.2080 -0.31 0.75
##
## Residual standard error: 0.679 on 156 degrees of freedom
## Multiple R-squared: 0.0873, Adjusted R-squared: 0.0698
## F-statistic: 4.98 on 3 and 156 DF, p-value: 0.00252
Hier ein Beispiel mit Zweifach- und Dreifachinteraktion:
model_4 <- lm(Skala_N ~ Skala_E * Skala_G * Skala_O, data)
summary(model_4)##
## Call:
## lm(formula = Skala_N ~ Skala_E * Skala_G * Skala_O, data = data)
##
## Residuals:
## Min 1Q Median 3Q Max
## -1.4475 -0.5045 -0.0911 0.4570 1.7586
##
## Coefficients:
## Estimate Std. Error t value Pr(>|t|)
## (Intercept) -0.13595 0.19547 -0.70 0.49
## Skala_E -0.41265 0.35446 -1.16 0.25
## Skala_G 0.00537 0.24361 0.02 0.98
## Skala_O 0.15338 0.21276 0.72 0.47
## Skala_E:Skala_G 0.00474 0.40550 0.01 0.99
## Skala_E:Skala_O 0.14196 0.38545 0.37 0.71
## Skala_G:Skala_O -0.19547 0.25639 -0.76 0.45
## Skala_E:Skala_G:Skala_O -0.09732 0.44660 -0.22 0.83
##
## Residual standard error: 0.681 on 152 degrees of freedom
## Multiple R-squared: 0.103, Adjusted R-squared: 0.0619
## F-statistic: 2.5 on 7 and 152 DF, p-value: 0.0186
Es gibt verschiedene Befehle und Sonderzeichen, die sich innerhalb einer Formel verwenden lassen, um z.B. ein Regressionsmodell genau zu spezifizieren. Eine schnelle Überischt hierüber findet man im folgenden Dokument:
Übersicht zur Formel-Syntax in R
Um Varianzanalysen (ohne Messwiederholungsfaktoren) in R durchzuführen, können wir die Funktion aov() nutzen. Diese Funktion funktioniert analog zu lm(), d.h. wir übergeben wieder einen Parameter formula, der die abhängige Variable und die Faktoren enthält, die in die Analyse einfließen sollen. Zusätzliche übergeben wir auch wieder den Parameter data, der den Datensatz spezifiziert, in dem die Analyse durchgeführt wird. Die Funktion summary() bereitet auch für Varianzanalysen die Ergebnisse auf:
aov_1 <- aov(Skala_O ~ vpsex + vpage_cat, data)
summary(aov_1)## Df Sum Sq Mean Sq F value Pr(>F)
## vpsex 1 0.1 0.0730 0.25 0.62
## vpage_cat 2 0.1 0.0277 0.09 0.91
## Residuals 156 45.7 0.2926
Hier ein Modell mit zusätzlichem Interaktionseffekt:
aov_2 <- aov(Skala_O ~ vpsex * vpage_cat, data)
summary(aov_2)## Df Sum Sq Mean Sq F value Pr(>F)
## vpsex 1 0.1 0.073 0.26 0.6116
## vpage_cat 2 0.1 0.028 0.10 0.9064
## vpsex:vpage_cat 1 2.0 1.979 7.02 0.0089 **
## Residuals 155 43.7 0.282
## ---
## Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1