Regex in Python: re-Modul

Du hast in den ersten vier Lektionen die Regex-Sprache gelernt – die Zeichen, Quantoren, Anker, Gruppen. Jetzt geht's um die Anwendung in einer konkreten Programmiersprache: Python. Pythons eingebautes re-Modul ist eine der elegantesten Regex-Implementierungen überhaupt – kompakt, mächtig, gut dokumentiert.

Diese Lektion ist deine Referenz für Python: welche Funktionen es gibt, wann du welche nimmst, was die Fallstricke sind. Außerdem: Raw-Strings, eine Python-Spezialität die du beim Regex-Schreiben fast immer brauchen wirst. Wer das nicht weiß, kämpft ständig mit verdoppelten Backslashes.

1) Das re-Modul importieren

Anders als JavaScript hat Python keine eingebaute Regex-Syntax mit Slashes. Stattdessen ist Regex eine ganz normale Standard-Library:

basics.pyPython

1import re
2
3text = "Anna ist 42 Jahre alt"
4match = re.search(r"\d+", text)
5if match:
6    print(match.group())  # → 42

Drei Dinge in diesem Mini-Beispiel:

import re – das Modul laden. Standard-Library, kein pip install nötig.
re.search(pattern, text) – durchsucht den Text. Gibt ein Match-Objekt zurück oder None.
r"\d+" – Raw-String. Das r vor dem String sagt Python: „behandle Backslashes wörtlich, nicht als Escape". Ohne das r müsstest du "\\d+" schreiben.

2) Raw-Strings: Pflichtwissen für Python-Regex

Das wichtigste Konzept aus dieser Lektion. Normale Python-Strings interpretieren Backslashes als Escape-Sequenzen: \n ist ein Newline, \t ein Tab. Aber in Regex ist \n auch ein Newline (zufällig gleich), während \d für „Ziffer" steht – Python kennt aber kein \d-Escape. Das wäre ungültig.

Lösung: Raw-Strings mit Präfix r:

Schreibweise	Python sieht	Regex bekommt
`"\d+"`	⚠ Warnung (ungültiges Escape)	`\d+` – matched eine Ziffer (Glück)
`"\\d+"`	`\d+` (doppelte Backslashes)	`\d+` ✓
`r"\d+"`	`\d+` (Raw, kein Escape)	`\d+` ✓

Die Raw-Variante ist klarer lesbar – du schreibst genau das was die Regex haben soll, ohne Backslash-Verdoppelung. Goldregel: Regex in Python immer als Raw-String schreiben. r"..." – wird zur Gewohnheit.

⚠ Stolperfalle: Raw-String mit Newline

Im Raw-String ist \n wörtlich Backslash-n, nicht ein Newline-Zeichen! Wenn du Python tatsächlich einen Newline einfügen willst (nicht als Regex-Pattern), nimm einen normalen String. Innerhalb des Patterns wird \n dann von der Regex-Engine als Newline verstanden – das passt. Bei Regex-Patterns ist Raw quasi immer richtig.

3) Die fünf Hauptfunktionen

Das re-Modul hat eine Handvoll Hauptfunktionen für die häufigen Operationen. Hier die wichtigsten – jede löst ein anderes Problem:

Die fünf re-Funktionen die du können musst

re.match(pat, text)

→ Match | None

Prüft ob das Pattern am ANFANG des Texts matched. Wie ein impliziter ^-Anker. Gibt Match-Objekt oder None.

re.search(pat, text)

→ Match | None

Sucht irgendwo im Text nach dem Pattern. Liefert ersten Treffer als Match-Objekt oder None.

re.findall(pat, text)

→ list[str]

Findet alle Vorkommen. Gibt Liste der Strings (oder Tupel bei Gruppen) zurück.

re.finditer(pat, text)

→ iterator[Match]

Wie findall, aber gibt Iterator von Match-Objekten zurück (mit Position etc.).

re.sub(pat, repl, text)

→ str

Ersetzt alle Treffer durch repl. Repl kann String mit \1-Backrefs sein oder Funktion.

re.split(pat, text)

→ list[str]

Spaltet Text am Pattern. Wie String-.split() aber mit Regex als Trenner.

re.fullmatch(pat, text)

→ Match | None

Wie match, aber Pattern muss den kompletten Text matchen. Wie impliziter ^...$. Ideal für Validierung.

re.compile(pat)

→ Pattern

Pre-compiliert ein Pattern. Auf dem Pattern-Objekt rufst du dann match/search/etc. auf. Schneller bei vielen Anwendungen.

Faustregel zur Wahl: Validieren einer Eingabe → fullmatch (das Pattern muss alles abdecken). Suchen ob's da ist → search. Alle Treffer holen → findall (Strings) oder finditer (mit Positionen). Text umwandeln → sub. Trennen → split. match ist eine Anfänger-Falle: viele denken es „matched den Text", tatsächlich nur „am Anfang". Im Zweifelsfall lieber search oder fullmatch.

4) Match-Objekte ausnutzen

Wenn match/search/finditer einen Treffer liefern, bekommst du ein Match-Objekt. Das hat mehrere nützliche Methoden:

match_methods.pyPython

1import re
2
3text = "Datum: 17.05.2026 (heute)"
4m = re.search(r"(\d{2})\.(\d{2})\.(\d{4})", text)
5
6m.group()       # '17.05.2026' (Gesamtmatch)
7m.group(0)      # '17.05.2026' (gleich)
8m.group(1)      # '17' (Gruppe 1)
9m.group(2)      # '05' (Gruppe 2)
10m.group(3)      # '2026' (Gruppe 3)
11m.groups()      # ('17', '05', '2026') - alle Gruppen als Tupel
12m.start()       # 7 (Position im Text wo Match beginnt)
13m.end()         # 17 (Position nach Match)
14m.span()        # (7, 17) - Tupel mit Start/End

Sehr praktisch: du bekommst nicht nur den Match-Text, sondern auch die Position im Original. Damit kannst du den Text vor/nach dem Match weiterverarbeiten, oder mehrere Matches mit Positionen kombinieren.

5) Named Groups in Python

Wie in L3 gezeigt: Named Groups machen Code lesbarer. Python-Syntax: (?P<name>...) mit großem P (Python-spezifisch):

named_groups.pyPython

1m = re.search(
2    r"(?P<day>\d{2})\.(?P<month>\d{2})\.(?P<year>\d{4})",
3    "17.05.2026"
4)
5m.group("day")    # '17'
6m.group("month")  # '05'
7m.group("year")   # '2026'
8m.groupdict()      # {'day': '17', 'month': '05', 'year': '2026'}

Ideal für Parser-Code wo du strukturierte Daten extrahierst. groupdict() gibt direkt ein Dictionary zurück – passt perfekt zu JSON-Verarbeitung.

6) Interaktiver Python-Tester

Probier die Methoden direkt aus. Wähle eine Funktion, gib Pattern und Text an, sieh den Python-Output direkt:

Python re-Methoden im Vergleich

Pattern:

Text:

Die wichtigsten Unterschiede auf einen Blick: search findet ersten Treffer egal wo. match matched nur ab Position 0 – „42" wird nicht gefunden wenn am Anfang „Anna" steht. fullmatch verlangt dass das Pattern den ganzen Text matched – perfekt für Eingabevalidierung. findall liefert Liste aller Treffer. sub ersetzt, split teilt am Pattern.

7) re.sub: Ersetzungen mit Power

Die sub-Funktion ist eine der mächtigsten – sie ersetzt Treffer durch beliebiges. Drei Stufen der Mächtigkeit:

1. Einfacher String-Ersatz:

sub_simple.pyPython

1re.sub(r"\s+", " ", "Hallo    Welt")
2# → 'Hallo Welt'   # mehrfache Spaces zu einem

2. Backreferences nutzen: in Python mit \1, \2 oder \g<name>:

sub_backref.pyPython

1# Datum umformatieren: 17.05.2026 → 2026-05-17
2re.sub(r"(\d{2})\.(\d{2})\.(\d{4})", r"\3-\2-\1", "17.05.2026")
3# → '2026-05-17'
4
5# Mit Named Groups (lesbarer):
6re.sub(
7    r"(?P<d>\d{2})\.(?P<m>\d{2})\.(?P<y>\d{4})",
8    r"\g<y>-\g<m>-\g<d>",
9    "17.05.2026"
10)

3. Funktion als Ersatz: für komplexe Logik gibst du eine Funktion mit. Sie bekommt das Match-Objekt und gibt den Ersatz zurück:

sub_function.pyPython

1# Alle Zahlen verdoppeln
2re.sub(r"\d+", lambda m: str(int(m.group()) * 2), "a=5, b=10")
3# → 'a=10, b=20'
4
5# Wörter zu Großbuchstaben:
6re.sub(r"\b\w+\b", lambda m: m.group().upper(), "hallo welt")
7# → 'HALLO WELT'

Diese Function-Variante ist extrem mächtig – fast schon ein Mini-Template-Engine. Du kannst auf den Match zugreifen, Berechnungen durchführen, externe Daten nachschlagen.

8) Flags: Verhalten steuern

Wie in JavaScript hat Python Flags die das Match-Verhalten ändern. Du übergibst sie als optionales Argument (mehrere mit | verknüpft):

Flag	Kurz	Wirkung
`re.IGNORECASE`	`re.I`	Case-insensitive – Groß/Kleinschreibung ignorieren
`re.MULTILINE`	`re.M`	`^`/`$` matchen Zeilenanfang/-ende statt String-Grenzen
`re.DOTALL`	`re.S`	`.` matched auch Newline
`re.VERBOSE`	`re.X`	Whitespace im Pattern ignorieren (für Lesbarkeit)
`re.ASCII`	`re.A`	`\w` nur ASCII (kein Unicode)
`re.UNICODE`	`re.U`	Unicode-Matching (Standard in Python 3)

flags.pyPython

1# Case-insensitive Suche
2re.findall(r"hallo", "Hallo Welt, HALLO!", re.IGNORECASE)
3# → ['Hallo', 'HALLO']
4
5# Mehrere Flags kombinieren:
6re.search(r"^ERROR.*", log_text, re.MULTILINE | re.IGNORECASE)

Besonders nützlich: re.VERBOSE. Damit kannst du komplexe Patterns über mehrere Zeilen mit Kommentaren schreiben:

verbose.pyPython

1phone_pattern = re.compile(r"""
  (\+49)?         # Länderkennung optional
  [\s/-]?         # Trennzeichen optional
  (\d{2,5})       # Vorwahl
  [\s/-]?         # Trennzeichen
  (\d{4,8})       # Hauptnummer
7""", re.VERBOSE)

Mit re.VERBOSE werden Whitespace und #-Kommentare im Pattern ignoriert. Dadurch wird auch ein komplexer Regex lesbar. Wer Patterns für andere wartbar machen will: re.VERBOSE nutzen.

9) Pattern vorab kompilieren

Wenn du dasselbe Pattern oft verwendest, kompiliere es einmal mit re.compile():

compile.pyPython

1# Einmal kompilieren
2phone_re = re.compile(r"\+?\d{2,3}[\s-]?\d{6,12}")
3
4# Mehrfach nutzen - schneller:
5for line in log_lines:
6    m = phone_re.search(line)
7    if m:
8        print(m.group())

Vorteile: Performance (Pattern wird nur einmal geparst), Lesbarkeit (Pattern hat einen Namen), wiederverwendbar. In Hot-Loops mit vielen Iterationen lohnt sich das immer.

Pythons re-Modul cachet zwar auch unkompilierte Patterns automatisch – aber die Lesbarkeit gewinnt allein schon weil das Pattern zentral steht.

10) Praxis-Beispiel: Log-Parser

Ein realistisches Beispiel das viele Konzepte verbindet. Wir parsen Log-Zeilen aus einer Webapp:

log_parser.pyPython

1import re
2
3# Format: 2026-05-17 14:32:15 [LEVEL] message (user=ID)
4pattern = re.compile(r"""
5    ^(?P<date>\d{4}-\d{2}-\d{2})         # Datum
6    \s+(?P<time>\d{2}:\d{2}:\d{2})        # Uhrzeit
7    \s+\[(?P<level>\w+)\]                 # Level in Klammern
8    \s+(?P<msg>.+?)                       # Message (lazy!)
9    (?:\s\(user=(?P<user>\d+)\))?        # User optional
10    $
11""", re.VERBOSE)
12
13line = "2026-05-17 14:32:15 [ERROR] Payment timeout (user=42)"
14m = pattern.fullmatch(line)
15if m:
16    print(m.groupdict())
17    # {'date': '2026-05-17', 'time': '14:32:15', 'level': 'ERROR',
18    #  'msg': 'Payment timeout', 'user': '42'}

Mit Named Groups, lazy Quantor, optionaler Non-Capturing-Group, VERBOSE-Modus – ein typisches Praxis-Pattern. Im echten Log-Parsing für eine Logging-Anwendung ist diese Methodik Standard. Mehr Details zur Validierung in L8.

11) Häufige Python-spezifische Stolperfallen

Sachen die in Python-Regex anders sind als anderswo – darauf achten:

match() vs. search(): match prüft nur am Anfang, search überall. Anfänger nutzen oft match, wundern sich warum Pattern \d+ auf „Anna 42" nichts findet. Lösung: search nutzen oder Pattern mit .*? davor anpassen.
Raw-String vergessen: "\b" ist in Python ein Backspace-Zeichen (ASCII 8), nicht ein Regex-Wortgrenzen-Anker! Mit r"\b" klappt's. Python 3.12+ warnt bei „invalid escape sequence".
findall mit Gruppen: bei einer Gruppe gibt findall die Gruppe zurück, nicht den ganzen Match. Bei mehreren Gruppen ein Tupel. Bei null Gruppen den ganzen Match. Verwirrend! Lieber finditer für vorhersagbares Verhalten.
None statt False: re.search gibt None bei nicht-Match zurück (nicht False). In if-Bedingung trotzdem ok, weil None falsy ist.
Unicode: in Python 3 ist \w standardmäßig Unicode – matched also auch ä, ö, ü und chinesische Zeichen. Wer nur ASCII will: re.ASCII-Flag.

12) Performance-Tipps

Regex in Python ist sehr schnell wenn richtig genutzt – aber es gibt Fallen:

Compile cache: re cacht die letzten ~512 Patterns automatisch. Bei vielen verschiedenen Patterns kann der Cache überlaufen → re.compile nutzen.
Anchor wenn möglich: ^pattern ist schneller als pattern wenn du nur am Anfang prüfen willst – Engine bricht früher ab.
Vermeiden: katastrophales Backtracking (siehe L4). Geschachtelte Quantoren wie (a+)+ sind gefährlich.
String-Methoden bevorzugen wenn keine Regex nötig: "foo" in text ist viel schneller als re.search("foo", text). Regex nur wenn du Patterns brauchst.
regex-Library als Alternative: Pythons Drittanbieter-Library regex (PyPI) ist mächtiger als re – unterstützt z.B. variable-length lookbehind. Bei komplexen Patterns sinnvoll.

Zusammenfassung

Pythons re-Modul: immer Raw-Strings r"..." nutzen, sonst Backslash-Hölle. Hauptfunktionen: re.search (irgendwo), re.match (nur am Anfang!), re.fullmatch (ganzer Text – ideal für Validierung), re.findall (alle Treffer), re.finditer (mit Match-Objekten), re.sub (ersetzen, String oder Funktion als Ersatz), re.compile (wiederverwendbar). Named Groups: (?P<name>...) mit P. Flags: re.IGNORECASE, re.MULTILINE, re.DOTALL, re.VERBOSE (Kommentare im Pattern für komplexe Regex).

Regex in Python: re-Modul

1) Das re-Modul importieren

2) Raw-Strings: Pflichtwissen für Python-Regex

3) Die fünf Hauptfunktionen

4) Match-Objekte ausnutzen

5) Named Groups in Python

6) Interaktiver Python-Tester

7) re.sub: Ersetzungen mit Power

8) Flags: Verhalten steuern

9) Pattern vorab kompilieren

10) Praxis-Beispiel: Log-Parser

11) Häufige Python-spezifische Stolperfallen

12) Performance-Tipps

Zusammenfassung

Anmelden

Account Registrieren und Fortschritt Speichern!

Modal title