Reguläre Ausdrücke in R erklärt

reguläre Ausdrücke sind super praktisch, um ein Muster in einem Text oder Vektor zu finden und ggf. zu ersetzen. Z.B. kann man ziemlich einfach überprüfen, ob eine Eingabe einer normalen Email-Adresse entspricht. In R sieht das dann so aus:

emails <- c("max@fax.net","fax","1x1@1","max.mustermann@fax","max_mustermann@fax.de")
grepl("[A-Za-z0-9\\._%+-]+@[A-Za-z0-9\\.-]+\\.[A-Za-z]{2,}",emails)

Aber ganz langsam und der Reihe nach. Ihr seht schon, so ganz trivial sieht so ein regulärer Ausdruck nicht aus. Im Grunde ist er aber ganz logisch aufgebaut und gar nicht so schwer.

Aufbau eines regulären Ausdrucks

Grundsätzlich ist ein regulärer Ausdruck einfach ein String, also eine Zeichenkette. Dabei kommt die Power aber von den Steuerzeichen. Diese erlauben es, komplexe Abfragen wie die obige, ob es sich um eine gültige Email-Adresse handelt, zu generieren.

Am besten lernt man anhand von Beispielen. Also los geht’s:

# Wir erzeugen uns einen Beispieltext
text <- "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet."
 
# Wörter aus String anhand Leerzeichen herausziehen
woerter <- strsplit(text,' ')[[1]]

Das war im Prinzip schon der erste reguläre Ausdruck nämlich ‘ ‘. Ok, nicht sonderlich spektakulär, gebe ich zu. Aber der einfachste Fall ist einfach eine ganz normale Zeichenkette:

# Befindet sich mindestens ein a in dem String?
grepl("a",text)
# Befindet sich mindestens ein a in den Wörtern?
grepl("a",woerter)
# Gib die Wörter aus, welche mindestens ein a enthalten
woerter[grepl("a",woerter)]

Jetzt kommt die Power der Steuerungszeichen:

• Mit dem senkrechten Strich (pipe=’|’) lassen sich Oder-Abfragen erzeugen
• Mit runden Klammern () bildet man Gruppen
• Mit eckigen Klammern [] gibt man Mengen an
• Der Punkt steht für ein beliebiges Zeichen

# Der senkrechte Strich (pipe) | bedeutet 'ODER'
# Gib TRUE aus, falls das Wort ein a oder b enthält
grepl("a|b",woerter)
# Gib nur die Wörter aus, welche ab oder ba enthalten
woerter[grepl("ab|ba",woerter)]
 
# Mit runden Klammern () bildet man Gruppen
# Wieviele Wörter enthalten ein l und danach ein a oder o?
sum(grepl("l(a|o)",woerter))
 
# Mit eckigen Klammern [] gibt man Mengen an
# Ersetze alle Vorkommen von a, e oder i durch ö
gsub("[aei]","ö",woerter)
# Der Bindestrich gibt einen Bereich an
# Alle Großbuchstaben durch eine 9 ersetzen
gsub("[A-Z]","9",woerter)
# Mit ^ innerhalb der eckigen Klammer negiert man den Ausdruck
# Achtung, der folgende Ausdruck gibt nicht die Anzahl Wörter zurück, welche kein e enthalten,
# sondern die Anzahl Wörter, welche mindestens einen Buchstaben enthalten, der kein e ist,
# also alle Wörter, die nicht nur aus e bestehen
sum(grepl("[^e]",woerter))
 
# Der Punkt . steht für ein beliebiges Zeichen
woerter[grepl("do.or",woerter)]

Jetzt wird es komplexer. Mit Quantifizierern kann man angeben, wie häufig eine Gruppe/ein Ausdruck vorkommen darf. Man kann dabei Mindestvorkommen und Maximalvorkommen definieren.

# *,+,?,{}
# Diese Quantifizierer kommen nach einem Zeichen oder Gruppe und bedeuten folgendes:
# * 0 oder mehrfaches Vorkommen
# + 1 oder mehrfaches Vorkommen
# ? 0 oder 1-faches Vorkommen
# {n} n-faches Vorkommen, wobei n eine Zahl ist
# {m,} mindestens m Vorkommen
# {n,m} zwischen n und m-fachem Vorkommen
 
# großes A mit optional folgenden beliebig vielen b und dann ein c
grepl("Ab*c",c("Abc","Ac","b","Abbbc"))
# großes A mit mindestens einem folgenden b und dann ein c
grepl("Ab+c",c("Abc","Ac","b","Abbbc"))
# großes A mit höchstens einem b und dann ein c
grepl("Ab?c",c("Abc","Ac","b","Abbbc"))
# großes A mit genau 3 b und dann ein c
grepl("Ab{3}c",c("Abc","Ac","b","Abbbc"))
# großes A mit mindestens einem b und dann ein c (wie +)
grepl("Ab{1,}c",c("Abc","Ac","b","Abbbc"))
# großes A mit einem bis drei b und dann ein c
grepl("Ab{1,3}c",c("Abc","Ac","b","Abbbc"))

Willst Du den Anfang oder Ende eines Strings überprüfen, brauchst Du die Steuerzeichen “Dach” und “Dollar”. Damit kannst Du Abfragen machen wie “Fängt die Zeichenkette mit dem folgenden Buchstaben/Wort/… an”

# ^ und $ = # Anfang und Ende des Strings
# Welche Wörter fangen mit großem oder kleinem d an
woerter[grepl("^[Dd]",woerter)]
# Welche Wörter enden mit einem t
woerter[grepl("t$",woerter)]

Sonderzeichen in regulären Ausdrücken in R

Die Frage, wie man denn nun einen Punkt, eine Klammer oder ein Fragezeichen in einem pattern vergleichen kann, stellt sich häufig. In R ist die Lösung ganz einfach, ein doppelter Backslash, also z.B. \\. für einen Punkt, \\? für ein Fragezeichen usw.

# Aufsplitten des Textes anhand .
saetze <- strsplit(text,'\\.')[[1]]

String-Suche und Ersetzen in R

Eigentlich sind die im Beispiel vorgekommen R-Befehle schon die wichtigsten zu den regulären Ausdrücken.

Mit den Befehlen grep und grepl wird ein Pattern in einem String-Vektor gesucht. Dabei gibt grep die Indizes mit einem match zurück, grepl gibt einen Vektor mit TRUE/FALSE-Werten zurück.

Mit den R-Befehlen sub und gsub lassen sich solche Pattern ersetzen. Dabei ersetzt sub das erste Vorkommen, gsub alle Vorkommen des Patterns. Meistens verwende ich gsub.

Mit strsplit könnt Ihr einen oder mehrere String anhand von Trennzeichen aufsplitten. Meistens genügt hier das Trennzeichen, aber die Funktion nimmt auch reguläre Ausdrücke an. Sehr nützlich, wenn man eine unsaubere csv-Datei hat, die mehrere Trennzeichen als Spaltentrenner enthält.

Es gibt noch mehr Funktionen, nämlich regmatches, regexpr, gregexpr und regexec, aber ehrlich gesagt benutze ich diese fast nie.

Fazit also: Merkt Euch die Befehle grepl, gsub und strsplit, mehr braucht Ihr normalerweise nicht.

Dateien eines Verzeichnisses in R anzeigen lassen

Der Befehl list.files zeigt alle Dateien und Unterordner eines Verzeichnisses an. Dabei kann man mittels des Parameters pattern die Dateinamen mittels regulärer Ausdrücke filtern. Im Databraineo R-Glossar findet Ihr einen Eintrag zu list.files mit Erklärung und Beispielen.

Online RegEx-Tools

Wer ein bisschen mit regulären Ausdrücken experimentieren will oder mal eben schnell checken, ob , der eingegebene String funktioniert, findet auf https://regexr.com/ oder https://regex101.com/ Online-Tools zum Nachschauen und Testen.

Viel Spaß beim Ausprobieren,

Euer Holger