R-Tutorial Teil 1: Der Einstieg

Diese Tutorial-Reihe ist eine Einführung in die statistische Programmiersprache R. Der erste Teil befasst sich mit der grundlegenden Syntax: Variablen, Vektoren, Matrizen, regelmäßige Folgen, sowie der Umgang mit Datensätzen. Teil 2 der R-Tutorial-Reihe befasst sich mit den Anweisungen zur Steuerung des Programmablaufs (bedingte Verzweigungen und Schleifen) und die Verwendung von Funktionen. Teil 3: Grafiken und Zufallszahlen der Tutorial-Reihe bietet einen Einblick in die Syntax zur Erzeugung von Grafiken und von Zufallszahlen und -stichproben in der Programmiersprache R.

Die Entwicklungsumgebung RStudio

Als Tool wird RStudio eingesetzt, eine Entwicklungs­umgebung und grafische Benutzer­oberfläche für die statistische Programmier­sprache R, die in Open-Source- und kommerziellen Editionen erhältlich ist und auf dem Desktop (Windows, Mac und Linux) oder in einem Browser läuft. Komplexere Algorithmen und Methoden sind in R in Paketen zusammengefasst, die nach Bedarf über die R-Konsole geladen werden können.

Eine R Version ist vor Installation von RStudio von der R-Webseite zu installieren, danach kann RStudio als Desktop-Anwendung installiert werden, siehe auf der Posit-­Webseite unter Produkte: RStudio IDE. Alternativ kann RStudio auch als Web-Anwendung verwendet werden.

Die Benutzeroberfläche von RStudio ist in vier konfigurierbare Panels unterteilt, die zum Entwickeln und Ausführen von Skripts verwendet werden. Die Konfiguration kann über View > Panes > Pane Layout Menu vorgenommen werden, und beschränkt sich hauptsächlich auf eine Auswahlmöglichkeit, welche Ansichten in welchem ​​Panel angezeigt werden sollen. Die Benutzeroberfläche von RStudio Cloud ist sehr ähnlich, außer, dass sie links eine Seitenleiste mit den Arbeitsbereichen und eine Breadcrumb-Navigation mit dem aktuellen Projekt anzeigt.

• Menü-Leiste: die Funktionalität der IDE ist in den Menüpunkten File, Edit, Code, View, Plots, Session, View, Debug gruppiert.
• Übersicht: zeigt den Inhalt des Arbeitsverzeichnisses, die erstellten Grafiken, die Package-Übersicht und die interne Hilfe an
• Environment: zeigt die Objekte der aktuellen R-Sitzung (Session) an.
• Editor: enthält den Inhalt (Quellcode, Kommentare) einer R-Datei und den RUN-Button zum Ausführen des Codes.
• Konsole: zeigt den ausgeführten Code an und deren Output, falls dieser ausgegeben werden soll.

R Code kann auf mehrere Arten erstellt und ausgeführt werden:

•  Interaktiv im R-Terminal:
  Die Befehle werden direkt in der Konsole eingegeben und mit der Enter-Taste ausgeführt, mit den Pfeiltasten nach Oben/Unten können die letzten Befehle aufgerufen werden bzw. in der History (Tab neben Environment) angesehen werden.
•   Programmierung eines R-Skripts:
  Größere Programme, d.h. mehrere Codezeilen, werden besser in einem R-Skript (Endung: .R) gespeichert, dieses R-Skript wird in einem Ordner, der als Arbeitsverzeichnis verwendet wird, gespeichert, siehe Abschnitt "R-Skript erstellen".
  Die Anzeige des aktuellen Arbeitsverzeichnisses erfolgt mit dem Befehl getwd() und kann mit setwd() auf einen beliebigen Ordner gesetzt werden. Die Angabe des Verzeichnispfades erfolgt mit dem "/"-Symbol und muss mit Anführungszeichen umrahmt werden.
  Durch das Anlegen eines R-Projektes, in dem alle für das Projekt relevanten Dateien und die R-Skripte abgespeichert werden, kann der Benutzer die Übersichtlichkeit bei der Programmierung verbessern. Das Arbeits­verzeichnis wird stets automatisch auf das aktive Projekt gesetzt, d.h. der Pfad zum Arbeits­verzeichnis muss nicht explizit im Skript mit setwd gesetzt werden, siehe Abschnitt "R-Projekt erstellen".
•  Webbasiert mit einer R Shiny-App:
  Das Shiny-Paket stellt Funktionen zur Erstellung einer interaktiven Webanwendung zur Verfügung. Die Details der Verwendung von R Shiny werden in dem Tutorial Anleitung zur Erstellung einer interaktiven Shiny-App mit RStudio erläutert und angewandt.

Verwendete Funktionen

setwd("C:/R/DemoR1")

getwd()

1 Erste Codezeilen in R

R-Code besteht aus Befehlen und Kommentaren.

Befehle / Kommandos sind ausführbare Anweisungen: Variablen-Zuweisungen, Ausdrücke, Funktionsaufrufe. Variablen sind benannte Speicherplätze, denen man Werte unterschiedlichen Datentyps (numerische Werte, Zeichen, Zeichenketten) und Ausdrücke zuweisen kann. R-Befehle unterscheiden zwischen Groß- und Kleinschreibung, d.h. max(x) ist nicht dasselbe wie Max(x). Eine Zuweisung erfolgt mittels dem = -Symbol oder dem Zuweisungssymbol <- -Symbol. Ein Ausdruck ist im Gegensatz zu einer Zuweisung zwar auch ein Befehl, wird jedoch sofort in der Konsole ausgeführt und liefert einen Output.

Kommentare dienen der besseren Verständlichkeit von Codezeilen und werden nicht ausgeführt. Alles was in der Zeile nach einem #-Symbol steht, ist als Kommentar gekennzeichnet und wird grün hinterlegt.

Codezeilen können direkt in der Konsole eingegeben werden oder in einem R-Skript gespeichert und über die RUN-Funktion ausgeführt werden. Hier wurde die Konsole benutzt um den Unterschied zwischen Kommentaren und Kommandos zu demonstrieren.

Wenn der Wert einer Zuweisung angezeigt werden soll, dann muss der bei Zuweisung vergebene Name als Ausdruck in der Konsole eingegeben werden. Um mehrere Kommandos in einer Zeile verwenden zu können, wird das Semikolon verwendet. Im Unterschied zu MATLAB trennt das Semikolon dabei Kommandos bei der Aufzählung und unterdrückt nicht die Ausgabe.

Hello World-Programm in R

Das Hello-World-Programm ist das kleinste ausführbare Programm in einer Programmiersprache und gibt den Text "Hello World" in der Konsole aus. Dies kann direkt in der Konsole eingegeben werden (Interaktiv) oder in ein R-Skript geschrieben und ausgeführt werden.

Interaktiv:
Die Befehle werden direkt in der Konsole eingegeben und mit ENTER ausgeführt, siehe die folgende Eingabe und Ausgabe in der Konsole von RStudio:

2 R-Skript erstellen

Ein R-Skript ist eine Text-Datei mit R-Befehlen und Kommentaren, diese Datei hat die Endung .R. Zulässige Skript-Namen bestehen aus Buchstaben, Zahlen und den Zeichen . und _ . Der Name beginnt mit einem Buchstaben oder dem Punkt, dabei darf keine Zahl nach dem Punkt folgen, d.h. ".2way" ist nicht zulässig. Ebenfalls nicht zulässig sind bereits von R reservierte Namen wie TRUE, FALSE, if, NULL usw.

R-Skripte werden über die Menüleiste File >New File >R Script oder das Tastenkürzel STRG+Shift+N erzeugt, weiterhin steht das Symbol ganz links (Papier mit dem grün-umrundeten Plus-Symbol) in der Symbol-Leiste dazu zur Verfügung. Das Skript wird über den Tab Code der Menüleiste und dessen entsprechenden RUN-Anweisungen ausgeführt, einfacher ist es jedoch über den RUN-Button im Editor, der die Zeile auf der der Cursor liegt oder die Zeilen, die markiert wurden, ausführt.

Als Nächstes wird mit File > New File > R Script ein neues R-Skript HelloWorld.R erstellt, das den R-Code enthalten wird.

R-Skript "HelloWorld"
In RStudio wird ein neues Skript erstellt und unter dem Namen "HelloWorld.R" gespeichert. Dann wird der String "Hello World" in einer Variablen t gespeichert. Im Unterschied zu MATLAB wird der Wert der Variablen t bei Ausführung des Befehls nicht sofort ausgegeben , sondern erst bei Aufruf des Variablennamens "t".

RStudio sieht nach Erstellung, Änderung und Ausführung des Skriptes "HelloWorld.R" wie folgt aus:

R-Code: Hello World

# R-Tutorial: Hello-World-Programm 
 
# die Zeichenkette/String in einer Variablen 
# mit Namen Text speichern
 
t="Hello World"
 
# Ausgabe des Inhalts der Variablen 
# durch Aufruf des Namens
 
t

Erläuterung des R-Codes

Zeile 1: einen Kommentar mit einer Beschreibung des Skript-Inhaltes
Zeile 6: der String "Hello World" wird unter dem Variablennamen "t" gespeichert
Zeile 11: die Variable "t" wird aufgerufen und damit wird ihr Wert ausgegeben

Erläuterungen zur Ausführung

Die Ausführung des Skriptes erfolgt entweder mit dem RUN-Button, der eine markierte Auswahl oder die aktuelle Zeile, auf der Cursor liegt, ausführt oder die komplette Ausführung mit der Tastenkombination STRG+ALT+R. Im Environment-Feld werden die erstellten Variablen und deren Inhalt angezeigt.
Der Arbeitspfad wird mit Kommando "getwd()" abgerufen und kann mit dem Kommando "setwd()" auf einen Ordner gesetzt werden, dessen Inhalt dann unter "Files" angezeigt wird. Der Pfad darf keine Backslashs enthalten, sondern nur Slashs.

Hinweis:
Mit dem folgenden Befehlen wird die Arbeitsumgebung (Environment) und die Konsole geleert.

 rm(list = ls()) # Leere Arbeitsumgebung 
 cat("\014") # Leere Konsole 

Die Konsole kann auch durch mit der Tastenkombination STRG+L geleert werden, dazu muss der Cursor auf der Konsole liegen.

Verwendete Funktionen

rm(list = ls())

cat("\014")

3 R-Projekt erstellen

Zunächst wird in RStudio mit File > New Project ein neues Projekt "DemoR1" angelegt, das alle Skripte und Daten zu Demo-R1 enthalten wird.
Beim Anlegen des neuen Projektes erstellt RStudio den Ordner C:\R\DemoR1, der als Arbeitsverzeichnis für die neue Demo genutzt wird. Das Arbeiten mit Projekten in RStudio hat verschiedene Vorteile, z.B. können Projekt-Templates (Directory, R Package, Shiny Web Applications) verwendet werden, auch die Versionskontrolle und damit kollaboratives Arbeiten wird über Projekte unterstützt. Weiterhin wird durch das Anlegen eines Projektes das Arbeits­verzeichnis automatisch auf das aktive Projekt gesetzt und der Pfad zum Arbeitsverzeichnis muss nicht explizit im Skript mit setwd gesetzt werden.

Die Struktur des DemoR1-Projektes sieht nach Erstellen des "HelloWorld"-Skriptes wie abgebildet aus.

Struktur des Skripts demoR1_teil1.R

Der Quellcode dieser Demo und die bereits ausgeführten ersten Codezeilen werden in einem R-Skript namens demoR1_teil1 gespeichert. Das Skript wird wie oben beim HelloWorld-Skript beschrieben erstellt und ist in Sektionen unterteilt. Wir gliedern das R-Skript demoR1_teil1.R in zehn Abschnitte, die den Abschnitten in diesem Tutorial entsprechen, dies macht den Code übersichtlicher.

Ein Abschnitt­/eine Sektion kann in RStudio mit Code > Insert Section eingefügt werden, oder auch einfach, indem man einen benannten Kommentar einfügt, der von mindestens 4 Symbolen desselben Typs gefolgt wird, und erzeugt ein einklappbares und separat ausführbares Code-Fragment, das mit dem Tastenkürzel STRG+ALT+T ausgeführt wird, wenn der Cursor auf der Sektion liegt.

Der R-Code der einzelnen Sektionen wird in den folgenden Abschnitten dieses Tutorials beschrieben und kann an den mit TODO gekennzeichneten Stellen eingefügt werden.

# Demo R1: R-Tutorial - Teil 1 ----

# Dieses Tutorial bietet einen Einstieg 
# in die Syntax und Funktionalität
# der Programmiersprache R und ist 
# gegliedert in die Abschnitte:
#
# 1. Erste Codezeilen ----
# TODO: Quellcode einfügen
#
# 2. Vektoren ----
# TODO: Quellcode einfügen
#
# 3. Operationen ----
# TODO: Quellcode einfügen
#
# 4. Regelmäßige Folgen und Wiederholungen ----
# TODO: Quellcode einfügen
#
# 5. Logische Werte ----
# TODO: Quellcode einfügen
#
# 6. Missing Values ----
# TODO: Quellcode einfügen
#
# 7. Zeichen/-ketten (characters) ----
# TODO: Quellcode einfügen
#
# 8. Matrizen ----
# TODO: Quellcode einfügen
#
# 9. Datensätze/ Data Frames ----
# TODO: Quellcode einfügen
#
# 10. Externe Daten einlesen ----
# TODO: Quellcode einfügen
#

Die Gliederung des Skriptes wird über den rechten Menü-Punkt im Editor angezeigt.

Die Struktur des DemoR1-Projektes sieht nach Erstellen der Skripte wie abgebildet aus.

4 Vektoren

Vektoren sind eindimensionale Matrizen, die nur eine Spalte oder eine Zeile enthalten. Die Elemente eines Vektors können neben Zahlen auch Zeichenketten sein.
Ein Spaltenvektor ist z.B. x = c(2,4,5,6) und y = t(c(2,4,5,6)) ist ein Zeilenvektor, wobei der Befehl t() für das Transponieren, also Vertauschung von Zeilen und Spalten und umgekehrt, steht.
Die Elemente eines Vektors werden über einen Index, der bei 1 beginnt, aufgerufen, z.B. liefert x[1] das erste Element des Vektors x.

Beispiel: Vektoren verwenden
Im folgenden Beispiel werden Zeilen- und Spaltenvektoren mit unterschiedlichen Datentypen erzeugt und deren Elemente aufgerufen.

R-Skript

 # 2. Vektoren ---- 
  
 # Syntax: c(element1,element2,...) 
 # als Ausdruck: 
 c(2,4,5,6) 
 c("aber", "und", "oder", "gleich") 
 z=c(1,2,"drei","vier")  
  
 # als Zuweisung: 
 x=c(2,4,5,6) 
 worte=c("aber", "und", 
 "oder", "gleich") 
  
 # Aufruf von Teilelementen:   
 # Indizes in eckigen Klammern 
 # Achtung: Zählindex der Elemente 
 beginnt bei 1. 
 x[1] #1.Element des Vektors x 
 x[2:3] #2.-3. Element 
 x[c(1,3)] #1. und 3. Element 
 x[-2] # x ohne das 2. Element 
  
 # Element-Aufruf in umgekehrter  
Reihenfolge 
 x[3:2] #3.-2. Element  
  
 c(x,x)# hintereinanderfügen 
 von 2 mal x 

Konsolen-Output

Erläuterungen zum Code:
Zeile 1: Die Sektion mit Namen "2. Vektoren" wird erzeugt
Zeile 5, 6: die Erzeugung von Vektoren mit Zahlen oder Zeichenketten als Elementen
Zeile 7: die Erzeugung eines Vektors mit Zahlen und Zeichenketten als Elementen und Speicherung unter dem Namen z
Zeile 10, 11, 12: die Erzeugung von Vektoren und Speicherung unter einem Variablennamen
Zeile 18-21: Aufrufe von einzelnen Elementen des Vektors x mittels Indexaufruf oder Weglassen eines Elementes mit "-Indexnr."
Zeile 25: Elementaufruf in umgekehrter Reihenfolge
Zeile 27: Der Vektor x wird 2mal hintereinander zusammengefügt.

5 Operationen

In R werden alle Vektoroperationen standardmäßig elementweise ausgeführt. Dies beruht auf der Anwendung von R zur Lösung statistischer Fragestellungen. Die Vektoren stellen dabei Beobachtungen aus Datensätzen dar, auf denen elementweise Operationen ausgeführt werden. Die Regelung mit elementweisen Operationen als Standardausführung gilt auch für Matrizen, da diese einem Zusammenfügen von Beobachtungen zu einem Datensatz entsprechen.

R-Skript

 # 3. Operationen ----
 # Verknüpfungen: +,-,*,/,^ :
 # bei Einzelwerten:
 z=2
 z+2;z-2;z^2;z/3;z*4;
 
 # bei Vektoren:
 # elementweise Rechenoperationen
 x=c(2,4,5,6)
 x^2; x-2; x/2; x^0.5;
 
 y=c(1,1,1,1)
 x-y; x+y; x*y;
 
 # Ergebnis speichern
 z=x-y

Konsolen-Output

Erläuterungen zum Code:
Zeile 4: eine Variable z mit dem Wert 2 wird erzeugt
Zeile 5: Operationen werden auf die Variable angewandt
Zeile 10: elementweise (default) Operationen werden auf den Vektor x angewandt
Zeile 13: die Vektoren x und y werden subtrahiert, addiert und multipliziert, dies erfolgt elementweise.
Zeile 16: das Ergebnis der Subtraktion wird unter dem Namen z gespeichert.

Funktionen aus dem base-Paket

Die R-Standardbibliothek (base-Paket) enthält eine Vielzahl vordefinierter statistischer Funktionen, die auf Vektoren angewandt werden können. Dazu gehören Funktionen für Minimum, Maximum, Länge und auch speziell für die Datenanalyse interessante Kennzahlen, wie der Mittelwert, der Median oder die Quantile usw. Mit dem Befehl library(help = "base") werden alle Funktionen dieses Paketes angezeigt. Eine Auswahl der zur Verfügung stehenden Funktionen ist im fogenden Quellcode enthalten.
Die summary()-Funktion liefert abhängig vom übergebenen Objekt verschiedene für das Objekt interessante Kennzahl-Übersichten. Bei Vektoren liefert summary() verschiedene Lagekennzahlen, das Minimum, das Maximum und den Mittelwert. Es ist ratsam, auf im Quellcode erzeugte Objekte oder Modelle die summary()-Funktion anzuwenden, um erste Informationen über die Objekte oder Modelle zu erhalten.

R-Skript	Output
# R-Funktionen auf # Vektoren anwenden: x=c(2,4,5,6) x=c(0,x) length(x) min(x) max(x) sum(x) exp(x) log(x) sin(x) var(x) sort(x) mean(x) summary(x)

6 Sequenzen und Wiederholungen

Bei der Entwicklung statistischer Anwendungen benötigt man oft regelmäßige Folgen (engl. sequences) oder Wiederholungen (engl. repetitions) von Werten, z.B. die Sequenz 2,4,6,8,10 der geraden Zahlen, die kleiner sind als 10, oder 1,1,1,1 als viermalige Wiederholung der Zahl 1. R bietet die Möglichkeit, auf einfache und schnelle Weise Sequenzen mit Hilfe der Funktion seq() und Wiederholungen mit Hilfe der Funktion rep() zu erzeugen. Mit Hilfe von seq(2, 10, by=2) wird z.B. die Sequenz der Zahlen mit Anfangswert 2, Endwert 10 und Schrittweite 2 erzeugt.

Beispiel: Sequenzen erzeugen
Das Beispiel zeigt, wie regelmäßige Zahlenfolgen erzeugt werden, entweder mit Hilfe des :-Operators, oder mit Hilfe der der Funktion seq().

R-Skript	Output
# 4. Regelmäßige Folgen # Sequenzen: Syntax: 1:10 #oder: seq(1,10) #liefert denselben Vektor #seq mit anderen Optionen: seq(1,10,by=0.5) #Schrittweite 0.5 seq(1,10,length.out=5) #äquidistante Zerlegung mit #5 Werten in [1;10] # weitere Beispiele: seq(-3,5,0.2) seq(6,1,-0.2)

Erläuterung des Codes:
Zeile 3: Erzeugung der Sequenz von Werten 1,2,...,10 mittels Kurzform ":"
Zeile 4: Erzeugung der Sequenz von Werten 1,2,...,10 mit der Sequenzfunktion. Diese ermöglicht weitere Optionen, wie Festlegung der Schrittweite oder des Endwertes.
Zeile 9: Sequenz im Bereich 1 bis 10 mit Schrittweite 0.5 erzeugen
Zeile 10: äquidistante Zerlegung mit 5 Werten in [1;10] erzeugen
Zeile 15: Sequenz im Bereich -3 bis 5 mit Schrittweite 0.2 erzeugen
Zeile 16: Sequenz im Bereich 6 bis 1 mit Schrittweite -0.2 erzeugen

Beispiel: Wiederholungen erzeugen
Das Beispiel zeigt, wie Wiederholungen mit Hilfe der Funktion rep() erzeugt werden.

R-Skript

Output

# Wiederholungen: Syntax: rep(1,4) #Output: [1] 1 1 1 1 rep(1:4,3) #Output: [1] 1 2 3 4 1 2 3 4 1 2 3 4 rep(1:4,each=3) #Output: [1] 1 1 1 2 2 2 3 3 3 4 4 4 rep(1:3,rep(4,3)) #Output: [1] 1 1 1 1 2 2 2 2 3 3 3 3 rep(1:4, c(2,1,2,1)) #Output: [1] 1 1 2 3 3 4 #Berechnet sin(0), sin(pi/18), sin(2*pi/18),...,sin(36*pi/18): #0,10,20,...,360 in Grad c=0:36 round(sin(c*pi/18),2) #round(x,2) rundet Werte in x #auf 2 Nachkommastellen

Erläuterungen zum Code:
Zeile 2: der Wert 1 wird 4 mal wiederholt.
Zeile 4: der Vektor (1,2,3,4) wird 3 mal wiederholt
Zeile 7: jedes Element des Vektors (1,2,3,4) wird 3 mal wiederholt
Zeile 10: geschachtelte Wiederholung: jedes Element des Vektors (1,2,3) wird 4 mal wiederholt
Zeile 13: das erste und dritte Element des Vektors (1,2,3,4) wird 2 mal wiederholt, die anderen einmal.
Zeile 19, 20: Rechenoperationen wie sin(), Multiplikation mit PI und Division durch 18 werden elementweise auf die Sequenz 0,1,2,..,36 angewandt, danach wird das Ergebnis auf 2 Nachkommastellen gerundet mit round(... ,2).

7 Logische Werte und fehlende Werte

Logische Werte

Die logischen Werte TRUE und FALSE sind das Ergebnis logischer Operationen, wie sie bei der Auswertung von Bedingungen auftreten. Z.B. ergibt die Auswertung von 3 < 4 den logischen Wert TRUE und die Auswertung von 3 == 4 ergibt FALSE. Logische Werte spielen bei der Extraktion von Beobachtungen aus Datensätzen eine wichtige Rolle.

Beispiel: Extrahiere Werte aus Daten mittels Bedingungen

Es werden Größen- und Gewichts-Daten als Sequenzen erzeugt. Aus diesen Daten werden über einzelne oder verknüpfte Bedingungen (&-Operator) Werte extrahiert. Mit der which()-Funktion kann der Index abgefragt werden, an dem eine bestimmt Bedingung erfüllt ist. Dieser Index wird dann zur Extraktion des maximalen Gewichts, verwendet.

R-Skript

Output

# TRUE/FALSE aus logischen Operationen 3<4; 3==4; 3!=4; 4<4; 4<=4; x=c(1,2,3,5,10) x>=5 # extrahiere Werte mittels Bedingungen groesse=170:180 gewicht=65:75 gewicht[groesse<=174 ] # Output: [1] 65 66 67 68 69 gewicht[groesse<=175 & gewicht >68 ] # Output: [1] 69 70 groesse[groesse<=175 & gewicht >68 ] # Output: [1] 174 175 # die Funktion which() zeigt, wo im # Vektor(Index) ein bestimmter # Wert vorkommt. which(gewicht==70) # Wo steht das maximale Gewicht? maxIndex=which(gewicht==max(gewicht)) gewicht[maxIndex]

Erläuterungen zum Code:
Zeile 2: Einzelwerte werden mit dem Wert 4 über verschiedene Vergleichsoperatoren (<, ==, !=, usw.) verglichen und liefern logische Werte als Ergebnis
Zeile 5: der Vektor (1,2,3,5,10) wird mittels des Vergleichsoperators >= (größer oder gleich) elementweise mit der 5 verglichen und liefert einen Vektor aus logischen Werten zurück
Zeile 8, 9: die Vektoren bestehend aus Größen und Gewichten werden als Sequenzen erzeugt: 170,171,...179,180 und 65,66,...,74,75
Zeile 11: die Elemente vom Gewichtsvektor, die an den Indexstellen ein TRUE aufweisen, werden ausgegeben. TRUE ist nur an den Stellen, an denen der Größenvektor kleiner oder gleich 174 ist.
Zeile 14: die Elemente vom Gewichtsvektor, die an den Indexstellen bei Abfrage groesse<=175 & gewicht >68 ein TRUE enthalten, werden ausgegeben.
Zeile 16: die Elemente vom Größenvektor, die an den Indexstellen bei Abfrage groesse<=175 & gewicht >68 ein TRUE enthalten, werden ausgegeben.
Zeile 22: which() gibt den Index wieder, an dessen Stelle die Bedingung gewicht==70 erfüllt ist und kann dann im nächsten Schritt weiter verwendet werden.
Zeile 25: fragt den Index mit dem maximalen Gewicht ab und
Zeile 26: gibt das Element an dieser Indexstelle aus, d.h. das maximale Gewicht.

Fehlende Werte

Fehlende Werte müssen in Datensätzen erkannt und notfalls damit umgegangen werden. Es ist wichtig, diese Stellen/Index auch in einer großen Menge von Werten schnell zu erkennen, dazu stehen Kommandos zur Verfügung. Fehlende Werte werden mit NA betitelt, d.h. Not Available/Nicht Verfügbar. Nicht definierte Rechnenoperationen liefern NaN (Not a Number) zurück.

Enthalten Vektoren NA-Werte, dann beeinflusst dies alle Operationen. Z.B. wird das Maximum dann als NA ausgegeben oder auch der Mittelwert (mean()), bevor Kennzahlen oder Operationen sinnvoll auf Vektoren angewandt werden können, müssen die NA-Werte mittels der Option na.rm=TRUE (Missing values remove= TRUE) aus der Bestimmung der Kennzahlen ausgeschlossen werden. Bei Rechenoperationen eines NA-Wertes mit einer Zahl ist das Ergebnis immer NA. Die Funktion is.na() liefert einen Vektor mit logischen Werten und TRUE an der Indexstelle, an der ein NA steht.

Beispiel: Umgang mit NA-Werten

Der erzeugte Gewichtsvektor enthält einen fehlenden Wert (NA). Bei Anwendung von Funktionen muss dieser fehlende Wert zuerst mittels der Option na.rm=TRUE ausgeschlossen werden, dann liefert die Funktionen einen sinnvollen Rückgabewert. Anstatt die Option na.rm bei Funktionsaufruf auf TRUE zu setzen, kann der Vektor Gewicht auch ohne die NA-Werte an die Funktion übergeben werden. Dazu stellt man mittels is.na() fest, wo sich die fehlenden Werte befinden (Indexangabe) oder an welchen Indexstellen eben keine fehlenden Werte zugeordnet sind (!is.na(), wobei das "!" für NICHT steht). Damit kann ein reduzierter Gewichtsvektor an die Funktion übergeben werden.

R-Skript

Output

# Symbol: NA, Not Available gewicht=c(65:68,NA,70:75) # NA als Ergebnis gewicht*2 # [1] 130 132 134 136 NA # 140 142 144 146 148 150 max(gewicht) #[1] NA max(gewicht, na.rm=TRUE) # na.rm loescht missing values #[1] 75 mean(gewicht) #[1] NA mean(gewicht, na.rm=TRUE) #[1] 70.1 #undefinierte Rechnungen #liefern NaN: Not a Number 0/0 # feststellen wo die # fehlenden Werte sind: is.na(gewicht) !is.na(gewicht) gewicht[!is.na(gewicht)] mean(gewicht[!is.na(gewicht)]) #Output: [1] 70.1 wie bereits #vorher ohne NA

8 Zeichen und Zeichenketten

Zeichen oder Zeichenketten sind nützliche Werkzeuge zum Benennen (Labeln) von Daten. Mit dem Label können Daten auch gezielt aufgerufen werden, das Label kann also wie ein Index genutzt werden. Das Zusammenfügen von einzelnen Strings, die viele gemeinsame Komponenten aufweisen und sich z.B. nur in der Stundenanzahl (siehe Beispiel) unterscheiden, ist mit der paste()-Funktion möglich.

Beispiel-Quellcode: Erzeugung von Strings und Labeling zur Extraktion von Werten

Der String "Blutdruck nach ... h" soll um die Stunden 0, 2, 4, 6 und 8 ergänzt werden. Die paste()-Funktion verknüpft dazu die Strings "Blutdruck nach" und "h" komponentenweise mit den Werten des Vektors c(0,2,4,6,8). Der Gewichtsvektor erhält mit der names()-Funktion Label für die einzelnen Komponeneten (hier: Personennamen). Damit wird das Gewicht von "Hans" gezielt extrahiert.

R-Skript	Output
gewicht=65:75 # Zusammenfügen von Zeichen/-ketten: paste("Blutdruck nach", c(0,2,4,6,8), "h", sep=" ") # names()- Funktion zur Benennung der # Elemente eines Vektors, Labeling: names(gewicht)= c("Hans", "Michael", "Maike", rep("NN",8)) gewicht gewicht["Hans"]

Erläuterungen zum Code:
Zeile 1: der Gewichtsvektor wird als Sequenz erstellt
Zeile 4, 5: mit der paste()-Funktion werden der String "Blutdruck nach" mit dem Vektor (0,2,4,6,8) und dem Zeichen "h" verbunden, die Trennung zwischen den Komponenten soll das Leerzeichen sein (sep=" "). Jedes Element des Vektors wird mit dem vorderen String und dem hinteren Zeichen verknüpft, also erfolgt eine Ausgabe von 5 Strings.
Zeile 10, 11: die names()-Funktion vergibt für die Elemente des Vektors gewicht Label/Namen, d.h. 3 Namen und 8 mal den String NN. In Zeile 13 wird das Label "Hans" benutzt um das Element mit diesem Label aus dem Gewichtsvektor auszugeben.

9 Matrizen

Arrays sind mehrdimensionale Verallgemeinerungen von Vektoren, deren Elemente durch zwei oder mehr Indizes indiziert werden können. Arrays in R werden mit der Funktion array(data, dim = dim_vector) erstellt. Die Anweisung array(1:24, dim=c(3,4,2)) erstellt beispielsweise ein Array mit den Dimensionen 2x3x4, das mit den Zahlen von 1 bis 24 gefüllt ist. Am häufigsten benötigen wir einen Sonderfall von Arrays, nämlich zweidimensionale Matrizen zur Darstellung tabellarischer Daten. Informell kann eine Matrix als eine Sammlung von Elementen desselben Datentyps betrachtet werden, die in einem zweidimensionalen rechteckigen Layout angeordnet sind. Matrizen in R werden mithilfe der Funktion matrix(data, nrow, ncol) oder durch Kombinieren von Vektoren mithilfe der Funktionen cbind und rbind oder auch einfach mittels von Schleifen erstellt.

Erstellung von Matrizen in R
Die Syntax zur Erstellung einer Matrix lautet: matrix(data, nrow, ncol). Die matrix()-Funktion wird aufgerufen und die Daten, die in der Matrix stehen sollen, und die weiteren Parameter nrow (Zeilenanzahl) und ncol (Spaltenanzahl) werden übergeben. Das Grundgerüst der (nrow x ncol)-Matrix wird spaltenweise mit den Daten gefüllt. Wenn zeilenweise gefüllt werden soll, muss der Parameter byrow auf TRUE gesetzt werden.

R-Skript	Output
## Matrizen erstellen ---- # 2x3 Matrix spaltenweise erstellen a=matrix(c(1, 4, 9, 16, 25, 36), 2, 3); a # 2x3 Matrix zeilenweise erstellen a=matrix(c(1, 4, 9, 16, 25, 36), 2, 3, byrow=TRUE); a # 2x3 Matrix spaltenweise erstellen # mit recycling der Werte names = list(c("r1","r2"), c("c1", "c2", "c3")) a=matrix(c(1, 4, 9), 2, 3, dimnames = names); a

Erstellung von Matrizen mit rbind und cbind
Die Funktionen rbind() und cbind() bieten die Möglichkeit, Vektoren/Daten zeilen- oder spaltenweise aneinander zu fügen. Dabei muss die Länge der zu verknüpfenden Vektoren gleich sein. Die verknüpften Zeilen bzw. Spalten erhalten die Vektornamen als Label. Diese Labels können dazu verwendet werden, um Teilelemente zu extrahieren.

Beispiel-Quellcode: Verwendung von rbind() und cbind()

Zeile 3: Die Funktion rbind() fügt Gewichts- und Größenvektor zeilenweise zusammen, das Ergebnis ist eine Tabelle mit zwei Zeilen. Zeile 4: Die Funktion cbind() fügt Gewichts- und Größenvektor spaltenweise zusammen, das Ergebnis ist eine Tabelle mit zwei Spalten.

R-Skript	Output
groesse=170:180 gewicht=65:75 rbind(groesse, gewicht) z=cbind(groesse, gewicht) z

Extraktion von Elementen aus Matrizen
Durch Angabe des Zeilen- und Spaltenindex können einzelne Elemente oder Teilmatrizen extrahiert werden. Die Index-Angabe erfolgt in eckigen Klammern: [Zeilenangabe, Spaltenangabe]. Ein leerer Index steht dabei für alle Elemente aus dieser Zeile oder Spalte, d.h. a[ , ] liefert die gesamte Matrix a als Ausgabe.
Hinweis: In MATLAB erfolgt die Angabe mit runden Klammern: (Zeilenangabe, Spaltenangabe).

Beispiel-Quellcode: Extraktion von Elementen oder Teilmatrizen

Durch die Indexangabe mittels [Zeilenangabe, Spaltenangabe] werden aus der Matrix a=matrix(1:12,3,4) gezielt Elemente oder Teilmatrizen extrahiert.

R-Skript	Output
#Extraktion einzelner Elemente: a[1,4] # Submatrizen: mit # [Zeilenangabe, Spaltenangabe] a[1:2,2:3] a[3,] #liefert nur die 3.Zeile mit # allen Spalten, # leerer Index steht für "alles" a[,2] #liefert nur die 2.Spalte # mit allen Zeilen

Extraktion von Elementen aus Matrizen mit Labeln
Durch Angabe der Bedingung für eines der Labels oder eine logische Verknüpfung von Bedingungen mehrerer Labels erfolgt eine Extraktion von Teilmatrizen. Dabei stehen die Bedingungen an erster Stelle des Indexaufrufs, danach folgt ein Leerzeichen im 2. Indexaufruf: [Bedingung(en), ].

Beispiel-Quellcode: Extraktion von Elementen mittels Labels

Aus der Matrix z = cbind (groesse, gewicht) werden über Bedingungen an die Label groesse und gewicht gezielt Teilmatrizen extrahiert, nämlich diejenigen Zeilen, bei denen die Größe kleiner gleich 175 ist, bzw. diejenigen Zeilen, bei denen Größe kleiner gleich 175 und Gewicht größer als 68 ist.

R-Skript	Output
# Extraktion aus Matrix: z[groesse<=175 ,] z[groesse<=175 & gewicht >68, ]

Matrixoperationen

In R werden alle Matrixoperationen standardmäßig elementweise ausgeführt, dies beruht auf der Anwendung von R zur Lösung statistischer Fragestellungen. Die Zeilen stellen dabei Beobachtungen und die Spalten die Merkmale/Variablen aus Datensätzen dar.
Es können Rechenoperationen auf Matrizen angewandt werden, diese werden elementweise ausgeführt. Die Transponierte wird mit der t()-Funktion erzeugt (MATLAB: A', Anführungszeichen als Transposition) und die bekannte Matrixmultiplikation wird in R mit "%*%" durchgeführt.
Hinweis: In MATLAB wird der Schwerpunkt auf die Matrixmultiplikation gelegt, d.h. A*B führt die Matrixmultiplikation aus. Wenn man in MATLAB elementweise multiplizieren möchte, muss das explizit mit dem "." ausgewiesen werden (MATLAB: A.*B).

Beispiel-Quellcode

R-Skript	Output
c=matrix(1:6,2,3) d=3*c c;d;d+c;d-c;d*c;d/c,d^c t(c) #liefert die Transponierte # von Matrix c # Matrixmultiplikation mit Zeichen %*% x=c(1,2,2) #Spaltenvektor x c%*%x # Matrixmultiplikation: c*c^T in R: c%*%t(c)

Weitere nützliche Funktionen für Matrizen
In R stehen weitere nützliche Funktionen für Standardfragen zu Matrizen zur Verfügung. Diese sind z.B. in dem R-Paket base enthalten. Mit der diag()-Funktion wird bei Übergabe einer quadratischen Matrix als Rückgabewert deren Diagonale ausgegeben bzw. bei Übergabe eines Vektors eine Diagonalmatrix mit dem Vektor als Diagonale erzeugt. Die Funktion nrow() bzw. ncol() geben die Zeilen- bzw. Spaltenanzahl zurück, dim() liefert die Dimension der Matrix, also zwei Werte zurück und mit der Funktion eigen() werden die Eigenwerte und -vektoren quadratischer Matrizen bestimmt.

Durch Eingabe von library(help = "base") in die Konsole wird eine Übersicht aller Funktionen des Paketes base geöffnet.

R-Skript

Output

# nützliche Funktionen für Matrizen: z=matrix(c(1,2,3,4),2,2, byrow=TRUE) t(Z) diag(z) #Diagonale, wenn z # quadratisch nrow(z) # Anzahl der Zeilen ncol(z) # Anzahl der Spalten dim(z) # Dimension rowMeans(z) # Zeilenmittelwerte colMeans(z) #Spaltenmittelwerte solve(z) # Inverse einer # quadratischen Matrix eigen(z) # Eigenwerte und -vektoren # quadratischer Matrizen eigen(z)$values #nur Eigenwerte eigen(z)$vectors #nur Eigenvektoren # Diagonalmatrizen erzeugen: diag(4) #liefert 4x4-Einheitsmarix diag(c(1,2,3))

10 Datensätze und das Einlesen von Daten

Daten werden in einer Rechteckmatrix aus Beobachtungen (Zeilen) und Merkmalen/Variablen (Spalten) dargestellt. Hierbei können verschiedene Variablentypen in den Spalten enthalten sein. Der Name eines Datensatzes beginnt standardmäßig mit einem Großbuchstaben. Zur Erstellung eines Datensatzes wird die data.frame-Funktion des base-Paketes verwendet. Mit

# Vektoren als Elemente von Datensätzen  
  
name=c("Lisa", "Norman", "Tilla")  
punkte=c(86,70, 87)  
bestanden=c(rep("ja",3))

werden drei Vektoren erzeugt, die die Spalten des Datensatzes bilden sollen. Diese drei Vektoren werden mit dem minimal Aufruf der data.frame-Funktion zu einem Datensatz names "Klausur1" zusammengefügt

Klausur1=data.frame(name, punkte, bestanden)

und liefern die bei Aufruf des Datensatzes in der Konsole die Ausgabe

Die Vektornamen wurden bei der Erzeugung des Datensatzes als Spaltennamen übernommen. Die Beobachtungen­/Zeilen werden durchnummeriert.

In der Arbeitsumgebung (Environment-Tab) ist ein Datensatz an dem Dreieck-Symbol zu erkennen, bei Doppelklick auf das data.frame-Objekt in der Umgebungsliste wird der Datensatz in einem Tab im Editor geöffnet:

Der data.frame-Funktion können Parameter übergeben werden, mit dem row.names-Parameter werden die Zeilennamen angepasst. Im Beispiel wird ein Vektor mit den Zeichenketten Student1, Student2 und Student3 als Zeilen- bzw. Beobachtungsnamen übergeben

 
Klausur1=data.frame(name, punkte, bestanden,
  row.names = c("Student1", "Student2", "Student3"))

Die Zeilennamen des Datensatzes sehen damit wie folgt aus:

Ein weiterer nützlicher Parameter beim Aufruf der data.frame-Funktion ist der stringsAsFactors-Parameter, damit werden Zeichenketten direkt in Faktoren mit Levels (deutsch Kategorien) umgewandelt. Dies ist für die weitere Verwendung der Daten hilfreich. Mit

Klausur1=data.frame(name, punkte, bestanden,
  row.names = c("Student1", "Student2", "Student3"))
  stringsAsFactors = TRUE)

erfolgt die Umwandlung der Strings in Faktoren, deren Typ mit der is.factor-Funktion des base-Paketes überprüft werden kann.

Matrizen in Datensätze umwandeln

Ein einfacher Weg einen Datensatz zu erzeugen, ist eine schon vorhandene Matrix in einen Datensatz umzuwandeln, dies ist ebenfalls mit der data.frame()-Funktion möglich. Das Datensatz-Objekt hat viele Eigenschaften und Operationen mit Matrizen gemeinsam, aber nicht alle, die Matrixmultiplikation führt bei Umwandlung in einen Datensatz zu einem Fehler. Die as.matrix()-Funktion schafft dort Abhilfe und wandelt den Datensatz wieder in eine Matrix um. Die Darstellung eines Datensatzes unterscheidet sich bei Aufruf und Ausgabe in der Konsole auch von Matrizen, die Zeilen- und Spaltenangabe fällt weg, stattdessen erfolgt ein Labeling der Spalten/Variablen mit X1,X2,..

R-Skript	Output
a=matrix(c(1:12),3,4) a A.dframe=data.frame(a) A.dframe A.dframe %*% 1:4 #Fehler! as.matrix(A.dframe) %*% 1:4

Label vergeben oder umbenennen
Manchmal ist es sinnvoll, auch den Beobachtungen Labels zu geben, dies kann mit der row.names()-Funktion bei der Erstellung der Matrix oder nachträglich erfolgen. Mit der Funktion names() werden die Namen von Objekten ausgelesen oder gesetzt. D.h. die Variablen in Datensätzen können auch nachträglich mit der names()-Funktion umbenannt werden. Die paste()-Funktion zum Verketten von Vektoren, die dabei in Strings umgewandelt werden, ist an dieser Stelle wieder sinnvoll einsetzbar.

R-Skript	Output
# Zeilenname # beim Erzeugen des Datensatzes A.dframe=data.frame(a, row.names=c("A","B","C")) A.dframe # Variablen umbenennen: names(A.dframe) names(A.dframe)=paste('Variable',1:4) names(A.dframe) A.dframe

Objekttyp abfragen
Mit der Funktion is.data.frame() wird abgefragt, ob das übergebene Objekt ein DataFrame ist, hier: TRUE. Mit class() wird die Klasse eines Objektes abgefragt, hier: data.frame.

R-Skript	Output
# Objekttyp abfragen is.data.frame(A.dframe) class(A.dframe)"

Variablen oder Beobachtungen extrahieren
Durch den Datentyp data.frame können speziell Variablen mit dem $-Zeichen extrahiert werden, z.B. gibt A.dframe$"Variable 4" die Werte der Variablen 4 aus, dazu wird also das Label der jeweiligen Spalte/Variablen benutzt. Um Beobachtungen abzurufen, kann auch die klassische Extraktionsweise von Matrizen genutzt werden, mit Zeilen- und Spaltenaufruf in eckigen Klammern.

R-Skript	Output
# einzelne Variablen abrufen: # mit $-Zeichen A.dframe$"Variable 4" # mit $SpaltenName # oder wie bei Matrizen: A.dframe[,4] A.dframe[,"Variable 4"] # Spaltenaufruf über Variablenname A.dframe["A",] # Zeilenaufruf "A" A.dframe["A",-2] # Zeilenaufruf "A" # ohne 2.Variable/Spalte

Teildatensätze extrahieren oder neue Variablen einfügen
Durch die subset(x, Bedingung für x)-Funktion können gezielt Teildatensätze mittels einer Bedingung an die Variablen erstellt werden. Diese Funktion ist auch auf Vektoren und Matrizen anwendbar. Zum Einfügen neuer Variablen und Beobachtungen stehen die Funktionen cbind() und rbind() zur Verfügung, die entweder spalten- oder zeilenweise Teile von Matrizen, Vektoren oder Datensätzen kombinieren.

R-Skript

 Subset1=subset(A.dframe, 
   A.dframe$"Variable 1" >= 2)
 Subset1
 
 #neue Variablen einfügen:
 A.dframe=cbind(A.dframe, 
   geschlecht=c("w","m", "m"))
 
 #neue Beobachtungen einfügen:
 A.dframe=rbind(A.dframe, 
   list(5,5,5,5, "w"))
 
 row.names(A.dframe)=
    c("A", "B", "C", "D")
 A.dframe

Konsolen-Output

Externe Daten einlesen
Die Funktion read.table aus dem utils-Paket erzeugt automatisch einen Datensatz mit Format data.frame bei Einlesen einer Standard-Datei, die die folgende Tabellen-Form hat:

Wenn dieses Format nicht vorliegt, müssen Optionen bei der read.table()-Funktion eingegeben werden, z.B. header, col.names, row.names, siehe die folgende Kursdaten00.txt-Datei:

Diese wird mit dem Befehl

read.table("Kursdaten00.txt",col.names=c(...)) 

eingelesen, wobei nach Übergabe des Dateinames, der hier im gleichen Ordner wie das aktuell verwendete R-Skript liegt bzw. im Projekt-Ordner von Demo R1 abgelegt ist, der Option col.names() die Variablennamen als Vektor übergeben werden müssen. Dabei muss die Anzahl der Variablen in der einzulesenden Datei bekannt sein und es muss eine übereinstimmende Anzahl von Elementen im Names-Vektor (=c(..)) vorhanden sein.

Andere Optionen können das Separationszeichen "sep" oder auch das Überspringen von Zeilen am Anfang mit "skip" sein:

• sep="" default: eine oder mehrere Leerzeichen
• sep=",": Komma als Trenner von Beobachtungen
• skip= : Zeilen am Anfang überspringen

Beim Einlesen der Daten muss der Arbeitspfad richtig gesetzt sein oder ein R-Projekt geöffnet sein und die Daten sich dann im gleichen Ordner bzw. Projekt wie das verwendete R-Skript befinden, dann muss nur der Name der Datei genannt werden. Es kann aber auch ein Dateipfad beim Aufruf von read.table() angegeben werden.

R-Skript	Output
read.table("StandardData.txt") Kurs=read.table("Kursdaten00.txt", col.names=c("Alter", "Geschlecht", "Groesse", "Textverarb", "Matlab", "Python", "R", "AndereProg")) Kurs

Bezugsdatensatz festlegen/entfernen: attach/detach
Die Funktionen attach() und detach() erlauben einen Datensatz oder ein Listen-Objekt als Suchpfad, also als Bezugsdatensatz festzulegen, dabei wird bei Aufruf einer Variablen direkt in dem vorher durch attach() als Suchpfad festgelegten Objekt nach der Variablen gesucht. D.h. der Variablenaufruf des Bezugsdatensatz kann ohne das $-Zeichen erfolgen. Mit detach wird dieser Suchpfad bzw. der Bezugsdatensatz oder die Bezugsliste wieder entfernt.

R-Skript	Output
attach(Kurs) Alter; Matlab; R; # Aufruf der Variablen # ohne Kurs$VariablenName detach() # Wichtig: entferne Kurs als # Bezugs-Datensatz Alter # Fehler! Da kein Bezugsdaten- # satz mehr vorhanden.

R vs. Python und MATLAB

R grenzt sich von allgemeinen Programmiersprachen wie C oder Java durch speziell für die Statistik entworfene Datenstrukturen und Funktionen sowie darauf bezogene Möglichkeiten der Grafikerzeugung ab. Es gibt eine Vielzahl von R-Paketen für statistische Aufgabenstellungen, dazu gehören: stats – für statistische Funktionen, graphics und ggplot2 – für statistische Visualisierungen, caret – für Klassifikation und Regression.

R wird, wie Python und MATLAB, auch für die Entwicklung von Anwendungen im Bereich des Maschinellen Lernens verwendet, um z.B. im Rahmen der Vorausschauenden Wartung Prognosen oder Clusteranalysen zu erstellen. Die drei Sprachen bieten zum Teil ähnliche Funktionalität (Bibliotheken für statistische Probleme, ausgefeilte Grafik- und Visualisierungsmodule), wobei jede ihre Stärken und Schwächen hat. Während R auf statistische Programmierung spezialisiert ist, ist MATLAB allgemeiner auf mathematische Problemstellungen ausgelegt. Python hingegen ist eine Programmiersprache, die um statistische Programmbibliotheken erweitert wurde.
Die Gemeinsamkeiten und Unterschiede in der Syntax und Verwendung werden in diesem Tutorial hervorgehoben, um Wechslern den Einstieg in R zu erleichtern.

Autoren, Tools und Quellen