Eigenschaften von R und Vorbereitungen

Um R-Programme schreiben und ausführen zu können, sind einige Vorbereitungen nötig: Installation von R, Installation einer Entwicklungsumgebung, Anlegen und Strukturierung eines Arbeitsverzeichnisses. Diese Vorbereitungen und kleine erste Programme werden für den Programmier-Einsteiger erläutert. Weiter werden viele Hinweise gegeben, wie man sich das Arbeiten mit R erleichtern kann.

walter
R-Skript RStudio R (Programmiersprache) HelloWorld (R) Helferlein Installation RGui
Inhaltsverzeichnis

Einordnung des Artikels

Eigenschaften von R

Die folgende Liste gibt einen kurzen Überblick über die wichtigsten Eigenschaften der Programmiersprache R:

1. Interpreter-Sprache

Die Befehle können zeilenweise in die Konsole eingegeben werden. Falls sie syntaktisch korrekt sind, werden sie sofort ausgeführt.

Es wird also kein Compiler verwendet, der immer ein Programm als Ganzes zuerst auf syntaktische Korrektheit prüft und dann den ausführbaren Maschinencode erzeugt. Beispiele für Programmiersprachen, die compiliert werden, sind C++ oder Java.

2. Skripte: .R-Dateien

Die einzelnen Befehlszeilen können zusammengefasst und als Datei abgespeichert werden — sie werden meist als Skripte bezeichnet. Dies sind dann eigentlich Textdateien (die mit der Datei-Endung .R abgespeichert werden); man kann sie wie Programme als Ganzes abarbeiten lassen (Stapel- oder batch-Betrieb).

Gerade bei komplexen Berechnungen ist diese Vorgehensweise zu empfehlen: Oft können diese Dateien — mit kleinen Variationen — wiederverwendet werden. Oder sie können zum Nachschlagen von komplizierten Konstrukten verwendet werden.

3. R ist objekt-orientiert und funktional

Die Sprache R erfüllt sowohl das objekt-orientierte als auch das funktionale Programmier-Paradigma. Salopp gesagt, lassen sich eigene, beliebig komplexe Datenstrukturen und Funktionen entwickeln. Was genau mit den Begriffen objekt-orientiert und funktional gemeint ist, wird sich erst im Lauf der Zeit erschließen.

Im Zusammenhang mit der Sprache R wird oftmals die Sprache S erwähnt: S ist die ältere Sprache, die rein funktional ist. R ist eine — von vielen — Erweiterungen von S.

4. Pakete

Die Installation von R beinhaltet schon mehrere Pakete, die alle für den Einsteiger wichtigen Funktionalitäten bereitstellen. Es lassen sich aber — zu allen nur denkbaren Themen — weitere Pakete nachträglich installieren.

5. Schnittstellen

Um Daten zu verarbeiten, können sie aus zahlreichen anderen Dateiformaten gelesen werden und Ergebnisse dorthin exportiert werden. Manche Dateiformate sind mit den Standard-Paketen zugänglich, für manche müssen erst Pakete installiert werden. Um einige Beispiele zu nennen:

Graphiken können aus einem R-Programm heraus in zahlreichen Dateiformaten erstellt werden.

Es gibt sogar Pakete, die es erlauben Schnittstellen zu anderen Programmiersprachen herzustellen, so dass Quellcodes aus anderen Sprachen genutzt werden können. Auch die Umkehrung ist möglich: R-Skripte können aus vielen Programmiersprachen heraus genutzt werden.

6. Data Science

Die bisher genannten Eigenschaften von R können womöglich noch nicht bei einer Entscheidung helfen, warum man gerade R als Programmiersprache auswählen soll und nicht etwa eine weit verbreitete Sprache wie C++ oder Java. Der große Vorteil von R ist, dass gerade für die Auswertung von Datensätzen, also Listen oder Vektoren von Zahlen — wie man sie in der Statistik andauernd benötigt — zahlreiche Operationen vorbereitet sind — und zwar von kleinen Hilfsfunktionen bis zu komplexen Auswertungen. Möchte man sich beim Programmieren auf die mathematischen Konzepte konzentrieren, wird man mit R sehr viel schneller produktiv arbeiten können als mit anderen Sprachen.

Um einige dieser Eigenschaften zu demonstrieren, soll eine kleine Beispiel-Anwendung vorgeführt werden. Sie müssen die Syntax jetzt noch nicht verstehen, Sie werden aber sehen, dass sie nicht schwer ist — man muss nur die Vokabeln beherrschen, aber dafür gibt es die Dokumentation. Weiter werden Zufallszahlen verwendet, so dass die Anwendung bei mehrfacher Ausführung andere Ergebnisse liefern wird. Wer schon mit einer Programmiersprache vertraut ist, wird sogar an diesem kleinen Beispiel ablesen können, in welchem Stil Programme mit R geschrieben werden, auf welche Funktionalitäten man sofort zugreifen kann und welche Arbeiten man selber zu erledigen hat.

Verwendet wird folgendes kleines Skript (die Befehle sind in den Kommentaren kurz erläutert; der Pfeil ist der Zuweisungs-Operator):

# Beispielanwendung: Erzeugen von Messdaten, statistische Auswertung der Messdaten

x <- (1:20)         # x = (1,2,...,19,20)
y <- x + rnorm(20)  # Addition einer Zufallszahl zu jedem x-Wert; Zufallszahl gemäß der Standard-Normalverteilung
x                   # Ausgabe von x

mean(x)             # Ausgabe des Mittelwertes von x
var(x)              # Ausgabe der Varianz von x

y                   # Ausgabe von y
mean(y)             # Ausgabe des Mittelwertes von y
var(y)              # Ausgabe der Varianz von y

plot(x,y,"p")       # Graphische Darstellung der Messpunkte

cor(x,y)            # Ausgabe des Korrelationskoeffizienten von x und y

Lässt man dieses Skript auf der Konsole ausführen, erhält man folgende Ausgaben und Abbildung 1:

> # Beispielanwendung: Erzeugen von Messdaten, statistische Auswertung der Messdaten

> x <- (1:20)           # x = (1,2,...,19,20)
> y <- x + rnorm(20)    # Addition einer Zufallszahl zu jedem x-Wert; Zufallszahl gemäß der Standard-Normalverteilung
> x                     # Ausgabe von x
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20
 
> mean(x)               # Ausgabe des Mittelwertes von x
[1] 10.5
> var(x)                # Ausgabe der Varianz von x
[1] 35

> y                     # Ausgabe von y
 [1]  0.6862987  2.4257763  3.8215357  3.4012362  5.2611641  6.2854739
 [7]  7.7347110  6.9532800  9.2239397 10.2637562 12.0485816 13.7849407
[13] 10.8270957 13.7493985 13.4560655 16.4979276 15.5527171 17.8185621
[19] 17.2762391 20.5077164
> mean(y)               # Ausgabe des Mittelwertes von y
[1] 10.37882
> var(y)                # Ausgabe der Varianz von y
[1] 32.47639

> plot(x,y,"p")         # Graphische Darstellung der Messpunkte

> cor(x,y)              # Ausgabe des Korrelationskoeffizienten von x und y
[1] 0.9851029

Abbildung 1: Graphische Darstellung der im Skript erzeugten Messpunkte.Abbildung 1: Graphische Darstellung der im Skript erzeugten Messpunkte.

Installation von R

The R Project for Statistical Computing

Unter der URL

https://www.r-project.org/

findet man The R Project for Statistical Computing.

Der erste Schritt zum Arbeiten mit R ist immer von dort R zu laden und zu installieren. Vor allem wenn Sie mit einer anderen Entwicklungsumgebung arbeiten wollen, sollten Sie zuerst R installieren.

Aufgabe:

1. Installieren Sie R von oben genannter URL.

2. Starten Sie das Programm und öffnen Sie den Ordner, in dem R installiert wurde.

3. Unten folgt eine Liste der Bestandteile von R. Versuchen Sie diese im Programm und im Installations-Ordner zu identifizieren.

Die Installation beinhaltet:

  1. Eine graphische Oberfläche RGui, die nicht mit einer professionellen Entwicklungsumgebung vergleichbar ist, aber für einen Anfänger ausreichen sollte.
  2. Eine Konsole, in die R-Befehle eingegeben und (Interpreter!) sofort ausgeführt werden können.
  3. Zahlreiche Dokumentationen, insbesondere An Introduction to R und R Reference werden Sie zu Beginn häufig nutzen.
  4. Eine library mit vorinstallierten Paketen.
  5. Beispiel-Dateien, also vorbereitete R-Skripte, die man hervorragend als Vorlagen verwenden kann.

Vorbereitung: Anlegen eines Arbeitsverzeichnisses (working directory)

Tips:

1. Installieren Sie einen reinen Text-Editor wie Notepad++ (Word ist kein Text-Editor!). Sie werden in Zukunft mit zahlreichen Dateiformaten konfrontiert, die aber meist Textdateien sind und in die man oft einen kurzen Blick werfen muss. Ein Text-Editor wie Notepad kommt mit zahlreichen Dateiformaten zurecht und bietet Syntax-Highlighting, was das Lesen erleichtert.

2. Stellen Sie Ihren Datei-Explorer so ein, dass die Datei-Endungen sichtbar sind. Programmieren heißt immer mit unterschiedlichen Dateiformaten zu arbeiten, die man schnell erkennen möchte.

Aufgabe:

Bevor Sie zum ersten Mal mit R arbeiten: Legen Sie sich ein Arbeitsverzeichnis an, also einen Ordner, in dem Sie ausschließlich Ihre R-Skripte abspeichern.

Da dieses Arbeitsverzeichnis im Lauf der Zeit sehr umfangreich werden kann, ist es sinnvoll sich gleich zu Beginn eine Struktur für seine Unterordner zu überlegen. Ratsam ist zum Beispiel, die Unterordner durchzunumerieren und thematisch zu ordnen. (Als Grundgerüst könnte etwa die Gliederung dieses R-Kurses dienen.) Sie werden sehen, wie wichtig es ist, früher geschriebene Skripte schnell aufzufinden.

Das erste Programm: HelloWorld

Starten Sie die RGui; eingebettet in das Fenster der RGui ist die R Console, von der Sie durch das Zeichen

>

aufgefordert werden, einen Befehl einzugeben. Geben Sie ein (wobei nach der Eingabe der ersten Zeile die return-Taste zu drücken ist):

> s <- "Hello World"
> s

[1] "Hello World"

Zur Erklärung:

1. Das Zeichen > ist immer die Eingabe-Aufforderung der Konsole, Ausgaben werden durch [1] gekennzeichnet (die tiefere Bedeutung der 1 werden Sie im Zusammenhang mit Vektoren verstehen; um es kurz anzudeuten: intern verbirgt sich hinter einer Variable ein Vektor der Länge 1 und mit dem Symbol [1] soll gesagt werden, dass die Ausgabe mit der ersten Komponente eines Vektors startet).

2. In Zeile 1 wird eine Variable namens s definiert, der eine Zeichenkette zugewiesen wird. Eine Zeichenkette ist an den umgebenden Anführungsstrichen zu erkennen. Der Inhalt der Zeichenkette ist — wie bei jedem ersten Programm — HelloWorld.

3. Unverständlich an Zeile 1 ist vermutlich das Symbol <- , der Pfeil von rechts nach links: Dies ist der Zuweisungs-Operator, der eben dafür sorgt, dass der Wert auf der rechten Seite der Variable auf der linken Seite zugewiesen wird. Man hätte stattdessen wohl

> s = "Hello World"

erwartet. Auch dies ist möglich, es wird aber empfohlen, in R immer den Pfeil als den Zuweisungs-Operator zu verwenden. (Es kann vorkommen, dass Variablen mit gleichem Namen in mehrfach definiert sind; in diesen Fällen kann = als Zuweisungs-Operator zu unvorhergesehenem Verhalten führen.)

4. Der Befehl muss nicht mit einen Semikolon angeschlossen werden (wie dies in den meisten Programmiersprachen der Fall ist).

5. Drückt man nach der Eingabe von Zeile 1 die return-Taste, erscheint eine neue Eingabe-Aufforderung: es wurde ja nur eine Variable eingegeben, aber keine Berechnung angefordert.

6. In Zeile 2 wird lediglich s eingegeben; dies ist die Abkürzung für

> print(s)

Damit wird R aufgefordert, den Inhalt der Variable s auf der Konsole auszudrucken und es erscheint obige Ausgabe.

Mit diesem Hintergrundwissen über die Arbeitsweise von R lassen sich weitere Berechnungen anstellen:

> x <- 1 + 1
> x
[1] 2
> x <- x + 1
> x
[1] 3
> s
[1] "Hello World"
> summe <- x + s
Fehler in x + s : nicht-numerisches Argument für binären Operator

Zur Erklärung:

  1. In Zeile 1 wird der Variable x der Wert 1 + 1 zugewiesen. Eine Zuweisung geschieht immer nach folgendem Schema:
    • zunächst wird die rechte Seite ausgewertet,
    • das Ergebnis wird der Variable auf der linken Seite zugewiesen.
  2. Zeilen 2 und 3: Die Ausgabe von x ergibt natürlich 2.
  3. Die Gleichung x = x + 1 wäre in der Mathematik unsinnig — es gibt keine Zahl x, die sie erfüllt. Als Zuweisung ist Zeile 4 durchaus sinnvoll. Da x aktuell den Wert 2 besitzt, ergibt die Auswertung der rechten Seite 3; und dies wird der Variable x zugewiesen, was an der folgenden Ausgabe zu sehen ist (Zeilen 5 und 6).
  4. Wenn Sie nach dem Ausführen von HelloWorld oben ihr Arbeitsverzeichnis nicht gelöscht haben (was genau damit gemeint ist, wird in Kürze erklärt), können Sie immer noch auf die Variable s zugreifen, in der der String Hello World abgespeichert ist (Zeilen 7 und 8).
  5. In Zeile 9 wird eine neue Variable namens summe definiert, indem ihr die Summe aus x und s zugewiesen wird. Das Ausführen dieser Zeile ist nicht möglich, da man Zahlen und Zeichenketten nicht addieren kann. R zeigt die entsprechende Fehlermeldung (Zeile 10).
  6. Wer schon mit anderen Programmiersprachen vertraut ist, wird sich vielleicht wundern, warum für die hier definierten Variablen keine Datentypen angegeben wurden (wie integer für ganze Zahlen oder string für Zeichenketten). Viele Programmiersprachen unterscheiden zwischen der Deklaration und der Initialisierung einer Variable; mit Ersterem wird der Datentyp vereinbart, mit Letzterem wird der Variable ein Wert zugewiesen. In R sind keine Deklarationen nötig; die Sprache reagiert dynamisch auf die Eingaben und folgert aus der Initialisierung selbst, welcher Datentyp vorliegen muss. Ein Fehler wie in Zeile 10 wird dadurch erkannt.

Skripte, Working directory und Workspace

Die Befehle oben zur Ausgabe von Hello World und den anschließenden Zuweisungen an die Variable x sind nicht besonders spannend, aber daran soll nun gezeigt werden, wie man sich Skripte abspeichert, die man später wiederverwenden möchte. Da im Lauf der Zeit sehr viele Skripte entstehen, auf die man schnell zugreifen möchte, sollte man sich einen Ordner als Arbeitsverzeichnis (working directory) anlegen. Dieses Arbeitsverzeichnis ist vom aktuellen Arbeitsbereich, dem workspace, zu unterscheiden.

Das Arbeitsverzeichnis (working directory)

Oben wurde bereits gesagt, dass Sie sich einen Ordner (mit geeigneten Unterordnern) anlegen sollen, in dem Sie später Ihre R-Skripte abspeichern. Diesen Ordner können Sie in der RGui definieren:

entweder im Menü mit

Datei -> Verzeichnis wechseln

oder in der Konsole mit

setwd("absolutePath")

wobei absolutePath für den absoluten Pfad des Arbeitsverzeichnisses steht; wd steht für working directory.

Wo sich das Arbeitsverzeichnis aktuell befindet, können Sie jederzeit mit

getwd()

abfragen. Ärgerlich ist, dass die RGui bei jedem Neustart einen (vermutlich ungeeigneten) default-Pfad für das working directory setzt.

Erzeugen und Abspeichern von Skripten

Nachdem Sie Ihr Arbeitsverzeichnis festgelegt haben, können Sie ein Skript anlegen. Dies geschieht mit

Datei -> Neues Skript

Es öffnet sich ein neues Editor-Fenster, in das Sie zum Beispiel eintragen (Achtung: keine Eingabe-Aufforderungen > eintragen!):

s = "Hello World"
s
x <- 1 + 1
x
x <- x + 1
x
s
summe <- x + s

Dies sind genau die Eingaben, die oben bei der ersten HelloWorld-Anwendung direkt in die Konsole geschrieben wurden. Wenn Sie das gesamte Skript mit der Maus markieren, so können Sie es auf der Konsole ausführen lassen mit:

Rechte Maustaste -> Ausführung Zeile oder Auswahl

Auf der Konsole erscheinen genau die Ausgaben, die oben besprochen wurden.

Dieses Skript können Sie jetzt abspeichern, entweder mit dem Disketten-Symbol oder mit

Datei -> Speichern

Als Ort wird das aktuelle Arbeitsverzeichnis vorgeschlagen — damit dieses übersichtlich bleibt, sollten Sie hier eine geeignete Unterordner-Struktur anlegen und die Namen für die Skripte möglichst aussagekräftig wählen, hier etwa HelloWorld.R.

Die Datei-Endung für Skripte ist .R; es handelt sich dabei um Textdateien, die mit jedem beliebigen Text-Editor geöffnet werden können (empfehlenswert ist Notepad++, der dann die .R-Dateien mit Syntax-Highlighting anzeigt).

Vorerst haben die Skripte nur folgende Funktion:

1. Sie dienen als Nachschlagewerk, um auf bereits geschriebene Skripte zurückzugreifen. Sie werden sehen: Hat man sich zu einer Aufgabe eine Folge von Anweisungen gründlich überlegt und in ein lauffähiges Skript übertragen, kann man daran die Lösungsstrategie besser verstehen als wenn man in Lehrbüchern die entsprechenden Konzepte nachliest. Gerade wenn man ähnliche Aufgaben bearbeiten muss, ist die schnellste Lösung meist die Abänderung eines bestehenden Skriptes.

2. Die abgespeicherten Skripte können jederzeit ausgeführt werden. Dazu muss es nur mit

Datei -> Öffne Skript...

geladen werden und kann wie oben beschrieben ausgeführt werden:

Rechte Maustaste -> Ausführung Zeile oder Auswahl

Später wird die eigentlich wichtigste Aufgabe der Skripte erklärt: Um Quelltexte wiederzuverwenden, werden sie nicht nur als Nachschlagewerk eingesetzt, sondern in den Skripten können — im Sinne der strukturierten Programmierung — spezielle Aufgaben in Form von Funktionen abgelegt. Und diese Skripte können später geladen werden, wodurch man auf ihre Funktionalität in den neuen Skripten zugreifen kann. So entstehen dann ganze Software-Pakete.

Der Arbeitsbereich (workspace)

Wenn Sie RGui schon öfters gestartet und wieder geschlossen haben, ist Ihnen sicher aufgefallen, dass Sie vor dem Schließen gefragt werden, ob Sie Ihren workspace sichern wollen. Im aktuellen Arbeitsbereich (workspace) werden alle zuvor verwendeten Variablen mit ihren aktuellen Werten abgespeichert.

Die Variablen kann man sich in der Konsole anzeigen lassen:

> ls()

oder gleichwertig:

> objects()

So ist zum Beispiel nach dem Ausführen des Skriptes

s = "Hello World"
s
x <- 1 + 1
x
x <- x + 1
x
s
summe <- x + s
summe

nach der Eingabe von ls() in der Konsole zu sehen:

[1] "s" "x"

Mit Hilfe von rm() kann man Variablen aus dem Arbeitsbereich löschen. So ist etwa nach

> rm(s)
>ls()

nur noch die Variable x vorhanden:

[1] "x"

Beim Verlassen der RGui kann man sich diesen Arbeitsbereich abspeichern und somit später wieder auf die Variablen und ihre Werte zugreifen. Die Datei-Endung ist .RData; es handelt sich dabei nicht um Textdateien, die man mit einem Text-Editor bearbeiten könnte, sondern um ein internes Dateiformat der RGui.

Die Entwicklungsumgebung RStudio

Wenn Sie mit der Arbeitsweise von RGui vertraut sind und Sie größere Projekte in Angriff nehmen wollen, lohnt es sich auf eine Entwicklungsumgebung wie RStudio umzusteigen. Vertraut sein mit RGui heißt:

Wenn Sie an diese Arbeitsweise gewöhnt sind, werden Sie keine Einführung in RStudio benötigen. Sie werden aber sehen, dass RStudio die Arbeit mit R deutlich erleichtert.

Wenn Sie schon mit Eclipse gearbeitet haben, kann man auch dafür eine Erweiterung zum Arbeiten mit R installieren.

Beachten Sie aber, dass sowohl RStudio als auch Eclipse die Installation von R voraussetzen (andernfalls müssen Sie umständlich Pfade zur R-Installation nachtragen).

Kommentare

Kommentare werden in R mit dem Zeichen # eingegeben. Alles was nach # kommt ist ein Kommentar; ein Zeilenumbruch beendet den Kommentar und in der nächsten Zeile kann wieder Quelltext geschrieben werden.

Das folgende Beispiel zeigt einige Kommentare, die durch das verwendete Syntax-Highlighting leicht erkennbar sind:

# x und y definieren
x <- 5
y <- 9

# Mittelwert mw berechnen
mw <- (x + y) / 2

# Ergebnis ausgeben
mw          # Mittelwert von x und y: 7

An dieser Stelle ist es noch schwer zu beschreiben, wie ausführlich Kommentare die Quelltexte erläutern sollen und welche Dinge in den Kommentaren stehen sollten — dazu wäre es hilfreich schon mehr Einblick in das Programmieren zu haben. Man kann dennoch jetzt schon einige Faustregeln über das richtige Kommentieren von Quelltexten formulieren:

  1. Kommentare sollen immer dort stehen, wo sie hingehören. Meistens werden Kommentare verwendet, um Quelltexte zu erläutern, die schwer verständlich sind; der Kommentar ist für den Leser nur hilfreich, wenn er in unmittelbarer Nähe der Anweisung im Quelltext steht. Nur Kommentare, die sich pauschal auf den gesamten Quelltext eines Skriptes beziehen, stehen am Anfang des Skriptes.
  2. Kommentare sollen kurz und treffend sein. Die in den Quelltext eingestreuten Kommentare bestehen meist nur aus einem Satz oder einem unvollständigen Satz. Wenn Sie merken, dass Sie deutlich mehr schreiben wollen (oder müssen), spricht dies eher dafür, dass Sie die verwendeten R-Konzepte nicht oder nicht richtig verstanden haben.
  3. Kommentare sollen das Lesen des Quelltextes nicht stören. Viele Programmierer gehen sogar weiter und sagen: Der Quelltext ist der Kommentar. Wie auch immer: Vorrang hat der Quelltext; der Kommentar ist eine Ergänzung, die dem Leser helfen soll. (Beachten Sie dabei auch, dass Sie selbst meist der Leser sind. Eine Faustregel besagt, dass man nach einem halben Jahr seine eigenen, unkommentierten Quelltexte nicht mehr versteht.)
  4. Dokumentieren Sie in den Kommentaren Ihren Lernfortschritt. Diese Richtlinie widerspricht eindeutig der Forderung nach kurzen Kommentaren. Es ist damit folgendes gemeint: Zu Beginn werden Sie keine ernsthaften Programme schreiben, sondern lediglich Übungen machen, um sich die Konzepte von R anzueignen. Dabei ist es sehr hilfreich, wenn Sie neu gelernte Inhalte (gerne ausführlich) in eigenen Worten formulieren. Und es schadet nicht, wenn Sie Ihre Beschreibungen den R-Skripten beifügen; denn Sie werden immer wieder auf Ihre Skripte zurückgreifen, wenn Sie später auf ähnliche Problem stoßen — und dann froh sein, dass Sie ausführliche Beschreibungen enthalten. Sie werden aber auch merken, dass im Lauf der Zeit Ihre Kommentare immer kürzer und prägnanter werden und Sie sich immer mehr der Richtlinie 2 annähern.
  5. Treffende Variablen- und Funktions-Namen ersparen viele Kommentare. Programmieren findet nie im luftleeren Raum reiner Abstraktion statt, sondern dient immer einer Problemlösung. Daher haben alle Variablen und Funktionen eine inhaltliche Bedeutung, die man durch treffende Namen andeuten kann.

Den letzten Punkt sollen zwei Skripte verdeutlichen, die eigentlich identisch sind:

# x und y sind bereits gesetzt
z <- x * ( 1 - y / 100)

# preis_alt und rabatt sind bereits gesetzt
preis_neu <- preis_alt * ( 1 - rabatt / 100)

Kleine Helferlein

Im Folgenden werden einige kleine Hilfsmittel vorgestellt, die das Arbeiten mit R deutlich erleichtern können. Manche davon werden Sie erst zu schätzen lernen, wenn Sie etwas Erfahrung im Umgang mit R und Ihrer Entwicklungsumgebung gesammelt haben.

Anzeigen der im workspace definierten Variablen

Hat man längere Zeit auf der Konsole herumprobiert oder man schreibt an umfangreichen Skripten, kann es leicht vorkommen, dass man den Überblick über die bereits definierten Variablen verliert. Wie oben schon gesagt, liefern die Befehle

ls()
objects()

alle aktuelle definierten Variablen.

Löschen der im workspace definierten Variablen

Möchte man einzelne Variablen löschen, geschieht dies mit dem Befehl rm() wie oben bereits gezeigt wurde. Man kann auch sämtliche Variablen löschen — sollte sich aber vorher gut überlegen, ob man das wirklich machne möchte. Der Befehl dazu lautet:

rm(list = ls())

Man wird vor Ausführung des Befehles nicht gefragt, ob man wirklich alle Variablen löschen möchte.

Hilfe zu Funktionen mit ?

Zu jeder Funktion kann mit Hilfe von help() direkt aus der Konsole die Dokumentation der Funktion aufgerufen werden. Möchte man zum Beispiel wissen, wie die Funktion length() eingesetzt wird, reicht es in die Konsole einzugeben:

help(length)

Es reicht sogar die Kurzform:

?length

In beiden Fällen öffnet sich die R-Dokumentation zur Funktion length() .

Code-Schnipsel (code-snippets)

Legen Sie sich möglichst früh eine Datei (oder besser: thematisch sortiert mehrere Dateien) an, in der Sie sich Code-Schnipsel abspeichern. Damit sind Anweisungen gemeint, von denen Sie vermuten, dass

Sie werden sehen, dass Sie mit gut organisierten Code-Schnipseln besser arbeiten können als mit Lehrbüchern.

Quelltext-Formatierung

Versuchen Sie die Lesbarkeit Ihrer Quelltexte zu verbessern, indem Sie

Als Anfänger konzentriert man sich zunächst nur darauf, syntaktisch richtige Quelltexte zu schreiben, die die richtigen Berechnungen durchführen; dabei vernachlässigt man meist die Formatierung des Quelltextes. Sie werden aber schnell sehen, wie oft Sie in Ihren eigenen Quelltexten nachschlagen und wie hilfreich es dann ist, wenn diese leicht lesbar sind.

Code-Vervollständigung

Eine Entwicklungsumgebung wie RStudio bietet eine Unterstützung, die man auch als Anfänger gut einsetzen kann: Code-Vervollständigung. Damit ist gemeint, dass nach Eintippen eines (oder mehrerer) Buchstaben sämtliche R-Objekte und Funktionen angezeigt werden, die mit diesem Buchstaben beginnen. Man kann dann leicht das gewünschte Objekt auswählen oder sich für die entsprechende Funktion die Dokumentation anzeigen lassen. Und die Code-Vervollständigung hat einen Nebeneffekt: man sieht, wenn es Zeit ist, überflüssige R-Objekte zu löschen.

Methodische Hinweise zum Gebrauch dieser Einführung in R

Learning by doing

In diesem Skript sind sehr viele Quelltexte eingestreut, die Sie leicht per copy & paste in Ihre R-Entwicklungsumgebung übertragen können. Führen Sie die Skripte stets selber aus und versuchen Sie eigene, ähnliche Fragestellungen zu bearbeiten. Sie werden sehen, dass man durch Lesen von theoretischen Erklärungen und Quelltexten nur sehr langsam dazulernt; dagegen werden Sie sehr viel schneller Fortschritte machen, wenn Sie selber Quelltexte und entsprechende Erklärungen schreiben.

Funktionen

Im Skript besprochene R-Funktionen

In diesem Skript werden zahlreiche Funktionen vorgestellt, die in den Standard-Paketen enthalten sind. Einige Beispiele haben Sie hier schon kennengelernt: Im allerersten Skript, das die Mächtigkeit von R andeuten sollte, wurden zum Beispiel Zufallszahlen erzeugt (rnorm()), Mittelwerte (mean()), Varianzen (var()) und ein Korrelationskoeffizient (cor()) berechnet.

Funktionen haben (fast) immer Eingabewerte; so hat zum Beispiel die Funktion mean() als Eingabewert einen Vektor x, von dessen Komponenten dann der Mittelwert berechnet wird. Wenn Sie in der Dokumentation für die Funktion mean() nachschlagen, werden Sie sehen, dass es noch weitere Eingabewerte gibt, die in diesem Beispiel nicht vorgekommen sind.

Und dieses Beispiel ist typisch für die gesamte Vorgehensweise in diesem Skript: Werden Funktionen besprochen, so werden immer nur diejenigen Eingabewerte besprochen, die man unbedingt benötigt, um mit der Funktion zu arbeiten. Hinter den weiteren Eingabewerten verstecken sich oft Spitzfindigkeiten, die einen Anfänger nur verwirren. Sie werden aber sehen, dass Sie im Verlauf der Arbeit mit R immer mehr von diesen Spitzfindigkeiten kennenlernen und dann auch in der Lage sind die Dokumentation selbständig durchzuarbeiten und die weiteren Eingabewerte sinnvoll einzusetzen.

Für die ersten Anwendungen, die Sie hier in diesem Kurs kennenlernen und selber schreiben, werden Sie kaum mit derartigen Spitzfindigkeiten konfrontiert; wenn Sie später ernsthaft programmierien, werden Sie daran aber nicht vorbeikommen. Um möglichst schnell in R einzusteigen und einen Überblick zu gewinnen, was man damit alles machen kann, sollten Sie sich zunächst auf den Gebrauch der Funktionen konzentrieren, wie sie hier vorgestellt werden.

Selbst geschriebene Funktionen

Wenn Sie tiefer in R eingestiegen sind, werden Sie sehen, dass die in R vorbereiteten Funktionen nicht mehr ausreichen und Sie gezwungen sind selber Funktionen zu schreiben. Versuchen Sie dabei immer, den Großteil der von einer Funktion zu erledigenden Arbeit an bereits bestehende Funktionen weiterzureichen und deren Eingabewerte anzubieten. Sie werden sehen, dass Sie dadurch viele Spezialfälle abfangen können, die meist mit sehr hohem Programmier-Aufwand verbunden sind.

Dazu ist es aber erforderlich, dass Sie gut mit der R-Dokumentation vertraut sind. Gewöhnen Sie sich deshalb möglichst früh an, bei jeder neuen Funktion, die hier besprochen wird, einen Blick in die Dokumentation zu werfen, um eine Gefühl dafür zu bekommen, welche Spezialfälle beim Gebrauch der Funktion auftreten können.

Diagnose-Funktionen

Die Sprache R bietet eine Reihe von Diagnose-Funktionen, die auf nahezu alle Objekte angewendet werden können und eine an den Datentyp des Objektes angepasste Information liefern.

In den folgenden Kapiteln werden der Reihe nach die in R vorbereiteten Datentypen besprochen; dabei werden auch die entsprechenden Diagnose-Funktionen vorgestellt. Um — gerade beim Einstieg — schnell mit der internen Arbeitsweise von R vertraut zu werden, empfiehlt es sich, beim Aufruf einer Funktion nicht nur das Ergebnis der Berechnung ausgeben zu lassen, sondern zusätzlich den Rückgabewert in einer Variable abzuspeichern und mit den Diagnose-Funktionen zu untersuchen. In vielen Fällen mag dies überflüssig und lästig erscheinen, es hilft aber dabei zu verstehen, wie die Ergebnisse von Berechnungen weiter verarbeitet werden können.

Aufruf von Funktionen: Argumente angeben

Die Sprache R bietet die Möglichkeit, beim Aufruf einer Funktion in der Argumentliste nicht nur die Argumente anzugeben, sondern zusätzlich die Namen der Argumente (viele andere Programmiersprachen kennen diese Möglichkeit nicht).

Was soll dies bedeuten? Es gibt zum Beispiel eine Funktion rep(), mit deren Hilfe Vektoren erzeugt werden, in denen ein Wert x mehrmals wiederholt wird (rep ist die Abkürzung für replicate). Der Aufruf der Funktion lautet etwa:

rep(5, 17)

Liest man diesen Aufruf und weiß man die Bedeutung von rep(), so wird man sich vielleicht fragen:

Schreibt man den Funktionsaufruf dagegen:

rep(x = 5, times = 17)

ist sofort klar, dass die erste Version richtig ist.

Es mag zwar mühsamer erscheinen, in den Quelltexten stets die Namen der Argumente anzugeben und vermutlich wird man öfters in der Dokumentation nachschlagen müssen, Sie werden aber sehen, dass sie langfristig davon profitieren:

In dieser Einführung in R werden die Namen der Argumente — außer wenn sie selbstverständlich sind — angegeben; Sie sollten dies in Ihren eigenen Skripten nachahmen und im Zweifelsfall immer die Dokumentation zu Rate ziehen.