Python-Tutorial zu regulären Ausdrücken

Reguläre Ausdrücke, oft als Regex abgekürzt, sind Zeichenfolgen, mit denen du prüfst, ob ein Muster in einem Text (String) vorkommt oder nicht. Wenn du schon mal Suchmaschinen, die Suchen-und-Ersetzen-Funktion in Textverarbeitungen oder Editoren genutzt hast, hast du Regex bereits in Aktion gesehen. Sie werden serverseitig eingesetzt, um beim Registrieren das Format von E-Mail-Adressen oder Passwörtern zu prüfen, beim Parsen von Textdateien, um bestimmte Strings zu finden, zu ersetzen oder zu löschen, und vieles mehr. Sie helfen dir, Textdaten zu verarbeiten – oft eine Voraussetzung für Data-Science-Projekte mit Text Mining.

Dieses Tutorial führt dich durch die wichtigsten Konzepte regulärer Ausdrücke mit Python. Du startest mit dem Import von re – der Python-Bibliothek für reguläre Ausdrücke. Danach siehst du, wie einfache Zeichen für exakte Treffer verwendet werden, gefolgt von Wildcards bzw. Sonderzeichen. Anschließend lernst du, Wiederholungen in deinen Regex zu nutzen. Du erfährst außerdem, wie du Gruppen und benannte Gruppen erstellst, um leichter auf Treffer zuzugreifen. Danach machst du dich mit dem Konzept von greedy vs. non-greedy Matching vertraut.

Das ist schon eine Menge – deshalb gibt es eine praktische Übersichtstabelle mit kurzen Definitionen, die dir beim Merken hilft. Unbedingt reinschauen!

Außerdem deckt dieses Tutorial einige sehr nützliche Funktionen aus der re-Bibliothek ab, darunter: compile(), search(), findall(), sub() zum Suchen und Ersetzen, split() und weitere. Du lernst auch Kompilierungs-Flags kennen, mit denen du deine Regex verbessern kannst.

Zum Schluss wartet eine Fallstudie – hier setzt du dein Wissen direkt ein! Los geht’s mit Regex...

Reguläre Ausdrücke in Python

In Python werden reguläre Ausdrücke vom Modul re unterstützt. Wenn du sie in deinen Python-Skripten nutzen willst, musst du das Modul per import einbinden:

import re

Die Bibliothek re stellt mehrere Funktionen bereit, die sie zu einer lohnenden Kompetenz machen. Einige davon siehst du in diesem Tutorial aus der Nähe.

Basis-Muster: Normale Zeichen

Viele einfache Muster kannst du in Python mit normalen Zeichen abbilden. Normale Zeichen sind die simpelsten regulären Ausdrücke. Sie matchen sich selbst exakt und haben in der Regex-Syntax keine Sonderbedeutung.

Beispiele sind "A", "a", "X", "5".

Mit normalen Zeichen kannst du einfache exakte Treffer prüfen:

pattern = r"Cookie"
sequence = "Cookie"
if re.match(pattern, sequence):
    print("Match!")
else: print("Not a match!")

Match!

Wie du im Beispiel gesehen hast, matchen die meisten Buchstaben und Zeichen sich selbst.

Die Funktion match() gibt ein Match-Objekt zurück, wenn der Text dem Muster entspricht. Andernfalls liefert sie None. Das Modul re enthält noch mehrere weitere Funktionen – einige lernst du später im Tutorial kennen.

Fürs Erste bleiben wir bei den normalen Zeichen!

Fällt dir das r am Anfang des Patterns Cookie auf?
Das ist ein Raw String Literal. Es ändert, wie das String-Literal interpretiert wird. Solche Literale werden so gespeichert, wie sie geschrieben sind.

Zum Beispiel ist \ mit einem vorangestellten r lediglich ein Backslash und wird nicht als Escape-Sequenz interpretiert. Was das mit Sonderzeichen zu tun hat, siehst du gleich. Manchmal beinhaltet die Syntax per Backslash escapte Zeichen. Damit diese nicht als Escape-Sequenzen interpretiert werden, nutzt du den Raw-String-Präfix r.

Tipp: In diesem Beispiel ist er nicht zwingend nötig; als gute Gewohnheit sorgt er jedoch für Konsistenz.

Wildcards: Sonderzeichen

Sonderzeichen matchen nicht sich selbst, sondern haben in regulären Ausdrücken eine besondere Bedeutung. Du kannst sie dir als reservierte Metazeichen vorstellen, die etwas anderes ausdrücken, als sie aussehen.

Schauen wir uns ein paar Beispiele an, um die Sonderzeichen in Aktion zu sehen...

Vorab nutzen die folgenden Beispiele zwei Funktionen: search() und group().
Mit der Suchfunktion durchläufst du die angegebene Zeichenkette und suchst die erste Position, an der die Regex ein Match erzeugt.
Die Gruppenfunktion gibt den durch die Regex gematchten String zurück. Beide Funktionen siehst du später noch ausführlicher.

Zurück zu den Sonderzeichen.

. – Ein Punkt. Matcht ein beliebiges einzelnes Zeichen außer dem Zeilenumbruch.

re.search(r'Co.k.e', 'Cookie').group()

'Cookie'

^ – Zirkumflex. Matcht den Anfang der Zeichenkette.

Hilfreich, wenn ein Dokument/Satz mit bestimmten Zeichen beginnen soll.

re.search(r'^Eat', "Eat cake!").group()

## Der folgende Code liefert jedoch nicht dasselbe Ergebnis. Probier es aus:
# re.search(r'^eat', "Let's eat cake!").group()

'Eat'

$ – Matcht das Ende der Zeichenkette.

Hilfreich, wenn ein Dokument/Satz mit bestimmten Zeichen enden soll.

re.search(r'cake$', "Cake! Let's eat cake").group()

## Die nächste Suche liefert den Wert NONE, probier es aus:
# re.search(r'cake$', "Let's get some cake on our way home!").group()

'cake'

[abc] – Matcht a oder b oder c.
[a-zA-Z0-9] – Matcht jeden Buchstaben von (a bis z) oder (A bis Z) oder (0 bis 9).

Tipp: Nicht enthaltene Zeichen lassen sich per Komplement des Sets matchen. Steht als erstes Zeichen im Set ein ^, werden alle Zeichen gematcht, die nicht im Set enthalten sind.

re.search(r'[0-6]', 'Number: 5').group()

'5'

## Matcht jedes Zeichen außer 5
re.search(r'Number: [^5]', 'Number: 0').group()

## Das hier matcht nicht und gibt daher NONE zurück
#re.search(r'Number: [^5]', 'Number: 5').group()

'Number: 0'

\ – Backslash.
Wahrscheinlich das vielseitigste Metazeichen!

• Folgt auf den Backslash ein anerkannter Escape-Character, gilt seine Sonderbedeutung (Szenario 1).
• Ist das folgende Zeichen kein anerkannter Escape-Character, wird \ wie ein normales Zeichen behandelt (Szenario 2).
• \ kann vor allen Metazeichen stehen, um ihre Sonderbedeutung aufzuheben (Szenario 3).

## (Szenario 1) Behandelt '\s' als Escape-Character, '\s' steht für ein Leerzeichen
re.search(r'Not a\sregular character', 'Not a regular character').group()

'Not a regular character'

## (Szenario 2) '\' wird als normales Zeichen behandelt, da '\r' hier kein anerkannter Escape-Character ist
re.search(r'Just a \regular character', 'Just a \regular character').group()

'Just a \regular character'

## (Szenario 3) '\s' wird mit einem zusätzlichen `\` escaped und damit als Literale '\s' interpretiert
re.search(r'Just a \\sregular character', 'Just a \sregular character').group()

'Just a \\sregular character'

Es gibt eine vordefinierte Menge an Sondersequenzen, die mit '\' beginnen und beim Suchen und Matchen sehr hilfreich sind. Ein Blick darauf...

\w – Kleines w. Matcht einen einzelnen Buchstaben, eine Ziffer oder einen Unterstrich.
\W – Großes W. Matcht jedes Zeichen, das nicht Teil von \w ist.

print("Lowercase w:", re.search(r'Co\wk\we', 'Cookie').group())

## Matcht jedes Zeichen außer Buchstabe, Ziffer oder Unterstrich
print("Uppercase W:", re.search(r'C\Wke', 'C@ke').group())

## Großes W matcht keinen einzelnen Buchstaben oder Ziffer
print("Uppercase W won't match, and return:", re.search(r'Co\Wk\We', 'Cookie'))

Lowercase w: Cookie
Uppercase W: C@ke
Uppercase W won't match, and return: None

\s – Kleines s. Matcht ein einzelnes Whitespacenzeichen wie Leerzeichen, Zeilenumbruch, Tab, Return.
\S – Großes S. Matcht jedes Zeichen, das nicht Teil von \s ist.

print("Lowercase s:", re.search(r'Eat\scake', 'Eat cake').group())
print("Uppercase S:", re.search(r'cook\Se', "Let's eat cookie").group())

Lowercase s: Eat cake
Uppercase S: cookie

\d – Kleines d. Matcht Dezimalziffern 0–9.
\D – Großes D. Matcht jedes Zeichen, das keine Dezimalziffer ist.

# Beispiel für \d
print("How many cookies do you want? ", re.search(r'\d+', '100 cookies').group())

How many cookies do you want?  100

Das +-Symbol nach \d im obigen Beispiel steht für Wiederholung. Mehr dazu im Abschnitt Wiederholungen...

\t – Kleines t. Matcht Tab.
\n – Kleines n. Matcht Zeilenumbruch.
\r – Kleines r. Matcht Return.
\A – Großes A. Matcht nur am Anfang der Zeichenkette – auch über mehrere Zeilen.
\Z – Großes Z. Matcht nur am Ende der Zeichenkette.
Tipp: ^ und \A sind effektiv gleich, ebenso $ und \Z – außer im MULTILINE-Modus. Mehr dazu im Abschnitt Flags.

\b – Kleines b. Matcht nur den Wortanfang oder das Wortende.

# Beispiel für \t
print("\\t (TAB) example: ", re.search(r'Eat\tcake', 'Eat    cake').group())

# Beispiel für \b
print("\\b match gives: ",re.search(r'\b[A-E]ookie', 'Cookie').group())

\t (TAB) example:  Eat    cake
\b match gives:  Cookie

Wiederholungen

Wenn du lange Muster in einer Zeichenkette finden willst, kann es mühsam werden. Zum Glück unterstützt das Modul re Wiederholungen mit folgenden Sonderzeichen:

+ – Prüft, ob das vorherige Zeichen ab der Position ein- oder mehrmals vorkommt.

re.search(r'Co+kie', 'Cooookie').group()

'Cooookie'

* – Prüft, ob das vorherige Zeichen ab der Position null- oder mehrmals vorkommt.

# Prüft auf beliebiges Vorkommen von a oder o oder beidem in der Sequenz
re.search(r'Ca*o*kie', 'Cookie').group()

'Cookie'

? – Prüft, ob das vorherige Zeichen ab der Position genau null- oder einmal vorkommt.

# Prüft auf genau null oder ein Vorkommen von a oder o oder beidem
re.search(r'Colou?r', 'Color').group()

'Color'

Was aber, wenn du auf eine exakte Anzahl von Wiederholungen testen willst?

Zum Beispiel bei der Validierung einer Telefonnummer in einer Anwendung. Auch das löst re elegant mit folgenden Ausdrücken:

{x} – Wiederhole genau x-mal.
{x,} – Wiederhole mindestens x-mal oder öfter.
{x, y} – Wiederhole mindestens x-, aber höchstens y-mal.

re.search(r'\d{9,10}', '0987654321').group()

'0987654321'

Die Qualifizierer + und * gelten als greedy. Was das bedeutet, siehst du gleich.

Gruppieren in regulären Ausdrücken

Mit Gruppen in Regex kannst du Teile des gematchten Textes herausgreifen. Teile eines Regex-Musters, die in Klammern () stehen, heißen Gruppen. Die Klammern ändern nicht, was gematcht wird, sondern bilden Gruppen innerhalb der Treffer. Die Funktion group() hast du in den Beispielen bereits genutzt. match.group() ohne Argument gibt wie gewohnt den gesamten gematchten Text zurück.

Verstehen wir das Konzept an einem einfachen Beispiel. Angenommen, du validierst E-Mail-Adressen und willst Benutzername und Host prüfen. Dann erstellst du separate Gruppen im gematchten Text.

statement = 'Please contact us at: support@datacamp.com'
match = re.search(r'([\w\.-]+)@([\w\.-]+)', statement)
if statement:
  print("Email address:", match.group()) # Der gesamte gematchte Text
  print("Username:", match.group(1)) # Der Benutzername (Gruppe 1)
  print("Host:", match.group(2)) # Der Host (Gruppe 2)

Email address: support@datacamp.com
Username: support
Host: datacamp.com

Alternativ kannst du <>-Klammern für benannte Gruppen verwenden. Benannte Gruppen machen deinen Code lesbarer. Die Syntax lautet: (?P<name>...). Ersetze name durch den gewünschten Gruppennamen. Die ... stehen für den restlichen Matching-Ausdruck. Hier dasselbe Beispiel in Aktion...

statement = 'Please contact us at: support@datacamp.com'
match = re.search(r'(?P<email>(?P<username>[\w\.-]+)@(?P<host>[\w\.-]+))', statement)
if statement:
  print("Email address:", match.group('email'))
  print("Username:", match.group('username'))
  print("Host:", match.group('host'))

Email address: support@datacamp.com
Username: support
Host: datacamp.com

Tipp: Du kannst benannte Gruppen immer auch per Nummer statt per Namen ansprechen. Je mehr Gruppen es werden, desto unübersichtlicher ist das über Nummern. Mach dir daher die Nutzung benannter Gruppen zur Gewohnheit.

Greedy vs. Non-Greedy Matching

Wenn ein Sonderzeichen so viel wie möglich aus der Suchsequenz (String) matcht, spricht man von einem "Greedy Match". Das ist das Standardverhalten regulärer Ausdrücke, aber manchmal ist es nicht gewünscht:

pattern = "cookie"
sequence = "Cake and cookie"

heading  = r'<h1>TITLE</h1>'
re.match(r'<.*>', heading).group()

'<h1>TITLE</h1>'

Das Pattern <.*> hat die gesamte Zeichenkette bis zum zweiten > gematcht.

Wenn du jedoch nur das erste <h1>-Tag matchen willst, kannst du den non-greedy-Qualifizierer *? nutzen, der so wenig Text wie möglich matcht.

Durch das ? nach dem Qualifizierer wird minimal – also non-greedy – gematcht: Es werden so wenige Zeichen wie möglich erfasst. Mit <.*?> erhältst du nur ein Match für <h1>.

heading  = r'<h1>TITLE</h1>'
re.match(r'<.*?>', heading).group()

'<h1>'

Übersichtstabelle

Du hast schon viel über reguläre Ausdrücke geschafft. Das sind viele Informationen und Konzepte! Die folgende Tabelle fasst alles zusammen, was du bisher gesehen hast. Kein Stress, wenn dir noch nicht alle Metazeichen in Fleisch und Blut übergegangen sind. Mit Zeit und Übung erkennst du die Besonderheiten und weißt, wann du was einsetzt...

Dieses Tutorial behandelt nicht alle in Python verfügbaren Sondersequenzen. Die vollständige Liste findest du in der Standardbibliothek.

Du hast die Regex-Grundlagen gemeistert! Es gibt jedoch noch weitere Konzepte, mit denen du noch elegantere Ausdrücke zum Suchen und Matchen schreibst.

Tipp: Regex sind mächtig und hilfreich – vermeide aber überlange, unklare Ausdrücke, die für andere (und dich) schwer zu verstehen und zu pflegen sind.

Funktionen aus "re"

Die Python-Bibliothek re bietet mehrere Funktionen, die dir die Arbeit erleichtern. Einige davon – wie re.search(), re.match() – hast du schon gesehen. Schauen wir uns mehr an...

compile(pattern, flags=0)

Reguläre Ausdrücke werden in Python als Strings gehandhabt. Mit compile() kannst du ein Regex-Pattern jedoch in ein Regex-Objekt kompilieren. Wenn du ein Pattern mehrfach im selben Programm brauchst, ist es effizienter, das kompilierte Objekt wiederzuverwenden, statt den String zu speichern. Grund ist der Cache für kompilierte Versionen der zuletzt übergebenen Patterns bei compile() und den Modul-Funktionen.

pattern = re.compile(r"cookie")
sequence = "Cake and cookie"
pattern.search(sequence).group()

'cookie'

# Das ist gleichbedeutend mit:
re.search(pattern, sequence).group()

'cookie'

search(pattern, string, flags=0)

Damit scannst du die angegebene Zeichenkette und suchst die erste Position, an der die Regex ein Match liefert. Wird eins gefunden, gibt die Funktion ein entsprechendes Match-Objekt zurück, sonst None. Beachte: None ist etwas anderes, als ein Null-Längen-Match an einer Position zu finden.

pattern = "cookie"
sequence = "Cake and cookie"

re.search(pattern, sequence)

<re.Match object; span=(9, 15), match='cookie'>

match(pattern, string, flags=0)

Gibt ein entsprechendes Match-Objekt zurück, wenn null oder mehr Zeichen am Anfang der Zeichenkette dem Pattern entsprechen. Andernfalls None, wenn die Zeichenkette nicht passt.

pattern = "C"
sequence1 = "IceCream"
sequence2 = "Cake"

# Kein Match, da "C" nicht am Anfang von "IceCream" steht
print("Sequence 1: ", re.match(pattern, sequence1))
print("Sequence 2: ", re.match(pattern,sequence2).group())

Sequence 1:  None
Sequence 2:  C

search() vs. match()

match() prüft standardmäßig nur am Anfang der Zeichenkette, während search() überall in der Zeichenkette sucht.

findall(pattern, string, flags=0)

Findet alle möglichen Treffer in der gesamten Sequenz und gibt sie als Liste von Strings zurück. Jeder zurückgegebene String repräsentiert einen Treffer.

statement = "Please contact us at: support@datacamp.com, xyz@datacamp.com"

# 'addresses' ist eine Liste, die alle möglichen Treffer speichert
addresses = re.findall(r'[\w\.-]+@[\w\.-]+', statement)
for address in addresses:
    print(address)

support@datacamp.com
xyz@datacamp.com

finditer(string, [position, end_position])

Ähnlich wie findall() – findet alle möglichen Treffer in der Sequenz, gibt aber Iteratoren von Regex-Match-Objekten zurück.

Tipp: finditer() ist ideal, wenn du mehr Informationen zu deiner Suche brauchst. Das Match-Objekt enthält nicht nur den gematchten Teil, sondern auch die Positionen im Originaltext.

statement = "Please contact us at: support@datacamp.com, xyz@datacamp.com"

# 'addresses' ist eine Liste, die alle möglichen Treffer speichert
addresses = re.finditer(r'[\w\.-]+@[\w\.-]+', statement)
for address in addresses:
    print(address)

<re.Match object; span=(22, 42), match='support@datacamp.com'>
<re.Match object; span=(44, 60), match='xyz@datacamp.com'>

sub(pattern, repl, string, count=0, flags=0)
subn(pattern, repl, string, count=0)

sub() ist die Substitute-Funktion. Sie gibt den String zurück, der entsteht, wenn die linkesten, nicht überlappenden Vorkommen des Patterns im String durch den Ersatz repl ersetzt werden. Wird kein Pattern gefunden, bleibt der String unverändert.

subn() funktioniert ähnlich wie sub(), liefert aber ein Tupel aus neuem String und der Anzahl der vorgenommenen Ersetzungen.

statement = "Please contact us at: xyz@datacamp.com"
new_email_address = re.sub(r'([\w\.-]+)@([\w\.-]+)', r'support@datacamp.com', statement)
print(new_email_address)

Please contact us at: support@datacamp.com

split(string, [maxsplit = 0])

Teilt den String überall dort, wo das Pattern matcht, und gibt eine Liste zurück. Wenn das optionale Argument maxsplit ungleich null ist, werden maximal so viele Splits durchgeführt.

statement = "Please contact us at: xyz@datacamp.com, support@datacamp.com"
pattern = re.compile(r'[:,]')

address = pattern.split(statement)
print(address)

['Please contact us at', ' xyz@datacamp.com', ' support@datacamp.com']

start() – Gibt den Startindex des Matches zurück.
end() – Gibt den Index zurück, an dem das Match endet.
span() – Gibt ein Tupel mit den Positionen (Start, Ende) des Matches zurück.

pattern = re.compile('COOKIE', re.IGNORECASE)
match = pattern.search("I am not a cookie monster")

print("Start index:", match.start())
print("End index:", match.end())
print("Tuple:", match.span())

Start index: 11
End index: 17
Tuple: (11, 17)

Kompilierungs-Flags

Ist dir der Begriff re.IGNORECASE im letzten Beispiel aufgefallen? Und seine Bedeutung?

Das Verhalten eines Ausdrucks lässt sich per Flag-Wert anpassen. Du kannst Flags als zusätzliches Argument an die Funktionen übergeben, die du in diesem Tutorial gesehen hast. Einige der nützlichsten sind:

IGNORECASE (I) – Erlaubt Groß-/Kleinschreibung zu ignorieren.
DOTALL (S) – Erlaubt, dass . jedes Zeichen matcht, auch den Zeilenumbruch.
MULTILINE (M) – Erlaubt, dass Anfang (^) und Ende ($) auch Zeilenumbrüche matchen.
VERBOSE (X) – Erlaubt Leerzeichen und Kommentare in der Regex, um sie besser lesbar zu machen.

statement = "Please contact us at: support@DataCamp.com, xyz@DATACAMP.com"

# Mit dem VERBOSE-Flag lassen sich komplexe Regex besser verstehen
pattern = re.compile(r"""
[\w\.-]+ #First part
@ #Matches @ sign within email addresses
datacamp.com #Domain
""", re.X | re.I)

addresses = re.findall(pattern, statement)                       
for address in addresses:
    print("Address: ", address)

Address:  support@DataCamp.com
Address:  xyz@DATACAMP.com

Tipp: Mehrere Flags kannst du mit bitweisem OR | kombinieren.

Fallstudie: Arbeiten mit regulären Ausdrücken

Nachdem du nun anhand einiger Beispiele gesehen hast, wie Regex in Python funktionieren, wird’s praktisch! In dieser Fallstudie setzt du dein Wissen ein.

Du arbeitest mit dem ersten Teil des kostenlosen E-Books "The Idiot" von Fjodor Dostojewski aus dem Project Gutenberg. Der Roman handelt von Fürst (Knjaz) Lew Nikolajewitsch Myschkin, einem arglosen Mann, dessen Güte, Freundlichkeit und Schlichtheit viele fälschlich für mangelnde Intelligenz und Einsicht halten. Der Titel verweist ironisch darauf.

Du wirst Regex schreiben, um den Text zu parsen und ein paar Übungen zu lösen.

import re
import requests
the_idiot_url = 'https://www.gutenberg.org/files/2638/2638-0.txt'

def get_book(url):
    # Sends a http request to get the text from project Gutenberg
    raw = requests.get(url).text
    # Discards the metadata from the beginning of the book
    start = re.search(r"\*\*\* START OF THIS PROJECT GUTENBERG EBOOK .* \*\*\*",raw ).end()
    # Discards the text starting Part 2 of the book
    stop = re.search(r"II", raw).start()
    # Keeps the relevant text
    text = raw[start:stop]
    return text

def preprocess(sentence):
    return re.sub('[^A-Za-z0-9.]+' , ' ', sentence).lower()

book = get_book(the_idiot_url)
processed_book = preprocess(book)
#print(processed_book)

• Übung: Finde die Anzahl des Pronomens "the" im Korpus. Hinweis: Verwende die Funktion len().

len(re.findall(r'the', processed_book))

302

• Übung: Ersetze jedes einzelne alleinstehende "i" im Korpus durch "I". Achte darauf, kein "i" innerhalb eines Wortes zu verändern:

processed_book = re.sub(r'\si\s', " I ", processed_book)
#print(processed_book)

• Übung: Wie oft wurde im Korpus zitiert ("")?

len(re.findall(r'\”', book))

0

• Übung: Welche Wörter sind im Korpus mit '--' verbunden?
  Probiere es selbst aus! Teile deine Antwort gern in den Kommentaren unten.

Glückwunsch!

Du hast es bis zum Ende dieses Python-Tutorials zu regulären Ausdrücken geschafft! Auf deiner Data-Science-Reise mit Python gibt es noch viel mehr zu entdecken.

Regex spielen in der Datenvorbereitung eine wichtige Rolle. Schau dir den Kurs Cleaning Data in Python von DataCamp an. Darin lernst du, deine Daten für die Analyse besser zu erkunden, aufzubereiten und zu bereinigen. Am Ende gibt es zudem eine Fallstudie, in der du dein neues Wissen anwenden kannst.

Wirf auch einen Blick auf unser Python String Replace Tutorial.