Caret: ^ und Dollar: $

Das Caret behauptet den Stringanfang; das Dollarzeichen das Stringende. Zum Beispiel matcht ^a jeden String, der mit a beginnt, während a$ jeden String matcht, der mit a endet.

Quantifier: *, +, ?, {n,m}

Diese Symbole steuern, wie oft das vorherige Element erscheinen soll.

• * – null oder mehr Mal.
• + – ein oder mehr Mal.
• ? – null oder ein Mal.
• {n,m} – mindestens n und höchstens m Mal.

Beispiele:

Häufig verwendetes Pattern: [0-9]{2,4} matcht zwei bis vier aufeinanderfolgende Ziffern.

Alternation: |

Der vertikale Strich implementiert logisches ODER. Zum Beispiel matcht a|b jeden String, der a oder b enthält.

Gruppierung: ()

Klammern gruppieren Sub-Patterns und erfassen gematchte Substrings. Beispiel: (a|b|c)xz matcht jeden String, der a, b oder c gefolgt von xz enthält.

Escaping: \

Verwenden Sie einen Backslash, um ein Metazeichen als Literal zu behandeln. Zum Beispiel matcht \$a die literale Sequenz $a anstatt $ als End-of-String-Anker zu interpretieren.

Spezielle Sequenzen

Spezielle Sequenzen vereinfachen gängige Patterns. Unten ist eine Referenzliste mit illustrierenden Beispielen.

Stringanfang: \A

Wortgrenze: \b

Nicht-Wortgrenze: \B

Ziffer: \d / Nicht-Ziffer: \D

Whitespace: \s / Nicht-Whitespace: \S

Wortzeichen: \w / Nicht-Wort: \W

Stringende: \Z

Tipp: Nutzen Sie einen Online-Regex-Tester wie regex101, um Patterns schnell zu erstellen und zu debuggen.

RegEx in Python verwenden

Pythons re-Modul bietet einen reichen Satz an Funktionen und Konstanten für Regex-Operationen. Importieren Sie es mit:

import re

Unten sind die gängigsten Utilities und ihre Verwendung.

re.findall()

Gibt eine Liste aller nicht-überlappenden Matches in einem String zurück.

# Alle Zahlen aus einem String extrahieren
import re
string = 'hallo 12 hi 89. Wie gehts 34'
pattern = '\d+'
result = re.findall(pattern, string)
print(result)  # Ausgabe: ['12', '89', '34']

Wenn kein Match gefunden wird, wird eine leere Liste zurückgegeben.

re.split()

Teilt einen String an jeder Stelle, wo das Pattern matcht, und gibt eine Liste von Substrings zurück.

import re
string = 'Zwölf:12 Neunundachtzig:89.'
pattern = '\d+'
result = re.split(pattern, string)
print(result)  # Ausgabe: ['Zwölf:', ' Neunundachtzig:', '.']

Verwenden Sie das optionale maxsplit-Argument, um die Anzahl der Splits zu begrenzen. Ein Wert von 0 (Standard) splittet bei jedem Match.

import re
string = 'Zwölf:12 Neunundachtzig:89 Neun:9.'
pattern = '\d+'
# Nur beim ersten Vorkommen splitten
result = re.split(pattern, string, 1)
print(result)  # Ausgabe: ['Zwölf:', ' Neunundachtzig:89 Neun:9.']

re.sub()

Ersetzt alle Vorkommen eines Patterns mit einem Ersetzungsstring.

# Alle Whitespace-Zeichen entfernen
import re
string = 'abc 12\nde 23 \n f45 6'
pattern = '\s+'
replace = ''
new_string = re.sub(pattern, replace, string)
print(new_string)  # Ausgabe: abc12de23f456

Um Ersetzungen zu begrenzen, geben Sie ein count-Argument an. Ein Wert von 0 ersetzt jeden Match.

new_string = re.sub(r'\s+', replace, string, 1)
print(new_string)  # Ausgabe:
# abc12de 23
# f45 6

re.subn()

Wie re.sub(), aber gibt ein Tupel zurück, das den neuen String und die Anzahl der durchgeführten Ersetzungen enthält.

new_string = re.subn(pattern, replace, string)
print(new_string)  # Ausgabe: ('abc12de23f456', 4)

re.search()

Findet die erste Position, wo das Pattern matcht.

string = "Python macht Spaß"
match = re.search('\\APython', string)
if match:
    print("Pattern im String gefunden")
else:
    print("Pattern nicht gefunden")
# Ausgabe: Pattern im String gefunden

Match-Objekt

Wenn ein Match gefunden wird, gibt re.search() ein Match-Objekt zurück. Gängige Methoden und Attribute umfassen:

• group() – der gematchte Substring.
• start() / end() – Indizes des Matches.
• span() – ein Tupel von (start, end).
• groups() – alle erfassten Gruppen.

string = '39801 356, 2102 1111'
pattern = '(\d{3}) (\d{2})'
match = re.search(pattern, string)
if match:
    print(match.group())
    print(match.group(1))
    print(match.group(2))
    print(match.groups())
    print(match.start(), match.end(), match.span())
else:
    print("pattern not found")
# Ausgabe:
# 801 35
# 801
# 35
# ('801', '35')
# 2 8 (2, 8)

Raw Strings verwenden (Präfix r)

Das Präfixieren eines String-Literals mit r behandelt Backslashes als literale Zeichen und verhindert versehentliche Escape-Sequenzen. Dies ist besonders nützlich bei Regex-Patterns.

string = '\n und \r sind Escape-Sequenzen.'
result = re.findall(r'[\n\r]', string)
print(result)  # Ausgabe: ['\n', '\r']

Für tiefergehende Erkundung des re-Moduls verweisen Sie auf die offizielle Python-Dokumentation.