Zum Hauptinhalt springen

Utilities in R Tutorial

Lerne nützliche Funktionen zur Manipulation von Datenstrukturen, verschachtelten Listen, regulären Ausdrücken sowie zum Arbeiten mit Zeiten und Daten in der Programmiersprache R kennen.
· 14 Min. lesen

Entdecke KI

In diesem Tutorial lernst du mehrere Funktionen und Helfer kennen, die in der Programmiersprache R einfach und häufig genutzt werden. Zuerst schauen wir uns einige mathematische Funktionen an. Danach widmest du dich Funktionen, die eng mit R-Datenstrukturen verknüpft sind: das Bearbeiten verschachtelter Listen, reguläre Ausdrücke sowie Arbeiten mit Zeit- und Datumswerten.

Mathematische Funktionen

Schau dir die folgenden Codezellen an, die mehrere mathematische Funktionen verwenden.

Zunächst definierst du zwei Vektoren, nämlich x und y, die sowohl positive als auch negative Werte enthalten.

x <- c(1.1, -2.3, -4.5)
y <- c(2.4,-44, -2.2)

print(x)

[1]  1.1 -2.3 -4.5
print(y)

[1]   2.4 -44.0  -2.2

Nimm nun die beiden Vektoren x und y und führe Folgendes durch:

  • Bilde die Beträge der Werte,
  • runde sie auf null Nachkommastellen,
  • bilde jeweils die Summe und
  • berechne schließlich den Durchschnitt der beiden Summen.
mean(c(sum(round(abs(x))),sum(round(abs(y)))))

27.5

Wie wäre es, wenn du die obige Zeile in kleinere Teile zerlegst und dir jede Funktion im Detail ansiehst?

  • Die Funktion abs() liefert einfach den positiven beziehungsweise absoluten Wert der Elemente der Vektoren x und y.

Wendest du abs() auf x und y an, erwartest du nur positive Werte, wie unten gezeigt.

abs(x)
  1. 1.1
  2. 2.3
  3. 4.5
abs(y)
  1. 2.4
  2. 44
  3. 2.2
  • Als Nächstes kommt die Funktion round(). Sie rundet die Eingabe. Über ein zusätzliches Argument gibst du an, auf wie viele Dezimalstellen gerundet werden soll. Standardmäßig rundet round() auf null Nachkommastellen.

Wendest du round() auf die Vektoren x und y an, sieht die Ausgabe wie folgt aus:

round(x)
  1. 1
  2. -2
  3. -4
round(y)
  1. 2
  2. -44
  3. -2
  • Die Funktion sum() berechnet die Summe der Elemente eines Vektors oder einer Matrix. Übergibst du zum Beispiel einen Zeilenvektor, erhältst du als Skalar die Summe aller Elemente zurück.

In unserem Fall werden die Vektoren x und y an sum() übergeben. R berechnet also jeweils die Summe der Vektorelemente und gibt einen Skalar aus.

sum(abs(round(x)))

7
sum(abs(round(y)))

 48
  • Zum Schluss berechnet mean() den arithmetischen Mittelwert. Dabei werden die Zahlen addiert und durch die Anzahl der Werte geteilt.

Hier ist die Eingabe für mean() ein Zeilenvektor der Länge zwei mit den Zahlen 7 und 48. Der Mittelwert ist also die Summe der beiden Werte geteilt durch die Anzahl der Elemente, also 2.

mean(c(7,48))

27.5

Gar nicht so schwer, oder?

Weiter geht’s mit dem nächsten, besonders spannenden Teil dieses Tutorials!

Funktionen für Datenstrukturen

Schauen wir uns nun einige Datenstrukturen wie Listen und Vektoren an. Du lernst verschiedene Möglichkeiten, mit der Datenstruktur list zu arbeiten, eine list umzukehren und wie du Listen in Vektoren und umgekehrt umwandelst.

Die folgende Funktion ist eine list() beziehungsweise eine Liste von Listen, auch verschachtelte Liste genannt. Sie erstellt eine Liste von Elementen, die logische Werte, numerische Werte und Zeichenketten enthalten kann.

Im folgenden Beispiel gibt es drei Listen innerhalb einer Liste: log, ch und int_vec. Jede davon hat einen Datentyp bzw. ein R-Objekt: logisch, numerisch oder Zeichen/String.

list_define <- list(log = TRUE, ch = "hello_datacamp", int_vec = sort(rep(seq(8,2, by = -2), times = 2)))

list_define
$log
TRUE
$ch
'hello_datacamp'
$int_vec
  1. 2
  2. 2
  3. 4
  4. 4
  5. 6
  6. 6
  7. 8
  8. 8
  • log ist ein logischer Wert, TRUE oder FALSE.
  • ch ist die Zeichenkette hello_datacamp.
  • int_vec ist eine Folge numerischer Werte.

Da log und ch selbsterklärend sind, schauen wir uns int_vec genauer an.

int_vec = sort(rep(seq(8,2, by = -2), times = 2))

int_vec
  1. 2
  2. 2
  3. 4
  4. 4
  5. 6
  6. 6
  7. 8
  8. 8

Gehen wir den obigen Ausdruck Schritt für Schritt durch.

Die Funktion seq erzeugt eine Zahlenfolge in absteigender Reihenfolge von 8 bis 2.

Die Syntax von seq() lautet: seq(x1,x2, by = y)

Die ersten beiden Argumente x1 und x2 geben den Bereich der Folge an, also wo sie beginnt und endet. Das Argument by legt die Schrittweite der Erhöhung oder Verringerung fest.

Zum Beispiel erzeugt die folgende Zeile eine Folge von 100 bis 200 in 20er-Schritten.

seq(100,200, by = 20)
  1. 100
  2. 120
  3. 140
  4. 160
  5. 180
  6. 200

In unserem Beispiel liefert seq eine Folge von 8 bis 2 (inklusive) mit einer Schrittweite von -2, also einen Vektor der Länge 4.

a = seq(8,2, by = -2)

a
  1. 8
  2. 6
  3. 4
  4. 2

Als Nächstes zur Funktion rep.

Sie wiederholt das Eingabeargument, üblicherweise einen Vektor oder eine Liste. Mit dem Argument times (eine ganze Zahl) gibst du an, wie oft die Eingabe wiederholt wird. rep erwartet zwei Argumente: die Eingabe und die gewünschte Anzahl an Wiederholungen.

Wendest du rep auf unser Beispiel (einen Vektor der Länge 4) an, erhältst du einen Ausgabeverktor der Länge 8.

b = rep(a, times = 2)

Wenn statt des gesamten Vektors jedes einzelne Element wiederholt werden soll, nutzt du statt times das Argument each.

Der Unterschied zwischen times und each liegt im entstehenden Muster der Wiederholungen.

rep(a, each = 2)
  1. 8
  2. 8
  3. 6
  4. 6
  5. 4
  6. 4
  7. 2
  8. 2

Zuletzt noch die Funktion sort(). Sie ist eine generische, selbsterklärende Funktion zum Sortieren vieler Datenstrukturen wie Vektoren oder Listen. Sie funktioniert nicht nur für numerische Werte, sondern auch für logische Werte und Zeichen. Standardmäßig wird aufsteigend sortiert.

Gib die Ausgabe von rep an sort weiter, um das finale Ergebnis zu erhalten.

sort(b)
  1. 2
  2. 2
  3. 4
  4. 4
  5. 6
  6. 6
  7. 8
  8. 8

Super! Damit hast du den langen Ausdruck int_vec aus der Liste list_define ganz entspannt nachvollzogen.

Als Nächstes schauen wir uns den Inhalt der Liste list_define mit der Funktion str() an. str() zeigt die Struktur von R-Objekten an.

str(list_define)

List of 3
 $ log    : logi TRUE
 $ ch     : chr "hello_datacamp"
 $ int_vec: num [1:8] 2 2 4 4 6 6 8 8

Schauen wir uns ein paar praktische R-Ausdrücke an:

  • Mit is-Funktionen kannst du den Typ deiner Datenstruktur prüfen. Das Ergebnis ist logisch (TRUE/FALSE) – ideal für Bedingungen.
is.list(list_define) #liefert TRUE, wenn das Argument eine Liste ist.

TRUE

Wird hingegen ein Vektor übergeben, der keine Liste ist, erhältst du FALSE, wie unten gezeigt.

is.list(c(1,2,3)) #liefert FALSE, da ein Vektor übergeben wurde.

FALSE
  • Einen Vektor in eine Liste umzuwandeln ist in R sehr einfach. Verwende as gefolgt von .list() und übergib den Vektor als Argument. Damit wandelst du den Vektor in eine Liste um.
vec_to_list <- as.list(c(1,2,3))

is.list(vec_to_list) #mit is.list() prüfen

TRUE
  • Umgekehrt kannst du eine Liste mit unlist in einen Vektor „abrollen“. R flacht dazu die gesamte Listenstruktur ab und gibt einen einzelnen Vektor aus.
list_to_vec <- unlist(vec_to_list)

list_to_vec
  1. 1
  2. 2
  3. 3

Analog zu is.list() kannst du mit is.vector() prüfen, ob ein Argument ein Vektor ist.

is.vector(list_to_vec)

TRUE

Wandeln wir nun die große Liste list_define in einen Vektor um. Wichtig: Ein Vektor kann nur einen einzigen Datentyp enthalten. Daher werden sowohl logische als auch numerische Werte zu Zeichenketten konvertiert.

unlist(list_define)
log
'TRUE'
ch
'hello_datacamp'
int_vec1
'2'
int_vec2
'2'
int_vec3
'4'
int_vec4
'4'
int_vec5
'6'
int_vec6
'6'
int_vec7
'8'
int_vec8
'8'

Bevor wir zum nächsten Thema übergehen, noch ein Blick auf append() und rev().

  • Wie der Name andeutet, fügt append() einen oder mehrere Vektoren bzw. Listen an einen bestehenden oder neuen Vektor/Liste an.

Probieren wir append() auf der Liste list_define aus. Du siehst, dass die Liste anschließend 6 statt 3 Elemente enthält, denn du hast sie mit sich selbst verknüpft.

str(append(list_define, list_define))

List of 6
 $ log    : logi TRUE
 $ ch     : chr "hello_datacamp"
 $ int_vec: num [1:8] 2 2 4 4 6 6 8 8
 $ log    : logi TRUE
 $ ch     : chr "hello_datacamp"
 $ int_vec: num [1:8] 2 2 4 4 6 6 8 8
  • Zum Schluss kehren wir die Reihenfolge der Liste list_define mit rev() um.
str(rev(list_define))

List of 3
 $ int_vec: num [1:8] 2 2 4 4 6 6 8 8
 $ ch     : chr "hello_datacamp"
 $ log    : logi TRUE

Reguläre Ausdrücke

Viele finden reguläre Ausdrücke zunächst kompliziert. Sie sind jedoch ein zentrales Thema – nicht nur in R, sondern auch in anderen Sprachen wie Python. Viele Programmiersprachen, darunter R, bringen eingebaute Regex-Funktionalität mit.

Reguläre Ausdrücke lassen sich in zahlreichen Anwendungen einsetzen und sind besonders nützlich, wenn du Textdaten vorverarbeiten möchtest. Sie kommen etwa in der Verarbeitung natürlicher Sprache (NLP) zum Einsatz.

Auch Suchmaschinen und Texteditoren nutzen sie.

Reguläre Ausdrücke, kurz regex oder regexp (auch rationale Operatoren genannt), sind Zeichenfolgen, die ein Suchmuster definieren. Diese Muster werden von verschiedenen String-Suchalgorithmen verwendet, um ein Muster zu finden, zu ersetzen oder passende Elemente zu filtern.

Starten wir mit den Funktionen grep() und grepl().

Der Einfachheit halber definieren wir einen Zeilenvektor animals_regex der Länge 5, auf dem du Regex-Muster anwenden wirst.

animals_regex <- c('cat','dog','cheetah','lion','mice')

Zuerst zur Funktion grepl(). grepl() gibt ein logisches Ergebnis zurück: Stimmt die Zeichenkette mit dem Muster überein, kommt TRUE, sonst FALSE.

Die Syntax ist klar: Erstes Argument ist das gesuchte Muster, zweites Argument ist der Eingabe-String/Vektor, in dem gesucht werden soll. Die restlichen Argumente kannst du vorerst ignorieren. grepl(pattern, x, ignore.case = FALSE, perl = FALSE, fixed = FALSE, useBytes = FALSE) Finden wir heraus, welche der fünf Tiere ein c enthalten, mit grepl().

In diesem Fall suchst du nach Tieren, die ein c enthalten – das Muster ist also einfach c.

grepl(pattern = 'c', x = animals_regex)
  1. TRUE
  2. FALSE
  3. TRUE
  4. FALSE
  5. TRUE

Wie du siehst, enthält cat, cheetah und mice ein c, daher ist an diesen Indizes im Vektor animals_regex der Wert TRUE, während für die anderen FALSE zurückgegeben wird.

Jetzt wollen wir die Elemente finden, die mit c beginnen, nicht nur solche, die irgendwo ein c enthalten.

Dafür setzt du ein Zirkumflex ^ an den Anfang des Suchmusters.

grepl(pattern = '^c', x = animals_regex) #nur cat und cheetah beginnen mit „c“.
  1. TRUE
  2. FALSE
  3. TRUE
  4. FALSE
  5. FALSE

Da nur cat und cheetah mit c anfangen, sind nur diese Positionen TRUE.

Ähnlich funktioniert das Dollarzeichen $ am Ende des Musters, um Elemente zu finden, die mit einem bestimmten Muster enden. Um ein Tier zu finden, das auf n endet, verwendest du n gefolgt von $.

grepl(pattern = 'n$', x = animals_regex) #nur lion endet auf „n“.
  1. FALSE
  2. FALSE
  3. FALSE
  4. TRUE
  5. FALSE

Hinweis: Wenn du mehr über reguläre Ausdrücke lernen willst, tippe ?regex in eine Jupyter-Notebook-Zelle – die Doku zu Regex öffnet sich. Sehr hilfreich ist auch diese Quelle, mit der du Suchmuster entwerfen und direkt auf deine Strings testen kannst.

  • Analog zu grepl() gibt es grep(). Diese Funktion liefert statt TRUE/FALSE die Indizes der Elemente im Vektor bzw. in der Matrix, die dem Muster entsprechen.

Die Syntax von grep() ist identisch zu grepl(): grep(pattern, x, ignore.case = FALSE, perl = FALSE, value = FALSE, fixed = FALSE, useBytes = FALSE, invert = FALSE) Nehmen wir dasselbe Beispiel wie oben, wenden diesmal aber grep() an!

grep(pattern = 'c', x = animals_regex)
  1. 1
  2. 3
  3. 5

Wie erwartet, bekommst du die Indizes der Elemente cat, cheetah und mice zurück – nicht TRUE/FALSE. Das war’s im Grunde schon!

Vergleichen wir grep() und grepl() noch mit which. which() liefert die Indizes der Elemente eines logischen Vektors, die TRUE sind.

Verknüpfst du das mit grepl(), kannst du also den logischen Vektor an which() übergeben und erhältst als Ergebnis dasselbe wie von grep().

which(grepl(pattern = 'c', x = animals_regex))
  1. 1
  2. 3
  3. 5

Wie grepl() kann auch grep() verschiedene Regex-Muster verarbeiten.

Suchst du mit grep() nach Elementen im Vektor animals_regex, die auf n enden, erwartest du als Ausgabe 4, denn nur lion endet auf n, wie unten gezeigt.

grep(pattern = 'n$', x = animals_regex)

4

Gut gemacht!

Du hast die Grundlagen regulärer Ausdrücke kennengelernt – etwa, wie du Elemente aus einem Vektor filterst, die einem Muster entsprechen. R kann aber mehr als nur Muster finden. Es gibt eine Reihe weiterer Funktionen, darunter sub().

sub() filtert nicht, sondern ersetzt Treffer durch andere Strings. Schauen wir uns das genauer an!

  • sub() nimmt im Wesentlichen drei Argumente entgegen:
    • pattern: das zu suchende Muster bzw. der reguläre Ausdruck,
    • replacement: der Wert, der an der Trefferposition eingesetzt wird, und
    • x: der Eingabevektor (Zeichenketten), auf den die Regex angewandt wird.

Die Syntax lautet: sub(pattern, replacement, x, ignore.case = FALSE, perl = FALSE,fixed = FALSE, useBytes = FALSE) Auch hier nutzen wir dasselbe Beispiel wie oben, um die Funktion zu verstehen!

sub(pattern = 'c', replacement = 'a', x = animals_regex)
  1. 'aat'
  2. 'dog'
  3. 'aheetah'
  4. 'lion'
  5. 'miae'

Wie du siehst, wird cat zu aat, cheetah zu aheetah und mice zu miae. Für diese Elemente wurde das Muster erfolgreich gefunden und ersetzt.

Beachte außerdem: sub() ersetzt nur das erste Vorkommen im String. Gibt es zwei c in einer Zeichenkette, wird nur das erste durch a ersetzt, das zweite bleibt unverändert.

Wenn du wirklich jedes einzelne Vorkommen eines Musters ersetzen willst, nutze gsub() – das geht über den Rahmen dieses Tutorials hinaus!

Bevor wir weitergehen, probieren wir noch einen interessanten Ausdruck.

Diesmal verwendest du den Operator | (oder), der auf eines der definierten Muster matcht und, falls gefunden, durch - ersetzt. Denk daran: Mit gsub() werden alle Vorkommen eines Musters im String ersetzt.

gsub(pattern = 'c|d|l', replacement = '-', x = animals_regex) #Tiere mit „c“, „d“, „l“ werden durch „-“ ersetzt.
  1. '-at'
  2. '-og'
  3. '-heetah'
  4. '-ion'
  5. 'mi-e'

Kommen wir zum letzten Thema dieses Tutorials: Zeit und Datum!

Zeit und Datum

Zeit- und Datumsinformationen sind in vielen Situationen nützlich. Angenommen, du arbeitest an einem Computer-Vision-Problem und möchtest die FPS (Frames per Second) messen, mit denen dein Algorithmus läuft. In so einem Fall kannst du Zeitfunktionen nutzen, um die Verarbeitungsgeschwindigkeit zu ermitteln. Für Aufgaben wie Zeitreihenprognosen und Saisonalitätsanalysen kann R sein Potenzial voll ausspielen.

Zum Einstieg drucken wir mit Sys.Date() das heutige Datum aus. Sys steht für System – es wird also das Datum des Systems zurückgegeben.

Sys.Date()

Einfach, oder?

Zeit- und Datumswerte gehören in R zum Objekt Date beziehungsweise zum Datentyp Date. Das kannst du mit der Funktion class prüfen, die du bereits im Tutorial Data Types in R kennengelernt hast.

Ähnlich zur Datumsfunktion gibt es Sys.time(), die die aktuelle Systemzeit zurückgibt – tatsächlich sowohl Datum als auch Uhrzeit.

Sys.time()

[1] "2020-02-04 02:05:04 IST"

Date-Objekte erstellen

Du weißt nun, wie du aktuelles Datum und aktuelle Uhrzeit bekommst. Als Nächstes: Wie erstellst du Datumswerte für andere Tage, indem du einfach eine Zeichenkette übergibst?

Um ein Date-Objekt für den 10. Mai 1993 zu erzeugen, verwendest du folgende Syntax:

date_may <- as.Date('1993-05-10') #wandelt eine Zeichenkette in ein Date-Objekt um

date_may


class(date_may)

'Date'

Wichtig: Die Funktion as.Date() erwartet standardmäßig das Format YYYY-MM-DD. Vertauschst du Jahr, Monat oder Tag, führt das zu einem Fehler. Probieren wir’s aus!

date_may <- as.Date('05-1993-10') #R folgt standardmäßig dem ISO-Datumsformat

Error in charToDate(x): character string is not in a standard unambiguous format
Traceback:


1. as.Date("05-1993-10")

2. as.Date.character("05-1993-10")

3. charToDate(x)

4. stop("character string is not in a standard unambiguous format")

Die gute Nachricht: Du kannst das Format explizit über das Argument format angeben und anpassen.

date_may <- as.Date('05-1993-10', format = '%m-%Y-%d')

as.Date() akzeptiert verschiedene Eingabeformate, konvertiert das Ergebnis aber am Ende wieder ins ISO-Format. Das siehst du, wenn du date_may ausgibst.

date_may


date_may <- as.Date('05-10-1993', format = '%m-%d-%Y')

date_may

Datumsarithmetik

Wäre es nicht praktisch, wenn du mit Date-Objekten in R auch rechnen könntest?

Addiere 1 zu date_may, und du siehst den Tag danach.

date_may + 1

Wie du siehst, wird aus dem 10. Mai 1993 der 11. Mai 1993. Genauso kannst du auch einen Tag subtrahieren.

Angenommen, du möchtest den Altersunterschied zwischen dir und deinem älteren Geschwister ermitteln.

elder_sib <- as.Date('1989-03-21')

date_may - elder_sib

Time difference of 1511 days

Fazit

Glückwunsch – du hast das Tutorial abgeschlossen.

Dieses Tutorial ist ein guter Einstieg für alle, die verschiedene praktische Hilfsfunktionen in R kennenlernen möchten. Als Übung bietet es sich an, tiefer in reguläre Ausdrücke einzusteigen. Sie werden in vielen Anwendungen genutzt und sind ein sehr mächtiges Werkzeug, wenn es ums Bereinigen oder Vorverarbeiten von Textdaten geht.

Stell gern Fragen zu diesem Tutorial in den Kommentaren.

Wenn du mehr über R lernen möchtest, mach den DataCamp-Kurs Intermediate R und sieh dir unser Tutorial Using Functions in R an.

Themen

R Datenwissenschaft

Ähnlich

Tutorial

Python Datenstrukturen Tutorial

Mehr anzeigen →