Textverarbeitung mit R: Die Funktionen substr() und substring() zum Extrahieren von Substrings

Einordnung des Artikels

• Einführung in die Informatik
  • Einführung in die Programmiersprache R
    • Textverarbeitung mit R
      • Textverarbeitung mit R: Die Funktionen substr() und substring() zum Extrahieren von Substrings

Einführung

Die Dokumentation zu den beiden Funktionen substr() und substring() findet man im Paket base unter substr.

Die beiden Funktionen sind in ihrer Arbeitsweise identisch; sie unterscheiden sich lediglich

• in der Bezeichnung der Eingabewerte sowie
• darin, dass bei substring() das Argument last = 1000000L einen default-Wert besitzt.

Im Folgenden wird bei allen Beispielen die Funktion substr() eingesetzt.

substr(x, start, stop)
substring(text, first, last = 1000000L)
substr(x, start, stop) <- value
substring(text, first, last = 1000000L) <- value

Man erkennt, dass für beide Funktionen eine replacement-Version existiert.

Eine typische Anwendung von substr() zeigt das folgende Skript:

s <- substr(x = "ABCDEF", start = 2, stop = 5)
s    # "BCDE"

Aus der Zeichenkette "ABCDEF" (bestehend aus 6 Zeichen), die an das Argument x übergeben wird, werden das zweite bis einschließlich fünfte Zeichen extrahiert; diese Zeichenkette (der "substring") bildet den Rückgabewert von substr() (siehe auch Abbildung 1 oben).

Abbildung 1: Darstellung der Arbeitsweise von substr() und ihrer replacement-Version.

Das Skript wirft aber sofort einige Fragen auf, die in den nächsten Abschnitten besprochen werden:

1. Was passiert, wenn die durch start und stop angesprochenen Indizes nicht innerhalb der Zeichenkette x liegen oder stop kleiner ist als start?
2. Wie arbeitet substr(), wenn der Eingabewert x ein Vektor von Zeichenketten ist?
3. Wie arbeitet die replacement-Version von substr()?

Die Eingabewerte start und stop

In der Einführung wurde bereits die typische Verwendung von substr() gezeigt; man muss dabei beachten, dass ein Zeichen wie \n als ein Zeichen behandelt wird:

s <- substr(x = "A\nB\nC\nD\nE\nF", start = 2, stop = 5)
s    # "\nB\nC"

Bei der Verwendung von substr() sollte man auch wissen, wie die Funktion in Sonderfällen arbeitet; dazu zeigt das folgende Skript einige Beispiele, die immer den Eingabewert x = "ABCDEF" verwenden, der aus 6 Zeichen besteht:

substr(x = "ABCDEF", start = 2, stop = 2)
# "B"

substr(x = "ABCDEF", start = 0, stop = 5)
# "ABCDE"

substr(x = "ABCDEF", start = -1, stop = 5)
# "ABCDE"

substr(x = "ABCDEF", start = 2, stop = 7)
# "BCDEF"

substr(x = "ABCDEF", start = 5, stop = 2)
# ""

substr(x = "ABCDEF", start = 7, stop = 2)
# ""

Zeile 1 und 2: Sind start und stop identisch, wird das Zeichen ausgewählt, das sich an der Stelle start von x befindet.

Zeile 4 bis 8: Sinnvolle Werte für start sind eigentlich alle Zahlen von 1 bis length(x) . Ist start kleiner als 1, wird substr() so eingesetzt als hätte man start = 1 gesetzt.

Zeile 10 und 11: Analoges gilt für das Argument stop. Für Werte von stop, die größer sind als length(x) , wird stop = length(x) verwendet.

Zeile 13 bis 17: Ist start größer als stop, wird als Rückgabewert die leere Zeichenkette erzeugt. Diese wird auch erzeugt, wenn start größer ist als length(x) .

Die Anwendung von substr() auf einen Vektor von Zeichenketten

Die Funktion ist vektorisiert: Wird für x ein Vektor von Zeichenketten eingegeben, so wird die Funktion substr() auf jede einzelne Komponente von x angewendet. Die dabei erzeugten Zeichenketten werden wider zu einem Vektor zusammengefügt, so dass length(x) und length(substr(x, start, stop)) übereinstimmen.

Das folgende Skript zeigt ein einfaches Beispiel, das auch einige der oben beschriebenen Spezialfälle enthält:

v <- c("A", "AB", "ABC", "ABC", "ABCDE", "ABCDEF")
substr(x = v, start = 2, stop = 5)
# ""     "B"    "BC"   "BC"   "BCDE" "BCDE"

Die Übereinstimmung von Eingabewert x und Rückgabewert besteht auch für das Attribut names – sofern es im Eingabe-Vektor x gesetzt war:

v <- c(v1 = "A", v2 = "AB", v3 = "ABC", v4 = "ABC", v5 = "ABCDE", v6 = "ABCDEF")
s <- substr(x = v, start = 2, stop = 5)

s
# v1     v2     v3     v4     v5     v6 
# ""    "B"   "BC"   "BC" "BCDE" "BCDE" 

str(v)
# Named chr [1:6] "A" "AB" "ABC" "ABC" "ABCDE" "ABCDEF"
# - attr(*, "names")= chr [1:6] "v1" "v2" "v3" "v4" ...

str(s)
# Named chr [1:6] "" "B" "BC" "BC" "BCDE" "BCDE"
# - attr(*, "names")= chr [1:6] "v1" "v2" "v3" "v4" ...

Jetzt sind im Eingabe-Vektor v Namen (das Attribut names) der Komponenten gesetzt (Zeile 1); diese Namen werden an den Rückgabewert von substr() weitergegeben (Zeile 12 und 13).

Die replacement-Version von substr()

Die Funktion substr() extrahiert einen Teil aus einer Zeichenkette x; dabei legen die Argumente start und stop fest, wo sich der "substring" in der Zeichenkette x befindet. Der "substring" ist dann der Rückgabewert.

Das folgende Skript zeigt eine einfache Anwendung der replacement-Version von substr():

s <- "ABCDEF"
substr(x = s, start = 2, stop = 5) <- "bcde"
s
# "AbcdeF"

Bei der Ausführung der replacement-Version von substr() geschieht Folgendes (siehe Abbildung 1 unten):

• Aus einer Zeichenkette s wird wieder über die Argumente start und stop ein "substring" ausgewählt.
• Dieser "substring" kann neu gesetzt werden; dazu dient die rechte Seite in substr() <- value (siehe Zeile 2).
• Die Zeichenkette s wurde vom zweiten bis zum fünften Zeichen verändert (siehe Zeile 4).

Natürlich kann auch bei der replacement-Version das Argument x ein Vektor von Zeichenketten sein. All die Spitzfindigkeiten, die sich dann ergeben und die oben erklärt wurden, treten auch hier auf – einige davon kann man an folgendem Skript ablesen:

v <- c("A", "AB", "ABC", "ABC", "ABCDE", "ABCDEF")
substr(x = v , start = 2, stop = 5) <- "bcde"
v
# [1] "A"      "Ab"     "Abc"    "Abc"    "Abcde"  "AbcdeF"