`re` — Reguläre Ausdrucksoperationen¶

Quellcode: Lib/re/

Dieses Modul stellt Operationen zur Mustererkennung mit regulären Ausdrücken bereit, ähnlich denen, die in Perl zu finden sind.

Sowohl Muster als auch zu durchsuchende Zeichenketten können Unicode-Zeichenketten (str) als auch 8-Bit-Zeichenketten (bytes) sein. Unicode-Zeichenketten und 8-Bit-Zeichenketten dürfen jedoch nicht gemischt werden: Das heißt, Sie können keine Unicode-Zeichenkette mit einem Bytes-Muster oder umgekehrt abgleichen. Ebenso muss die Ersatzzeichenkette beim Anfordern einer Ersetzung vom selben Typ sein wie sowohl das Muster als auch die Suchzeichenkette.

Reguläre Ausdrücke verwenden den Backslash ('\'), um Sonderformen anzuzeigen oder um Sonderzeichen zu ermöglichen, die ohne ihre spezielle Bedeutung verwendet werden können. Dies kollidiert mit Pythons Verwendung desselben Zeichens für denselben Zweck in Zeichenkettenliteralen; zum Beispiel müsste man, um einen literalen Backslash abzugleichen, möglicherweise '\\\\' als Musterzeichenkette schreiben, da der reguläre Ausdruck \\ sein muss und jeder Backslash als \\ innerhalb eines regulären Python-Zeichenkettenliterals ausgedrückt werden muss. Beachten Sie außerdem, dass ungültige Escape-Sequenzen in Pythons Verwendung des Backslash in Zeichenkettenliteralen nun eine SyntaxWarning erzeugen und in Zukunft zu einem SyntaxError werden. Dieses Verhalten tritt auch dann auf, wenn es sich um eine gültige Escape-Sequenz für einen regulären Ausdruck handelt.

Die Lösung besteht darin, Pythons Raw-String-Notation für reguläre Ausdrucksmuster zu verwenden; Backslashes werden in einem Zeichenkettenliteral, dem 'r' vorangestellt ist, nicht speziell behandelt. Also ist r"\n" eine zweizeichige Zeichenkette, die '\' und 'n' enthält, während "\n" eine einzeichenige Zeichenkette ist, die einen Zeilenumbruch enthält. Normalerweise werden Muster im Python-Code mit dieser Raw-String-Notation ausgedrückt.

Es ist wichtig zu beachten, dass die meisten Operationen für reguläre Ausdrücke als Modulfunktionen und Methoden für kompilierte reguläre Ausdrücke verfügbar sind. Die Funktionen sind Verknüpfungen, die nicht erfordern, dass Sie zuerst ein Regex-Objekt kompilieren, aber einige Feinabstimmungsparameter fehlen.

Siehe auch

Das Drittanbieter-Modul regex, das eine API hat, die mit dem Standardbibliotheksmodul re kompatibel ist, aber zusätzliche Funktionalität und eine gründlichere Unicode-Unterstützung bietet.

Syntax regulärer Ausdrücke¶

Ein regulärer Ausdruck (oder RE) spezifiziert eine Menge von Zeichenketten, die dazu passen; die Funktionen in diesem Modul lassen Sie prüfen, ob eine bestimmte Zeichenkette zu einem gegebenen regulären Ausdruck passt (oder ob ein gegebener regulärer Ausdruck zu einer bestimmten Zeichenkette passt, was auf dasselbe hinausläuft).

Reguläre Ausdrücke können verkettet werden, um neue reguläre Ausdrücke zu bilden; wenn A und B beides reguläre Ausdrücke sind, dann ist AB auch ein regulärer Ausdruck. Im Allgemeinen gilt: Wenn eine Zeichenkette p zu A passt und eine andere Zeichenkette q zu B passt, dann passt die Zeichenkette pq zu AB. Dies gilt, es sei denn, A oder B enthalten Operationen mit niedriger Priorität; Begrenzungen zwischen A und B; oder haben nummerierte Gruppenreferenzen. So können komplexe Ausdrücke leicht aus einfacheren primitiven Ausdrücken wie den hier beschriebenen aufgebaut werden. Details zur Theorie und Implementierung von regulären Ausdrücken finden Sie im Friedl-Buch [Frie09] oder in praktisch jedem Lehrbuch über Compilerbau.

Eine kurze Erklärung des Formats von regulären Ausdrücken folgt. Weitere Informationen und eine sanftere Darstellung finden Sie im Regular Expression HOWTO.

Reguläre Ausdrücke können sowohl Sonder- als auch normale Zeichen enthalten. Die meisten normalen Zeichen, wie 'A', 'a' oder '0', sind die einfachsten regulären Ausdrücke; sie passen einfach auf sich selbst. Sie können normale Zeichen verketten, sodass last auf die Zeichenkette 'last' passt. (Im Rest dieses Abschnitts werden wir REs in diesem Sonderstil schreiben, normalerweise ohne Anführungszeichen, und Zeichenketten, die abgeglichen werden sollen, 'in einfachen Anführungszeichen'.)

Einige Zeichen, wie '|' oder '(', sind speziell. Sonderzeichen stehen entweder für Klassen von normalen Zeichen oder beeinflussen, wie die umgebenden regulären Ausdrücke interpretiert werden.

Wiederholungsoperatoren oder Quantifizierer (*, +, ?, {m,n}, etc.) können nicht direkt verschachtelt werden. Dies vermeidet Mehrdeutigkeit mit dem nicht-gierigen Modifikator-Suffix ? und mit anderen Modifikatoren in anderen Implementierungen. Um eine zweite Wiederholung auf eine innere Wiederholung anzuwenden, können Klammern verwendet werden. Zum Beispiel passt der Ausdruck (?:a{6})* auf jede Vielfache von sechs 'a'-Zeichen.

Die Sonderzeichen sind

.: (Punkt.) Im Standardmodus passt dies auf jedes Zeichen außer einem Zeilenumbruch. Wenn das Flag DOTALL angegeben wurde, passt dies auf jedes Zeichen, einschließlich eines Zeilenumbruchs. (?s:.) passt auf jedes Zeichen unabhängig von den Flags.

^: (Caret.) Passt auf den Anfang der Zeichenkette und passt im MULTILINE-Modus auch unmittelbar nach jedem Zeilenumbruch.

$: Passt auf das Ende der Zeichenkette oder kurz vor den Zeilenumbruch am Ende der Zeichenkette, und passt im MULTILINE-Modus auch vor einem Zeilenumbruch. foo passt sowohl auf 'foo' als auch auf 'foobar', während der reguläre Ausdruck foo$ nur auf 'foo' passt. Interessanterweise passt die Suche nach foo.$ in 'foo1\nfoo2\n' im normalen Modus auf 'foo2', aber im MULTILINE-Modus auf 'foo1'; die Suche nach einem einzelnen $ in 'foo\n' findet zwei (leere) Treffer: einen kurz vor dem Zeilenumbruch und einen am Ende der Zeichenkette.

*: Bewirkt, dass der resultierende RE 0 oder mehr Wiederholungen des vorhergehenden REs abgleicht, so viele Wiederholungen wie möglich. ab* passt auf 'a', 'ab' oder 'a', gefolgt von einer beliebigen Anzahl von 'b's.

+: Bewirkt, dass der resultierende RE 1 oder mehr Wiederholungen des vorhergehenden REs abgleicht. ab+ passt auf 'a', gefolgt von einer beliebigen nicht-null Anzahl von 'b's; es passt nicht nur auf 'a'.

?: Bewirkt, dass der resultierende RE 0 oder 1 Wiederholungen des vorhergehenden REs abgleicht. ab? passt auf entweder 'a' oder 'ab'.

*?, +?, ??: Die Quantifizierer '*', '+' und '?' sind alle gierig; sie passen so viel Text wie möglich. Manchmal ist dieses Verhalten unerwünscht; wenn der RE <.*> gegen '<a> b <c>' abgeglichen wird, passt er auf die gesamte Zeichenkette und nicht nur auf '<a>'. Das Hinzufügen von ? nach dem Quantifizierer bewirkt, dass er den Abgleich im nicht-gierigen oder minimalen Modus durchführt; es werden so wenige Zeichen wie möglich abgeglichen. Die Verwendung des RE <.*?> passt nur auf '<a>'.

*+, ++, ?+: Ähnlich wie die Quantifizierer '*', '+' und '?' passen auch diejenigen, bei denen '+' angehängt ist, so oft wie möglich. Im Gegensatz zu den echten gierigen Quantifizierern erlauben diese jedoch kein Backtracking, wenn der folgende Ausdruck nicht passt. Dies sind sogenannte possessive Quantifizierer. Zum Beispiel passt a*a auf 'aaaa', weil a* alle 4 'a's abgleicht, aber wenn das endgültige 'a' angetroffen wird, wird der Ausdruck zurückverfolgt, sodass am Ende a* insgesamt 3 'a's abgleicht und das vierte 'a' durch das endgültige 'a' abgeglichen wird. Wenn jedoch a*+a verwendet wird, um 'aaaa' abzugleichen, passt a*+ auf alle 4 'a', aber wenn das endgültige 'a' keine weiteren Zeichen zum Abgleichen findet, kann der Ausdruck nicht zurückverfolgt werden und schlägt somit fehl. x*+, x++ und x?+ sind äquivalent zu (?>x*), (?>x+) und (?>x?) entsprechend.

Hinzugefügt in Version 3.11.

{m}: Gibt an, dass genau m Kopien des vorherigen REs abgeglichen werden sollen; weniger Treffer führen dazu, dass der gesamte RE nicht passt. Zum Beispiel passt a{6} auf genau sechs 'a'-Zeichen, aber nicht auf fünf.
{m,n}: Bewirkt, dass der resultierende RE von m bis n Wiederholungen des vorherigen REs abgleicht, wobei versucht wird, so viele Wiederholungen wie möglich abzugleichen. Zum Beispiel passt a{3,5} auf 3 bis 5 'a'-Zeichen. Wenn m weggelassen wird, wird eine untere Grenze von null angegeben, und wenn n weggelassen wird, wird eine unendliche obere Grenze angegeben. Als Beispiel passt a{4,}b auf 'aaaab' oder tausend 'a'-Zeichen gefolgt von einem 'b', aber nicht auf 'aaab'. Das Komma darf nicht weggelassen werden, da der Modifikator sonst mit der zuvor beschriebenen Form verwechselt würde.
{m,n}?: Bewirkt, dass der resultierende RE von m bis n Wiederholungen des vorherigen REs abgleicht, wobei versucht wird, so wenige Wiederholungen wie möglich abzugleichen. Dies ist die nicht-gierige Version des vorherigen Quantifizierers. Zum Beispiel passt auf der 6-zeichenlangen Zeichenkette 'aaaaaa' a{3,5} auf 5 'a'-Zeichen, während a{3,5}? nur 3 Zeichen abgleicht.
{m,n}+: Bewirkt, dass der resultierende RE von m bis n Wiederholungen des vorherigen REs abgleicht, wobei versucht wird, so viele Wiederholungen wie möglich abzugleichen, ohne Backtracking-Punkte einzurichten. Dies ist die possessive Version des obigen Quantifizierers. Zum Beispiel versucht a{3,5}+aa auf der 6-zeichenlangen Zeichenkette 'aaaaaa', 5 'a'-Zeichen abzugleichen, und benötigt dann 2 weitere 'a's, mehr Zeichen als verfügbar, und schlägt somit fehl, während a{3,5}aa mit a{3,5} 5 abgleicht, dann 4 'a's durch Backtracking und dann die endgültigen 2 'a's durch das endgültige aa im Muster abgeglichen werden. x{m,n}+ ist äquivalent zu (?>x{m,n}).

Hinzugefügt in Version 3.11.

\

Escapet Sonderzeichen (damit Sie Zeichen wie '*', '?' usw. abgleichen können) oder signalisiert eine Sondersequenz; Sondersequenzen werden unten besprochen.

Wenn Sie keinen Raw-String zur Angabe des Musters verwenden, denken Sie daran, dass Python den Backslash auch als Escape-Sequenz in Zeichenkettenliteralen verwendet; wenn die Escape-Sequenz vom Python-Parser nicht erkannt wird, werden der Backslash und das folgende Zeichen in die resultierende Zeichenkette aufgenommen. Wenn Python die resultierende Sequenz jedoch erkennen würde, muss der Backslash zweimal wiederholt werden. Dies ist kompliziert und schwer zu verstehen, daher wird dringend empfohlen, Raw-Strings für alle außer den einfachsten Ausdrücken zu verwenden.

[]

Wird verwendet, um eine Zeichenmenge anzugeben. In einer Menge

Zeichen können einzeln aufgeführt werden, z. B. passt [amk] auf 'a', 'm' oder 'k'.

Zeichenbereiche können angegeben werden, indem zwei Zeichen angegeben und durch ein '-' getrennt werden. Zum Beispiel passt [a-z] auf jeden Kleinbuchstaben der ASCII-Zeichen, [0-5][0-9] passt auf alle zweistelligen Zahlen von 00 bis 59 und [0-9A-Fa-f] passt auf jede Hexadezimalziffer. Wenn - escaped wird (z. B. [a\-z]) oder wenn es als erstes oder letztes Zeichen platziert wird (z. B. [-a] oder [a-]), passt es auf ein literales '-'.
Sonderzeichen außer dem Backslash verlieren ihre Sonderbedeutung innerhalb von Mengen. Zum Beispiel passt [(+*)] auf jedes der literalen Zeichen '(', '+', '*' oder ')'.

Ein Backslash escapet entweder Zeichen, die in einer Menge eine Sonderbedeutung haben, wie '-', ']', '^' und '\\' selbst, oder signalisiert eine Sondersequenz, die ein einzelnes Zeichen darstellt, wie \xa0 oder \n, oder eine Zeichenklasse, wie \w oder \S (weiter unten definiert). Beachten Sie, dass \b ein einzelnes "Backspace"-Zeichen darstellt, nicht eine Wortgrenze wie außerhalb einer Menge, und numerische Escapes wie \1 immer Oktal-Escapes sind, keine Gruppenreferenzen. Sondersequenzen, die kein einzelnes Zeichen abgleichen, wie \A und \z, sind nicht erlaubt.

Zeichen, die nicht innerhalb eines Bereichs liegen, können durch Komplementierung der Menge abgeglichen werden. Wenn das erste Zeichen der Menge '^' ist, werden alle Zeichen abgeglichen, die nicht in der Menge enthalten sind. Zum Beispiel passt [^5] auf jedes Zeichen außer '5', und [^^] passt auf jedes Zeichen außer '^'. ^ hat keine Sonderbedeutung, wenn es nicht das erste Zeichen in der Menge ist.
Um einen literalen ']' innerhalb einer Menge abzugleichen, stellen Sie ihm einen Backslash voran oder platzieren Sie ihn am Anfang der Menge. Zum Beispiel passen sowohl [()[\]{}] als auch []()[{}] auf eine rechte Klammer sowie eine linke Klammer, geschweifte Klammern und runde Klammern.

Die Unterstützung für verschachtelte Mengen und Mengenoperationen gemäß Unicode Technical Standard #18 könnte in Zukunft hinzugefügt werden. Dies würde die Syntax ändern, daher wird zur Erleichterung dieser Änderung vorerst eine FutureWarning in mehrdeutigen Fällen ausgelöst. Dazu gehören Mengen, die mit einem literalen '[' beginnen oder literale Zeichenfolgen '--', '&&', '~~' und '||' enthalten. Um eine Warnung zu vermeiden, escapen Sie diese mit einem Backslash.

Geändert in Version 3.7: FutureWarning wird ausgelöst, wenn eine Zeichenmenge Konstrukte enthält, die sich in Zukunft semantisch ändern werden.

|: A|B, wobei A und B beliebige REs sein können, erstellt einen regulären Ausdruck, der entweder A oder B abgleicht. Eine beliebige Anzahl von REs kann auf diese Weise durch '|' getrennt werden. Dies kann auch innerhalb von Gruppen (siehe unten) verwendet werden. Wenn die Zielzeichenkette durchsucht wird, werden die durch '|' getrennten REs von links nach rechts ausprobiert. Wenn ein Muster vollständig passt, wird dieser Zweig akzeptiert. Das bedeutet, dass, sobald A passt, B nicht weiter getestet wird, selbst wenn es einen längeren Gesamtmatch ergeben würde. Mit anderen Worten, der Operator '|' ist niemals gierig. Um ein literales '|' abzugleichen, verwenden Sie \| oder schließen Sie es in eine Zeichenmenge ein, wie in [|].

(...): Gleicht den regulären Ausdruck ab, der sich in den Klammern befindet, und kennzeichnet den Anfang und das Ende einer Gruppe; der Inhalt einer Gruppe kann nach einem erfolgreichen Abgleich abgerufen und später in der Zeichenkette mit der unten beschriebenen Sondersequenz \number abgeglichen werden. Um die literalen Zeichen '(' oder ')' abzugleichen, verwenden Sie $ oder $, oder schließen Sie sie in eine Zeichenmenge ein: [(], [)].

(?...)

Dies ist eine Erweiterungssyntax (ein '?' nach einem '(' ist sonst nicht aussagekräftig). Das erste Zeichen nach dem '?' bestimmt die Bedeutung und weitere Syntax des Konstrukts. Erweiterungen erstellen normalerweise keine neue Gruppe; (?P<name>...) ist die einzige Ausnahme von dieser Regel. Nachfolgend sind die derzeit unterstützten Erweiterungen aufgeführt.

(?aiLmsux)

(Ein oder mehrere Buchstaben aus der Menge 'a', 'i', 'L', 'm', 's', 'u', 'x'.) Die Gruppe gleicht die leere Zeichenkette ab; die Buchstaben setzen die entsprechenden Flags für den gesamten regulären Ausdruck

re.A (nur ASCII-Abgleich)
re.I (Groß-/Kleinschreibung ignorieren)
re.L (lokal abhängig)
re.M (mehrzeilig)
re.S (Punkt entspricht allem)
re.U (Unicode-Abgleich)
re.X (verbose)

(Die Flags werden in Modulinhalte beschrieben.) Dies ist nützlich, wenn Sie die Flags als Teil des regulären Ausdrucks aufnehmen möchten, anstatt ein flag-Argument an die Funktion re.compile() zu übergeben. Flags sollten zuerst in der Ausdruckszeichenkette verwendet werden.

Geändert in Version 3.11: Diese Konstruktion kann nur am Anfang des Ausdrucks verwendet werden.

(?:...)

Eine nicht-erfassende Version von regulären Klammern. Gleicht den regulären Ausdruck ab, der sich in den Klammern befindet, aber die von der Gruppe abgeglichene Teilzeichenkette kann nach Ausführung eines Abgleichs *nicht* abgerufen oder später im Muster referenziert werden.

(?aiLmsux-imsx:...)

(Null oder mehr Buchstaben aus der Menge 'a', 'i', 'L', 'm', 's', 'u', 'x', optional gefolgt von '-' gefolgt von einem oder mehreren Buchstaben aus 'i', 'm', 's', 'x'.) Die Buchstaben setzen oder entfernen die entsprechenden Flags für den Teil des Ausdrucks

re.A (nur ASCII-Abgleich)
re.I (Groß-/Kleinschreibung ignorieren)
re.L (lokal abhängig)
re.M (mehrzeilig)
re.S (Punkt entspricht allem)
re.U (Unicode-Abgleich)
re.X (verbose)

(Die Flags werden in Modulinhalte beschrieben.)

Die Buchstaben 'a', 'L' und 'u' sind als Inline-Flags gegenseitig ausschließend, daher können sie nicht kombiniert oder '-' folgen. Stattdessen überschreibt einer von ihnen den Abgleichmodus in der umschließenden Gruppe, wenn er in einer Inline-Gruppe vorkommt. In Unicode-Mustern schaltet (?a:...) auf reinen ASCII-Abgleich um, und (?u:...) schaltet auf Unicode-Abgleich (Standard) um. In Bytes-Mustern schaltet (?L:...) auf lokal abhängigen Abgleich um, und (?a:...) schaltet auf reinen ASCII-Abgleich (Standard) um. Diese Überschreibung gilt nur für die enge Inline-Gruppe, und der ursprüngliche Abgleichmodus wird außerhalb der Gruppe wiederhergestellt.

Hinzugefügt in Version 3.6.

Geändert in Version 3.7: Die Buchstaben 'a', 'L' und 'u' können auch in einer Gruppe verwendet werden.

(?>...)

Versucht, ... so abzugleichen, als wäre es ein separates reguläres Ausdrucksmuster, und wenn erfolgreich, wird versucht, den Rest des Musters abzugleichen. Wenn das nachfolgende Muster nicht übereinstimmt, kann der Stack nur bis zu einem Punkt *vor* dem (?>...) zurückgerollt werden, da der Ausdruck, bekannt als atomare Gruppe, sobald er verlassen wurde, alle Stack-Punkte innerhalb von sich selbst verworfen hat. Daher würde (?>.*). nichts abgleichen, da zuerst .* alle möglichen Zeichen abgleichen würde und dann, da nichts mehr abzugleichen ist, der letzte Punkt . nicht übereinstimmen würde. Da keine Stack-Punkte in der atomaren Gruppe gespeichert sind und davor kein Stack-Punkt vorhanden ist, würde der gesamte Ausdruck fehlschlagen.

Hinzugefügt in Version 3.11.

(?P<name>...)

Ähnlich wie normale Klammern, aber die vom Gruppentreffer übereinstimmende Teilzeichenkette ist über den symbolischen Gruppennamen name zugänglich. Gruppennamen müssen gültige Python-Bezeichner sein, und in bytes-Mustern dürfen sie nur Bytes im ASCII-Bereich enthalten. Jeder Gruppennamen muss innerhalb eines regulären Ausdrucks nur einmal definiert werden. Eine symbolische Gruppe ist auch eine nummerierte Gruppe, so als ob die Gruppe nicht benannt wäre.

Benannte Gruppen können in drei Kontexten referenziert werden. Wenn das Muster (?P<quote>['"]).*?(?P=quote) ist (d.h. eine Zeichenkette abgleichen, die entweder mit einfachen oder doppelten Anführungszeichen zitiert ist)

Kontext der Referenz auf Gruppe „quote“	Möglichkeiten, sie zu referenzieren
im Muster selbst	`(?P=quote)` (wie gezeigt) `\1`
bei der Verarbeitung des Trefferobjekts m	`m.group('quote')` `m.end('quote')` (usw.)
in einer Zeichenkette, die an das Argument repl von `re.sub()` übergeben wird	`\g<quote>` `\g<1>` `\1`

Geändert in Version 3.12: In bytes-Mustern kann der Gruppenname name nur Bytes im ASCII-Bereich (b'\x00'-b'\x7f') enthalten.

(?P=name): Eine Rückreferenz auf eine benannte Gruppe; sie gleicht jeden Text ab, der von der früheren Gruppe namens name abgeglichen wurde.

(?#...): Ein Kommentar; der Inhalt der Klammern wird einfach ignoriert.

(?=...): Passt, wenn ... als nächstes passt, verbraucht aber keine Zeichen aus der Zeichenkette. Dies wird als Lookahead-Assertion bezeichnet. Zum Beispiel gleicht Isaac (?=Asimov) nur dann 'Isaac ' ab, wenn ihm 'Asimov' folgt.

(?!...): Passt, wenn ... nicht als nächstes passt. Dies ist eine negative Lookahead-Assertion. Zum Beispiel gleicht Isaac (?!Asimov) nur dann 'Isaac ' ab, wenn ihm *nicht* 'Asimov' folgt.

(?<=...)

Passt, wenn die aktuelle Position in der Zeichenkette einem Treffer für ... vorausgeht, der an der aktuellen Position endet. Dies wird als positive Lookbehind-Assertion bezeichnet. (?<=abc)def findet einen Treffer in 'abcdef', da die Lookbehind-Assertion 3 Zeichen zurückspringt und prüft, ob das enthaltene Muster übereinstimmt. Das enthaltene Muster darf nur Zeichenketten einer bestimmten festen Länge abgleichen, d.h. abc oder a|b sind erlaubt, aber a* und a{3,4} nicht. Beachten Sie, dass Muster, die mit positiven Lookbehind-Assertionen beginnen, nicht am Anfang der durchsuchten Zeichenkette übereinstimmen; Sie möchten wahrscheinlich die Funktion search() anstelle der Funktion match() verwenden.

>>> import re
>>> m = re.search('(?<=abc)def', 'abcdef')
>>> m.group(0)
'def'

Dieses Beispiel sucht nach einem Wort, das einem Bindestrich folgt

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'

Geändert in Version 3.5: Unterstützung für Gruppenreferenzen fester Länge hinzugefügt.

(?<!...): Passt, wenn die aktuelle Position in der Zeichenkette keinem Treffer für ... vorausgeht. Dies ist eine negative Lookbehind-Assertion. Ähnlich wie bei positiven Lookbehind-Assertionen muss das enthaltene Muster nur Zeichenketten einer bestimmten festen Länge abgleichen. Muster, die mit negativen Lookbehind-Assertionen beginnen, können am Anfang der durchsuchten Zeichenkette übereinstimmen.

(?(id/name)ja-muster|nein-muster): Versucht, mit ja-muster übereinzustimmen, wenn die Gruppe mit der angegebenen id oder dem namen existiert, und mit nein-muster, wenn sie nicht existiert. nein-muster ist optional und kann weggelassen werden. Zum Beispiel ist (<)?(\w+@\w+(?:\.\w+)+)(?(1)>|$) ein schlechtes E-Mail-Muster, das sowohl '<user@host.com>' als auch 'user@host.com' abgleicht, aber nicht '<user@host.com' oder 'user@host.com>'.

Geändert in Version 3.12: Gruppen-id darf nur ASCII-Ziffern enthalten. In bytes-Mustern darf der Gruppenname name nur Bytes im ASCII-Bereich (b'\x00'-b'\x7f') enthalten.

Die speziellen Sequenzen bestehen aus '\' und einem Zeichen aus der folgenden Liste. Wenn das normale Zeichen keine ASCII-Ziffer oder kein ASCII-Buchstabe ist, dann gleicht der resultierende RE das zweite Zeichen ab. Zum Beispiel gleicht \$ das Zeichen '$' ab.

\number: Gleicht den Inhalt der Gruppe mit derselben Nummer ab. Gruppen werden ab 1 nummeriert. Zum Beispiel gleicht (.+) \1 'the the' oder '55 55' ab, aber nicht 'thethe' (beachten Sie das Leerzeichen nach der Gruppe). Diese spezielle Sequenz kann nur verwendet werden, um eine der ersten 99 Gruppen abzugleichen. Wenn die erste Ziffer von number 0 ist oder number 3 Oktalziffern lang ist, wird sie nicht als Gruppenreferenz interpretiert, sondern als das Zeichen mit dem Oktalwert number. Innerhalb von '[' und ']' einer Zeichenklasse werden alle numerischen Escapes als Zeichen behandelt.

\A: Passt nur am Anfang der Zeichenkette.

\b

Gleicht die leere Zeichenkette ab, aber nur am Anfang oder Ende eines Wortes. Ein Wort wird als eine Folge von Wortzeichen definiert. Beachten Sie, dass \b formal als die Grenze zwischen einem \w und einem \W Zeichen (oder umgekehrt) oder zwischen \w und dem Anfang oder Ende der Zeichenkette definiert ist. Dies bedeutet, dass r'\bat\b' 'at', 'at.', '(at)' und 'as at ay' abgleicht, aber nicht 'attempt' oder 'atlas'.

Die Standard-Wortzeichen in Unicode (str) Mustern sind Unicode-Alphanumerika und der Unterstrich, dies kann jedoch durch Verwendung des ASCII-Flags geändert werden. Wortgrenzen werden durch die aktuelle Locale bestimmt, wenn das LOCALE-Flag verwendet wird.

Hinweis

Innerhalb eines Zeichenbereichs repräsentiert \b das Backspace-Zeichen, zur Kompatibilität mit Python-Zeichenkettenliteralen.

\B: Gleicht die leere Zeichenkette ab, aber nur, wenn sie sich *nicht* am Anfang oder Ende eines Wortes befindet. Dies bedeutet, dass r'at\B' 'athens', 'atom', 'attorney' abgleicht, aber nicht 'at', 'at.' oder 'at!'. \B ist das Gegenteil von \b, daher sind Wortzeichen in Unicode (str) Mustern Unicode-Alphanumerika oder der Unterstrich, obwohl dies durch Verwendung des ASCII-Flags geändert werden kann. Wortgrenzen werden durch die aktuelle Locale bestimmt, wenn das LOCALE-Flag verwendet wird.

Geändert in Version 3.14: \B gleicht jetzt eine leere Eingabezeichenkette ab.

\d

Für Unicode (str) Muster

Gleicht jede Unicode-Dezimalziffer ab (d.h. jedes Zeichen in der Unicode-Zeichenkategorie [Nd]). Dies schließt [0-9] ein und auch viele andere Ziffernzeichen.

Gleicht [0-9] ab, wenn das ASCII-Flag verwendet wird.

Für 8-Bit (bytes) Muster

Gleicht jede Dezimalziffer im ASCII-Zeichensatz ab; dies ist äquivalent zu [0-9].

\D

Gleicht jedes Zeichen ab, das keine Dezimalziffer ist. Dies ist das Gegenteil von \d.

Gleicht [^0-9] ab, wenn das ASCII-Flag verwendet wird.

\s

Für Unicode (str) Muster

Gleicht Unicode-Leerzeichenzeichen ab (wie definiert durch str.isspace()). Dies schließt [ \t\n\r\f\v] ein und auch viele andere Zeichen, zum Beispiel die nicht-brechenden Leerzeichen, die in vielen Sprachen typografisch vorgeschrieben sind.

Gleicht [ \t\n\r\f\v] ab, wenn das ASCII-Flag verwendet wird.

Für 8-Bit (bytes) Muster

Gleicht Zeichen ab, die im ASCII-Zeichensatz als Leerzeichen gelten; dies ist äquivalent zu [ \t\n\r\f\v].

\S

Gleicht jedes Zeichen ab, das kein Leerzeichen ist. Dies ist das Gegenteil von \s.

Gleicht [^ \t\n\r\f\v] ab, wenn das ASCII-Flag verwendet wird.

\w

Für Unicode (str) Muster

Gleicht Unicode-Wortzeichen ab; dies schließt alle Unicode-Alphanumerika (wie definiert durch str.isalnum()) sowie den Unterstrich (_) ein.

Gleicht [a-zA-Z0-9_] ab, wenn das ASCII-Flag verwendet wird.

Für 8-Bit (bytes) Muster

Gleicht Zeichen ab, die im ASCII-Zeichensatz als alphanumerisch gelten; dies ist äquivalent zu [a-zA-Z0-9_]. Wenn das LOCALE-Flag verwendet wird, gleicht es Zeichen ab, die in der aktuellen Locale als alphanumerisch gelten, sowie den Unterstrich.

\W

Gleicht jedes Zeichen ab, das kein Wortzeichen ist. Dies ist das Gegenteil von \w. Standardmäßig werden Nicht-Unterstrich-Zeichen (_) abgeglichen, für die str.isalnum() False zurückgibt.

Gleicht [^a-zA-Z0-9_] ab, wenn das ASCII-Flag verwendet wird.

Wenn das LOCALE-Flag verwendet wird, gleicht es Zeichen ab, die weder in der aktuellen Locale alphanumerisch sind noch der Unterstrich.

\z: Passt nur am Ende der Zeichenkette.

Hinzugefügt in Version 3.14.
\Z: Dasselbe wie \z. Zur Kompatibilität mit alten Python-Versionen.

Die meisten Escape-Sequenzen, die von Python-Zeichenkettenliteralen unterstützt werden, werden auch vom Parser für reguläre Ausdrücke akzeptiert

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\

(Beachten Sie, dass \b zur Darstellung von Wortgrenzen verwendet wird und nur innerhalb von Zeichenklassen „Backspace“ bedeutet.)

'\u', '\U' und '\N' Escape-Sequenzen werden nur in Unicode (str) Mustern erkannt. In Bytes-Mustern sind sie Fehler. Unbekannte Escapes von ASCII-Buchstaben sind für die zukünftige Verwendung reserviert und werden als Fehler behandelt.

Oktale Escapes werden in begrenzter Form aufgenommen. Wenn die erste Ziffer eine 0 ist oder wenn es drei Oktalziffern gibt, wird dies als oktale Escape interpretiert. Andernfalls ist es eine Gruppenreferenz. Wie bei Zeichenkettenliteralen sind oktale Escapes immer maximal drei Ziffern lang.

Geändert in Version 3.3: Die Escape-Sequenzen '\u' und '\U' wurden hinzugefügt.

Geändert in Version 3.6: Unbekannte Escapes, die aus '\' und einem ASCII-Buchstaben bestehen, sind nun Fehler.

Geändert in Version 3.8: Die Escape-Sequenz '\N{name}' wurde hinzugefügt. Wie bei Zeichenkettenliteralen expandiert sie zum benannten Unicode-Zeichen (z.B. '\N{EM DASH}').

Modulinhalt¶

Das Modul definiert mehrere Funktionen, Konstanten und eine Ausnahme. Einige der Funktionen sind vereinfachte Versionen der voll ausgestatteten Methoden für kompilierte reguläre Ausdrücke. Die meisten nicht-trivialen Anwendungen verwenden immer die kompilierte Form.

Flags¶

Geändert in Version 3.6: Flag-Konstanten sind jetzt Instanzen von RegexFlag, einer Unterklasse von enum.IntFlag.

class re.RegexFlag¶: Eine enum.IntFlag-Klasse, die die unten aufgeführten Regex-Optionen enthält.

Hinzugefügt in Version 3.11: - zu __all__ hinzugefügt

re.A¶

re.ASCII¶

Bewirkt, dass \w, \W, \b, \B, \d, \D, \s und \S nur ASCII-Abgleiche durchführen, anstatt vollständige Unicode-Abgleiche. Dies ist nur für Unicode (str) Muster aussagekräftig und wird für Bytes-Muster ignoriert.

Entspricht dem Inline-Flag (?a).

Hinweis

Das Flag U existiert noch aus Kompatibilitätsgründen, ist aber in Python 3 redundant, da Treffer für str-Muster standardmäßig Unicode sind und für Bytes-Muster kein Unicode-Abgleich erlaubt ist. UNICODE und das Inline-Flag (?u) sind ebenfalls redundant.

re.DEBUG¶

Zeigt Debug-Informationen über den kompilierten Ausdruck an.

Kein entsprechendes Inline-Flag.

re.I¶

re.IGNORECASE¶

Führt einen nicht beachtenden Groß-/Kleinschreibung-Abgleich durch; Ausdrücke wie [A-Z] gleichen auch Kleinbuchstaben ab. Vollständiger Unicode-Abgleich (wie Ü mit ü) funktioniert ebenfalls, es sei denn, das ASCII-Flag wird verwendet, um Nicht-ASCII-Abgleiche zu deaktivieren. Die aktuelle Locale ändert die Wirkung dieses Flags nicht, es sei denn, das LOCALE-Flag wird ebenfalls verwendet.

Entspricht dem Inline-Flag (?i).

Beachten Sie, dass bei Verwendung der Unicode-Muster [a-z] oder [A-Z] in Kombination mit dem IGNORECASE-Flag die 52 ASCII-Buchstaben und 4 zusätzliche Nicht-ASCII-Buchstaben abgeglichen werden: „İ“ (U+0130, Latin Capital Letter I with dot above), „ı“ (U+0131, Latin Small Letter dotless i), „ſ“ (U+017F, Latin Small Letter long s) und „K“ (U+212A, Kelvin sign). Wenn das ASCII-Flag verwendet wird, werden nur die Buchstaben „a“ bis „z“ und „A“ bis „Z“ abgeglichen.

re.L¶

re.LOCALE¶

Bewirkt, dass \w, \W, \b, \B und der nicht beachtende Groß-/Kleinschreibung-Abgleich von der aktuellen Locale abhängen. Dieses Flag kann nur mit Bytes-Mustern verwendet werden.

Entspricht dem Inline-Flag (?L).

Warnung

Dieses Flag wird nicht empfohlen; erwägen Sie stattdessen Unicode-Abgleiche. Der Locale-Mechanismus ist sehr unzuverlässig, da er nur eine „Kultur“ gleichzeitig behandelt und nur mit 8-Bit-Locales funktioniert. Unicode-Abgleiche sind standardmäßig für Unicode (str) Muster aktiviert und können verschiedene Locales und Sprachen verarbeiten.

Geändert in Version 3.6: LOCALE kann nur mit Bytes-Mustern verwendet werden und ist nicht mit ASCII kompatibel.

Geändert in Version 3.7: Kompilierte reguläre Ausdrucksobjekte mit dem LOCALE-Flag hängen nicht mehr von der Locale zur Kompilierungszeit ab. Nur die Locale zur Abgleichzeit beeinflusst das Ergebnis des Abgleichs.

re.M¶

re.MULTILINE¶

Wenn angegeben, gleicht das Musterzeichen '^' am Anfang der Zeichenkette und am Anfang jeder Zeile (unmittelbar nach jedem Zeilenumbruch) ab; und das Musterzeichen '$' gleicht am Ende der Zeichenkette und am Ende jeder Zeile (unmittelbar vor jedem Zeilenumbruch) ab. Standardmäßig gleicht '^' nur am Anfang der Zeichenkette ab, und '$' nur am Ende der Zeichenkette und unmittelbar vor dem Zeilenumbruch (falls vorhanden) am Ende der Zeichenkette.

Entspricht dem Inline-Flag (?m).

re.NOFLAG¶

Zeigt an, dass kein Flag angewendet wird, der Wert ist 0. Dieses Flag kann als Standardwert für ein Funktionsargument oder als Basiswert verwendet werden, der bedingt mit anderen Flags mit bitweisem ODER (dem Operator |) verknüpft wird. Beispiel für die Verwendung als Standardwert

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)

Hinzugefügt in Version 3.11.

re.S¶

re.DOTALL¶

Bewirkt, dass das Sonderzeichen '.' jedes Zeichen abgleicht, einschließlich eines Zeilenumbruchs; ohne dieses Flag gleicht '.' alles ab, *außer* einem Zeilenumbruch.

Entspricht dem Inline-Flag (?s).

re.U¶

re.UNICODE¶

In Python 3 werden Unicode-Zeichen für str-Muster standardmäßig abgeglichen. Dieses Flag ist daher redundant und hat **keine Auswirkung** und wird nur aus Kompatibilitätsgründen beibehalten.

Siehe ASCII, um stattdessen den Abgleich auf ASCII-Zeichen zu beschränken.

re.X¶

re.VERBOSE¶

Dieses Flag ermöglicht es Ihnen, reguläre Ausdrücke zu schreiben, die besser aussehen und lesbarer sind, indem Sie logische Abschnitte des Musters visuell trennen und Kommentare hinzufügen können. Leerzeichen innerhalb des Musters werden ignoriert, außer wenn sie sich in einer Zeichenklasse befinden oder von einem nicht maskierten Backslash gefolgt werden, oder innerhalb von Token wie *?, (?: oder (?P<...>. Zum Beispiel sind (? : und * ? nicht erlaubt. Wenn eine Zeile ein # enthält, das sich nicht in einer Zeichenklasse befindet und nicht von einem nicht maskierten Backslash gefolgt wird, werden alle Zeichen von diesem linken # bis zum Ende der Zeile ignoriert.

Dies bedeutet, dass die folgenden beiden regulären Ausdrucksobjekte, die eine Dezimalzahl abgleichen, funktional gleichwertig sind

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")

Entspricht dem Inline-Flag (?x).

Funktionen¶

re.compile(pattern, flags=0)¶

Kompiliert ein reguläres Ausdrucksmuster in ein reguläres Ausdrucksobjekt, das zum Abgleichen unter Verwendung seiner match(), search() und anderer unten beschriebener Methoden verwendet werden kann.

Das Verhalten des Ausdrucks kann durch Angabe eines flags-Wertes modifiziert werden. Werte können beliebige der flags Variablen sein, kombiniert mit bitweisem ODER (dem | Operator).

Die Sequenz

prog = re.compile(pattern)
result = prog.match(string)

gleichbedeutend ist mit

result = re.match(pattern, string)

aber die Verwendung von re.compile() und das Speichern des resultierenden regulären Ausdrucksobjekts zur Wiederverwendung ist effizienter, wenn der Ausdruck mehrmals in einem einzelnen Programm verwendet wird.

Hinweis

Die kompilierten Versionen der zuletzt an re.compile() und die modulweiten Abgleichfunktionen übergebenen Muster werden zwischengespeichert, sodass Programme, die nur wenige reguläre Ausdrücke gleichzeitig verwenden, sich keine Gedanken über das Kompilieren von regulären Ausdrücken machen müssen.

re.search(pattern, string, flags=0)¶

Durchsucht string nach der ersten Position, an der der reguläre Ausdruck pattern eine Übereinstimmung ergibt, und gibt ein entsprechendes Match-Objekt zurück. Gibt None zurück, wenn keine Position in der Zeichenkette dem Muster entspricht. Beachten Sie, dass dies anders ist als das Finden einer null-längen Übereinstimmung an einer bestimmten Stelle in der Zeichenkette.

Das Verhalten des Ausdrucks kann durch Angabe eines flags-Wertes modifiziert werden. Werte können beliebige der flags Variablen sein, kombiniert mit bitweisem ODER (dem | Operator).

re.match(pattern, string, flags=0)¶

Wenn null oder mehr Zeichen am Anfang von string mit dem regulären Ausdruck pattern übereinstimmen, wird ein entsprechendes Match-Objekt zurückgegeben. Gibt None zurück, wenn die Zeichenkette nicht mit dem Muster übereinstimmt. Beachten Sie, dass dies anders ist als eine Übereinstimmung mit null Länge.

Beachten Sie, dass re.match(), auch im MULTILINE-Modus, nur am Anfang der Zeichenkette und nicht am Anfang jeder Zeile übereinstimmt.

Wenn Sie eine Übereinstimmung irgendwo in string finden möchten, verwenden Sie stattdessen search() (siehe auch search() vs. match()).

Das Verhalten des Ausdrucks kann durch Angabe eines flags-Wertes modifiziert werden. Werte können beliebige der flags Variablen sein, kombiniert mit bitweisem ODER (dem | Operator).

re.fullmatch(pattern, string, flags=0)¶

Wenn die gesamte string mit dem regulären Ausdruck pattern übereinstimmt, wird ein entsprechendes Match-Objekt zurückgegeben. Gibt None zurück, wenn die Zeichenkette nicht mit dem Muster übereinstimmt. Beachten Sie, dass dies anders ist als eine Übereinstimmung mit null Länge.

Das Verhalten des Ausdrucks kann durch Angabe eines flags-Wertes modifiziert werden. Werte können beliebige der flags Variablen sein, kombiniert mit bitweisem ODER (dem | Operator).

Hinzugefügt in Version 3.4.

re.split(pattern, string, maxsplit=0, flags=0)¶

Teilt string an den Vorkommen von pattern auf. Wenn Klammern im pattern verwendet werden, werden die Texte aller Gruppen im Muster ebenfalls als Teil der resultierenden Liste zurückgegeben. Wenn maxsplit ungleich null ist, werden höchstens maxsplit Teilungen durchgeführt, und der Rest der Zeichenkette wird als letztes Element der Liste zurückgegeben.

>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', maxsplit=1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']

Wenn es erfassende Gruppen im Trennzeichen gibt und diese am Anfang der Zeichenkette übereinstimmen, beginnt das Ergebnis mit einer leeren Zeichenkette. Dasselbe gilt für das Ende der Zeichenkette.

>>> re.split(r'(\W+)', '...words, words...')
['', '...', 'words', ', ', 'words', '...', '']

Auf diese Weise werden Trennzeichenkomponenten immer an denselben relativen Indizes innerhalb der Ergebnisliste gefunden.

Angrenzende leere Übereinstimmungen sind nicht möglich, aber eine leere Übereinstimmung kann unmittelbar nach einer nicht-leeren Übereinstimmung auftreten.

>>> re.split(r'\b', 'Words, words, words.')
['', 'Words', ', ', 'words', ', ', 'words', '.']
>>> re.split(r'\W*', '...words...')
['', '', 'w', 'o', 'r', 'd', 's', '', '']
>>> re.split(r'(\W*)', '...words...')
['', '...', '', '', 'w', '', 'o', '', 'r', '', 'd', '', 's', '...', '', '', '']

Das Verhalten des Ausdrucks kann durch Angabe eines flags-Wertes modifiziert werden. Werte können beliebige der flags Variablen sein, kombiniert mit bitweisem ODER (dem | Operator).

Geändert in Version 3.1: Das optionale Argument flags wurde hinzugefügt.

Geändert in Version 3.7: Unterstützung für das Aufteilen nach einem Muster, das eine leere Zeichenkette ergeben kann, hinzugefügt.

Veraltet seit Version 3.13: Das Übergeben von maxsplit und flags als positionelle Argumente ist veraltet. In zukünftigen Python-Versionen werden dies keyword-only Parameter sein.

re.findall(pattern, string, flags=0)¶

Gibt alle nicht überlappenden Übereinstimmungen von pattern in string als Liste von Zeichenketten oder Tupeln zurück. string wird von links nach rechts durchsucht, und Übereinstimmungen werden in der Reihenfolge ihres Auftretens zurückgegeben. Leere Übereinstimmungen sind im Ergebnis enthalten.

Das Ergebnis hängt von der Anzahl der erfassenden Gruppen im Muster ab. Wenn es keine Gruppen gibt, wird eine Liste von Zeichenketten zurückgegeben, die dem gesamten Muster entsprechen. Wenn es genau eine Gruppe gibt, wird eine Liste von Zeichenketten zurückgegeben, die dieser Gruppe entsprechen. Wenn mehrere Gruppen vorhanden sind, wird eine Liste von Tupeln von Zeichenketten zurückgegeben, die den Gruppen entsprechen. Nicht-erfassende Gruppen beeinflussen die Form des Ergebnisses nicht.

>>> re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
['foot', 'fell', 'fastest']
>>> re.findall(r'(\w+)=(\d+)', 'set width=20 and height=10')
[('width', '20'), ('height', '10')]

Das Verhalten des Ausdrucks kann durch Angabe eines flags-Wertes modifiziert werden. Werte können beliebige der flags Variablen sein, kombiniert mit bitweisem ODER (dem | Operator).

Geändert in Version 3.7: Nicht-leere Übereinstimmungen können nun unmittelbar nach einer vorherigen leeren Übereinstimmung beginnen.

re.finditer(pattern, string, flags=0)¶

Gibt einen Iterator zurück, der Match-Objekte für alle nicht überlappenden Übereinstimmungen des RE pattern in string liefert. string wird von links nach rechts durchsucht, und Übereinstimmungen werden in der Reihenfolge ihres Auftretens zurückgegeben. Leere Übereinstimmungen sind im Ergebnis enthalten.

Das Verhalten des Ausdrucks kann durch Angabe eines flags-Wertes modifiziert werden. Werte können beliebige der flags Variablen sein, kombiniert mit bitweisem ODER (dem | Operator).

Geändert in Version 3.7: Nicht-leere Übereinstimmungen können nun unmittelbar nach einer vorherigen leeren Übereinstimmung beginnen.

re.sub(pattern, repl, string, count=0, flags=0)¶

Gibt die Zeichenkette zurück, die durch Ersetzen der am weitesten links liegenden nicht überlappenden Vorkommen von pattern in string durch den Ersatz repl erzielt wird. Wenn das Muster nicht gefunden wird, wird string unverändert zurückgegeben. repl kann eine Zeichenkette oder eine Funktion sein; wenn es eine Zeichenkette ist, werden alle Backslash-Escapes darin verarbeitet. Das heißt, \n wird in ein einzelnes Zeilenumbruchzeichen umgewandelt, \r in einen Wagenrücklauf und so weiter. Unbekannte Escapes von ASCII-Buchstaben sind für zukünftige Verwendung reserviert und werden als Fehler behandelt. Andere unbekannte Escapes wie \& bleiben unverändert. Backreferences wie \6 werden durch die von Gruppe 6 im Muster übereinstimmende Teilzeichenkette ersetzt. Zum Beispiel

>>> re.sub(r'def\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*\(\s*\):',
...        r'static PyObject*\npy_\1(void)\n{',
...        'def myfunc():')
'static PyObject*\npy_myfunc(void)\n{'

Wenn repl eine Funktion ist, wird sie für jedes nicht überlappende Vorkommen von pattern aufgerufen. Die Funktion nimmt ein einzelnes Match-Argument und gibt die Ersatzzeichenkette zurück. Zum Beispiel

>>> def dashrepl(matchobj):
...     if matchobj.group(0) == '-': return ' '
...     else: return '-'
...
>>> re.sub('-{1,2}', dashrepl, 'pro----gram-files')
'pro--gram files'
>>> re.sub(r'\sAND\s', ' & ', 'Baked Beans And Spam', flags=re.IGNORECASE)
'Baked Beans & Spam'

Das Muster kann eine Zeichenkette oder ein Pattern sein.

Das optionale Argument count ist die maximale Anzahl der zu ersetzenden Muster-Vorkommen; count muss eine nicht-negative ganze Zahl sein. Wenn es weggelassen wird oder null ist, werden alle Vorkommen ersetzt.

Angrenzende leere Übereinstimmungen sind nicht möglich, aber eine leere Übereinstimmung kann unmittelbar nach einer nicht-leeren Übereinstimmung auftreten. Infolgedessen gibt sub('x*', '-', 'abxd') '-a-b--d-' anstelle von '-a-b-d-' zurück.

In repl-Argumenten vom Typ Zeichenkette werden zusätzlich zu den oben beschriebenen Zeichen-Escapes und Backreferences \g<name> verwendet, um die von der Gruppe mit dem Namen name übereinstimmende Teilzeichenkette zu verwenden, wie sie durch die Syntax (?P<name>...) definiert ist. \g<number> verwendet die entsprechende Gruppennummer; \g<2> ist daher äquivalent zu \2, ist aber in einer Ersetzung wie \g<2>0 nicht mehrdeutig. \20 würde als Referenz auf Gruppe 20 interpretiert werden, nicht als Referenz auf Gruppe 2 gefolgt vom literalen Zeichen '0'. Die Backreference \g<0> substituiert die gesamte vom RE übereinstimmende Teilzeichenkette.

Das Verhalten des Ausdrucks kann durch Angabe eines flags-Wertes modifiziert werden. Werte können beliebige der flags Variablen sein, kombiniert mit bitweisem ODER (dem | Operator).

Geändert in Version 3.1: Das optionale Argument flags wurde hinzugefügt.

Geändert in Version 3.5: Nicht übereinstimmende Gruppen werden durch eine leere Zeichenkette ersetzt.

Geändert in Version 3.6: Unbekannte Escapes in pattern, die aus '\' und einem ASCII-Buchstaben bestehen, sind nun Fehler.

Geändert in Version 3.7: Unbekannte Escapes in repl, die aus '\' und einem ASCII-Buchstaben bestehen, sind nun Fehler. Eine leere Übereinstimmung kann unmittelbar nach einer nicht-leeren Übereinstimmung auftreten.

Geändert in Version 3.12: Gruppen-id dürfen nur ASCII-Ziffern enthalten. In bytes-Ersetzungszeichenketten darf der Gruppen-name nur Bytes im ASCII-Bereich (b'\x00'-b'\x7f') enthalten.

Veraltet seit Version 3.13: Das Übergeben von count und flags als positionelle Argumente ist veraltet. In zukünftigen Python-Versionen werden dies keyword-only Parameter sein.

re.subn(pattern, repl, string, count=0, flags=0)¶

Führt dieselbe Operation wie sub() durch, gibt aber ein Tupel (new_string, number_of_subs_made) zurück.

Das Verhalten des Ausdrucks kann durch Angabe eines flags-Wertes modifiziert werden. Werte können beliebige der flags Variablen sein, kombiniert mit bitweisem ODER (dem | Operator).

re.escape(pattern)¶

Maskiert Sonderzeichen in pattern. Dies ist nützlich, wenn Sie eine beliebige literale Zeichenkette abgleichen möchten, die möglicherweise reguläre Ausdrucks-Metazeichen enthält. Zum Beispiel

>>> print(re.escape('https://pythonlang.de'))
https://www\.python\.org

>>> legal_chars = string.ascii_lowercase + string.digits + "!#$%&'*+-.^_`|~:"
>>> print('[%s]+' % re.escape(legal_chars))
[abcdefghijklmnopqrstuvwxyz0123456789!\#\$%\&'\*\+\-\.\^_`\|\~:]+

>>> operators = ['+', '-', '*', '/', '**']
>>> print('|'.join(map(re.escape, sorted(operators, reverse=True))))
/|\-|\+|\*\*|\*

Diese Funktion darf nicht für die Ersatzzeichenkette in sub() und subn() verwendet werden, nur Backslashes sollten maskiert werden. Zum Beispiel

>>> digits_re = r'\d+'
>>> sample = '/usr/sbin/sendmail - 0 errors, 12 warnings'
>>> print(re.sub(digits_re, digits_re.replace('\\', r'\\'), sample))
/usr/sbin/sendmail - \d+ errors, \d+ warnings

Geändert in Version 3.3: Das Zeichen '_' wird nicht mehr maskiert.

Geändert in Version 3.7: Nur Zeichen, die in einem regulären Ausdruck eine Sonderbedeutung haben können, werden maskiert. Infolgedessen werden '!', '"', '%', "'", ',', '/', ':', ';', '<', '=', '>', '@' und "`" nicht mehr maskiert.

re.purge()¶: Löscht den Cache für reguläre Ausdrücke.

Ausnahmen¶

exception re.PatternError(msg, pattern=None, pos=None)¶

Ausnahme, die ausgelöst wird, wenn eine an eine der Funktionen übergebene Zeichenkette kein gültiger regulärer Ausdruck ist (z. B. nicht übereinstimmende Klammern enthalten kann) oder wenn während der Kompilierung oder des Abgleichs ein anderer Fehler auftritt. Es ist niemals ein Fehler, wenn eine Zeichenkette keine Übereinstimmung mit einem Muster enthält. Die Instanz PatternError hat die folgenden zusätzlichen Attribute

msg¶: Die ungeformatierte Fehlermeldung.

pattern¶: Das Muster des regulären Ausdrucks.

pos¶: Der Index in pattern, an dem die Kompilierung fehlgeschlagen ist (kann None sein).

lineno¶: Die Zeile, die pos entspricht (kann None sein).

colno¶: Die Spalte, die pos entspricht (kann None sein).

Geändert in Version 3.5: Zusätzliche Attribute hinzugefügt.

Geändert in Version 3.13: PatternError hieß ursprünglich error; letzteres bleibt als Alias für Abwärtskompatibilität erhalten.

Objekte für reguläre Ausdrücke¶

class re.Pattern¶: Kompiliertes Objekt eines regulären Ausdrucks, das von re.compile() zurückgegeben wird.

Geändert in Version 3.9: re.Pattern unterstützt [], um ein Unicode-Muster (str) oder Byte-Muster anzuzeigen. Siehe Generischer Alias-Typ.

Pattern.search(string[, pos[, endpos]])¶

Durchsucht string nach der ersten Position, an der dieser reguläre Ausdruck eine Übereinstimmung ergibt, und gibt ein entsprechendes Match-Objekt zurück. Gibt None zurück, wenn keine Position in der Zeichenkette dem Muster entspricht. Beachten Sie, dass dies anders ist als das Finden einer null-längen Übereinstimmung an einer bestimmten Stelle in der Zeichenkette.

Der optionale zweite Parameter pos gibt einen Index in der Zeichenkette an, an dem die Suche beginnen soll; er standardmäßig auf 0. Dies ist nicht vollständig äquivalent zum Slicing der Zeichenkette; das Musterzeichen '^' stimmt am tatsächlichen Anfang der Zeichenkette und an Positionen unmittelbar nach einem Zeilenumbruch überein, aber nicht unbedingt am Index, an dem die Suche beginnen soll.

Der optionale Parameter endpos begrenzt, wie weit die Zeichenkette durchsucht wird; es wird so sein, als wäre die Zeichenkette endpos Zeichen lang, so dass nur die Zeichen von pos bis endpos - 1 auf eine Übereinstimmung durchsucht werden. Wenn endpos kleiner als pos ist, wird keine Übereinstimmung gefunden; andernfalls ist, wenn rx ein kompiliertes Objekt eines regulären Ausdrucks ist, rx.search(string, 0, 50) äquivalent zu rx.search(string[:50], 0).

>>> pattern = re.compile("d")
>>> pattern.search("dog")     # Match at index 0
<re.Match object; span=(0, 1), match='d'>
>>> pattern.search("dog", 1)  # No match; search doesn't include the "d"

Pattern.match(string[, pos[, endpos]])¶

Wenn null oder mehr Zeichen am *Anfang* von string mit diesem regulären Ausdruck übereinstimmen, wird ein entsprechendes Match-Objekt zurückgegeben. Gibt None zurück, wenn die Zeichenkette nicht mit dem Muster übereinstimmt. Beachten Sie, dass dies anders ist als eine Übereinstimmung mit null Länge.

Die optionalen Parameter pos und endpos haben dieselbe Bedeutung wie in der Methode search().

>>> pattern = re.compile("o")
>>> pattern.match("dog")      # No match as "o" is not at the start of "dog".
>>> pattern.match("dog", 1)   # Match as "o" is the 2nd character of "dog".
<re.Match object; span=(1, 2), match='o'>

Wenn Sie eine Übereinstimmung irgendwo in string finden möchten, verwenden Sie stattdessen search() (siehe auch search() vs. match()).

Pattern.fullmatch(string[, pos[, endpos]])¶

Wenn die gesamte string mit diesem regulären Ausdruck übereinstimmt, wird ein entsprechendes Match-Objekt zurückgegeben. Gibt None zurück, wenn die Zeichenkette nicht mit dem Muster übereinstimmt. Beachten Sie, dass dies anders ist als eine Übereinstimmung mit null Länge.

Die optionalen Parameter pos und endpos haben dieselbe Bedeutung wie in der Methode search().

>>> pattern = re.compile("o[gh]")
>>> pattern.fullmatch("dog")      # No match as "o" is not at the start of "dog".
>>> pattern.fullmatch("ogre")     # No match as not the full string matches.
>>> pattern.fullmatch("doggie", 1, 3)   # Matches within given limits.
<re.Match object; span=(1, 3), match='og'>

Hinzugefügt in Version 3.4.

Pattern.split(string, maxsplit=0)¶: Identisch mit der Funktion split(), unter Verwendung des kompilierten Musters.

Pattern.findall(string[, pos[, endpos]])¶: Ähnlich wie die Funktion findall(), unter Verwendung des kompilierten Musters, akzeptiert aber auch optionale Parameter pos und endpos, die den Suchbereich wie bei search() begrenzen.

Pattern.finditer(string[, pos[, endpos]])¶: Ähnlich wie die Funktion finditer(), unter Verwendung des kompilierten Musters, akzeptiert aber auch optionale Parameter pos und endpos, die den Suchbereich wie bei search() begrenzen.

Pattern.sub(repl, string, count=0)¶: Identisch mit der Funktion sub(), unter Verwendung des kompilierten Musters.

Pattern.subn(repl, string, count=0)¶: Identisch mit der Funktion subn(), unter Verwendung des kompilierten Musters.

Pattern.flags¶: Die Flags für den Regex-Abgleich. Dies ist eine Kombination aus den an compile() übergebenen Flags, allen Inline-Flags (?...) im Muster und impliziten Flags wie UNICODE, wenn das Muster eine Unicode-Zeichenkette ist.

Pattern.groups¶: Die Anzahl der erfassenden Gruppen im Muster.

Pattern.groupindex¶: Ein Wörterbuch, das alle symbolischen Gruppennamen, die durch (?P<id>) definiert sind, auf Gruppennummern abbildet. Das Wörterbuch ist leer, wenn keine symbolischen Gruppen im Muster verwendet wurden.

Pattern.pattern¶: Die Musterzeichenkette, aus der das Musterobjekt kompiliert wurde.

Geändert in Version 3.7: Unterstützung für copy.copy() und copy.deepcopy() hinzugefügt. Kompilierte Objekte regulärer Ausdrücke werden als atomar betrachtet.

Match-Objekte¶

Match-Objekte haben immer einen booleschen Wert von True. Da match() und search() None zurückgeben, wenn keine Übereinstimmung gefunden wurde, können Sie mit einer einfachen if-Anweisung testen, ob eine Übereinstimmung vorlag

match = re.search(pattern, string)
if match:
    process(match)

class re.Match¶: Match-Objekt, das von erfolgreichen `match`- und `search`-Aufrufen zurückgegeben wird.

Geändert in Version 3.9: `re.Match` unterstützt `[]` zur Angabe eines Unicode (str) oder Bytes-Treffers. Siehe Generischer Alias-Typ.

Match.expand(template)¶: Gibt die Zeichenkette zurück, die durch Rückwärtssubstitutionen im Vorlagen-String template erzielt wird, wie sie von der `sub()`-Methode ausgeführt werden. Escapes wie `\n` werden in die entsprechenden Zeichen umgewandelt, und numerische Rückverweise (`\1`, `\2`) sowie benannte Rückverweise (`\g<1>`, `\g<name>`) werden durch den Inhalt der entsprechenden Gruppe ersetzt. Der Rückverweis `\g<0>` wird durch den gesamten Treffer ersetzt.

Geändert in Version 3.5: Nicht übereinstimmende Gruppen werden durch eine leere Zeichenkette ersetzt.

Match.group([group1, ...])¶

Gibt eine oder mehrere Untergruppen des Treffers zurück. Wenn ein einzelnes Argument angegeben wird, ist das Ergebnis eine einzelne Zeichenkette; bei mehreren Argumenten ist das Ergebnis ein Tupel mit einem Element pro Argument. Ohne Argumente ist `group1` standardmäßig auf Null gesetzt (der gesamte Treffer wird zurückgegeben). Wenn ein `groupN`-Argument Null ist, ist der entsprechende Rückgabewert die gesamte übereinstimmende Zeichenkette; wenn es sich im inklusiven Bereich [1..99] befindet, ist es die Zeichenkette, die mit der entsprechenden geklammerten Gruppe übereinstimmt. Wenn eine Gruppennummer negativ ist oder größer als die Anzahl der im Muster definierten Gruppen, wird eine `IndexError`-Ausnahme ausgelöst. Wenn eine Gruppe Teil eines Musters ist, das nicht übereinstimmte, ist das entsprechende Ergebnis `None`. Wenn eine Gruppe Teil eines Musters ist, das mehrmals übereinstimmte, wird der letzte Treffer zurückgegeben.

>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
>>> m.group(0)       # The entire match
'Isaac Newton'
>>> m.group(1)       # The first parenthesized subgroup.
'Isaac'
>>> m.group(2)       # The second parenthesized subgroup.
'Newton'
>>> m.group(1, 2)    # Multiple arguments give us a tuple.
('Isaac', 'Newton')

Wenn der reguläre Ausdruck die Syntax `(?P<name>...)` verwendet, können die `groupN`-Argumente auch Zeichenketten sein, die Gruppen anhand ihres Gruppennamens identifizieren. Wenn ein Zeichenkettenargument nicht als Gruppenname im Muster verwendet wird, wird eine `IndexError`-Ausnahme ausgelöst.

Ein mäßig kompliziertes Beispiel

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'

Benannte Gruppen können auch durch ihren Index referenziert werden

>>> m.group(1)
'Malcolm'
>>> m.group(2)
'Reynolds'

Wenn eine Gruppe mehrmals übereinstimmt, ist nur der letzte Treffer zugänglich

>>> m = re.match(r"(..)+", "a1b2c3")  # Matches 3 times.
>>> m.group(1)                        # Returns only the last match.
'c3'

Match.__getitem__(g)¶

Dies ist identisch mit `m.group(g)`. Dies ermöglicht einen einfacheren Zugriff auf eine einzelne Gruppe aus einem Treffer

>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
>>> m[0]       # The entire match
'Isaac Newton'
>>> m[1]       # The first parenthesized subgroup.
'Isaac'
>>> m[2]       # The second parenthesized subgroup.
'Newton'

Benannte Gruppen werden ebenfalls unterstützt

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Isaac Newton")
>>> m['first_name']
'Isaac'
>>> m['last_name']
'Newton'

Hinzugefügt in Version 3.6.

Match.groups(default=None)¶

Gibt ein Tupel zurück, das alle Untergruppen des Treffers von 1 bis zur Anzahl der Gruppen im Muster enthält. Das `default`-Argument wird für Gruppen verwendet, die nicht am Treffer teilgenommen haben; es ist standardmäßig `None`.

Zum Beispiel

>>> m = re.match(r"(\d+)\.(\d+)", "24.1632")
>>> m.groups()
('24', '1632')

Wenn wir die Dezimalstelle und alles danach optional machen, nehmen möglicherweise nicht alle Gruppen am Treffer teil. Diese Gruppen haben standardmäßig `None`, es sei denn, das `default`-Argument wird angegeben

>>> m = re.match(r"(\d+)\.?(\d+)?", "24")
>>> m.groups()      # Second group defaults to None.
('24', None)
>>> m.groups('0')   # Now, the second group defaults to '0'.
('24', '0')

Match.groupdict(default=None)¶

Gibt ein Dictionary zurück, das alle *benannten* Untergruppen des Treffers enthält, wobei die Gruppennamen als Schlüssel dienen. Das `default`-Argument wird für Gruppen verwendet, die nicht am Treffer teilgenommen haben; es ist standardmäßig `None`. Zum Beispiel

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.groupdict()
{'first_name': 'Malcolm', 'last_name': 'Reynolds'}

Match.start([group])¶

Match.end([group])¶

Gibt die Start- und Endindizes des vom `group` übereinstimmenden Teilstrings zurück; `group` ist standardmäßig Null (was bedeutet, dass der gesamte übereinstimmende Teilstring zurückgegeben wird). Gibt `-1` zurück, wenn `group` existiert, aber nicht zum Treffer beigetragen hat. Für ein Match-Objekt `m` und eine Gruppe `g`, die zum Treffer beigetragen hat, ist der von Gruppe `g` übereinstimmende Teilstring (äquivalent zu `m.group(g)`):

m.string[m.start(g):m.end(g)]

Beachten Sie, dass `m.start(group)` gleich `m.end(group)` ist, wenn `group` einen leeren String übereinstimmte. Zum Beispiel, nach `m = re.search('b(c?)', 'cba')`, sind `m.start(0)` 1, `m.end(0)` 2, `m.start(1)` und `m.end(1)` beide 2, und `m.start(2)` löst eine `IndexError`-Ausnahme aus.

Ein Beispiel, das `remove_this` aus E-Mail-Adressen entfernt

>>> email = "tony@tiremove_thisger.net"
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
'tony@tiger.net'

Match.span([group])¶: Für einen Treffer `m` gibt das 2-Tupel `(m.start(group), m.end(group))` zurück. Beachten Sie, dass dies `(-1, -1)` ist, wenn `group` nicht zum Treffer beigetragen hat. `group` ist standardmäßig Null, der gesamte Treffer.

Match.pos¶: Der Wert von `pos`, der an die Methode `search()` oder `match()` eines Regex-Objekts übergeben wurde. Dies ist der Index in der Zeichenkette, ab dem die RE-Engine nach einem Treffer zu suchen begann.

Match.endpos¶: Der Wert von `endpos`, der an die Methode `search()` oder `match()` eines Regex-Objekts übergeben wurde. Dies ist der Index in der Zeichenkette, über den die RE-Engine nicht hinausgehen wird.

Match.lastindex¶: Der ganzzahlige Index der zuletzt übereinstimmenden erfassenden Gruppe oder `None`, wenn überhaupt keine Gruppe übereinstimmte. Zum Beispiel haben die Ausdrücke `(a)b`, `((a)(b))` und `((ab))` `lastindex == 1`, wenn sie auf die Zeichenkette `'ab'` angewendet werden, während der Ausdruck `(a)(b)` `lastindex == 2` hat, wenn er auf dieselbe Zeichenkette angewendet wird.

Match.lastgroup¶: Der Name der zuletzt übereinstimmenden erfassenden Gruppe oder `None`, wenn die Gruppe keinen Namen hatte oder wenn überhaupt keine Gruppe übereinstimmte.

Match.re¶: Das reguläre Ausdrucksobjekt, dessen `match()`- oder `search()`-Methode diese Trefferinstanz erzeugt hat.

Match.string¶: Die Zeichenkette, die an `match()` oder `search()` übergeben wurde.

Geändert in Version 3.7: Unterstützung für `copy.copy()` und `copy.deepcopy()` hinzugefügt. Match-Objekte gelten als atomar.

Beispiele für reguläre Ausdrücke¶

Überprüfung auf ein Paar¶

In diesem Beispiel verwenden wir die folgende Hilfsfunktion, um Match-Objekte etwas übersichtlicher darzustellen

def displaymatch(match):
    if match is None:
        return None
    return '<Match: %r, groups=%r>' % (match.group(), match.groups())

Angenommen, Sie schreiben ein Pokerspiel, bei dem die Hand eines Spielers als 5-stellige Zeichenkette dargestellt wird, wobei jedes Zeichen eine Karte darstellt: "a" für Ass, "k" für König, "q" für Dame, "j" für Bube, "t" für 10, und "2" bis "9" repräsentieren die Karte mit diesem Wert.

Um zu prüfen, ob eine gegebene Zeichenkette eine gültige Hand ist, könnte man Folgendes tun

>>> valid = re.compile(r"^[a2-9tjqk]{5}$")
>>> displaymatch(valid.match("akt5q"))  # Valid.
"<Match: 'akt5q', groups=()>"
>>> displaymatch(valid.match("akt5e"))  # Invalid.
>>> displaymatch(valid.match("akt"))    # Invalid.
>>> displaymatch(valid.match("727ak"))  # Valid.
"<Match: '727ak', groups=()>"

Die letzte Hand, `"727ak"`, enthielt ein Paar, also zwei Karten des gleichen Wertes. Um dies mit einem regulären Ausdruck abzugleichen, könnte man Rückverweise wie folgt verwenden:

>>> pair = re.compile(r".*(.).*\1")
>>> displaymatch(pair.match("717ak"))     # Pair of 7s.
"<Match: '717', groups=('7',)>"
>>> displaymatch(pair.match("718ak"))     # No pairs.
>>> displaymatch(pair.match("354aa"))     # Pair of aces.
"<Match: '354aa', groups=('a',)>"

Um herauszufinden, aus welcher Karte das Paar besteht, könnte man die `group()`-Methode des Match-Objekts wie folgt verwenden:

>>> pair = re.compile(r".*(.).*\1")
>>> pair.match("717ak").group(1)
'7'

# Error because re.match() returns None, which doesn't have a group() method:
>>> pair.match("718ak").group(1)
Traceback (most recent call last):
  File "<pyshell#23>", line 1, in <module>
    re.match(r".*(.).*\1", "718ak").group(1)
AttributeError: 'NoneType' object has no attribute 'group'

>>> pair.match("354aa").group(1)
'a'

Simulieren von scanf()¶

Python hat derzeit kein Äquivalent zu `scanf()`. Reguläre Ausdrücke sind im Allgemeinen leistungsfähiger, wenn auch ausführlicher, als `scanf()`-Format-Strings. Die folgende Tabelle bietet mehr oder weniger gleichwertige Zuordnungen zwischen `scanf()`-Format-Tokens und regulären Ausdrücken.

`scanf()` Token	Regulärer Ausdruck
`%c`	`.`
`%5c`	`.{5}`
`%d`	`[-+]?\d+`
`%e`, `%E`, `%f`, `%g`	`[-+]?(\d+(\.\d*)?\|\.\d+)([eE][-+]?\d+)?`
`%i`	`[-+]?(0[xX][\dA-Fa-f]+\|0[0-7]*\|\d+)`
`%o`	`[-+]?[0-7]+`
`%s`	`\S+`
`%u`	`\d+`
`%x`, `%X`	`[-+]?(0[xX])?[\dA-Fa-f]+`

Um den Dateinamen und die Zahlen aus einer Zeichenkette wie

/usr/sbin/sendmail - 0 errors, 4 warnings

würde man ein `scanf()`-Format wie

%s - %d errors, %d warnings

Der entsprechende reguläre Ausdruck wäre

(\S+) - (\d+) errors, (\d+) warnings

search() vs. match()¶

Python bietet verschiedene primitive Operationen basierend auf regulären Ausdrücken

`re.match()` prüft nur am Anfang der Zeichenkette auf einen Treffer
`re.search()` prüft auf einen Treffer irgendwo in der Zeichenkette (das macht Perl standardmäßig)
`re.fullmatch()` prüft, ob die gesamte Zeichenkette ein Treffer ist

Zum Beispiel

>>> re.match("c", "abcdef")    # No match
>>> re.search("c", "abcdef")   # Match
<re.Match object; span=(2, 3), match='c'>
>>> re.fullmatch("p.*n", "python") # Match
<re.Match object; span=(0, 6), match='python'>
>>> re.fullmatch("r.*n", "python") # No match

Reguläre Ausdrücke, die mit `'^'` beginnen, können mit `search()` verwendet werden, um den Treffer auf den Anfang der Zeichenkette zu beschränken

>>> re.match("c", "abcdef")    # No match
>>> re.search("^c", "abcdef")  # No match
>>> re.search("^a", "abcdef")  # Match
<re.Match object; span=(0, 1), match='a'>

Beachten Sie jedoch, dass im `MULTILINE`-Modus `match()` nur am Anfang der Zeichenkette übereinstimmt, während die Verwendung von `search()` mit einem regulären Ausdruck, der mit `'^'` beginnt, am Anfang jeder Zeile übereinstimmt.

>>> re.match("X", "A\nB\nX", re.MULTILINE)  # No match
>>> re.search("^X", "A\nB\nX", re.MULTILINE)  # Match
<re.Match object; span=(4, 5), match='X'>

Ein Telefonbuch erstellen¶

`split()` teilt eine Zeichenkette in eine Liste, die durch das übergebene Muster getrennt ist. Die Methode ist unschätzbar wertvoll für die Konvertierung von Textdaten in Datenstrukturen, die von Python leicht gelesen und modifiziert werden können, wie im folgenden Beispiel gezeigt, das ein Telefonbuch erstellt.

Zuerst die Eingabe. Normalerweise könnte sie aus einer Datei stammen, hier verwenden wir die Syntax für dreifach-angeführte Zeichenketten

>>> text = """Ross McFluff: 834.345.1254 155 Elm Street
...
... Ronald Heathmore: 892.345.3428 436 Finley Avenue
... Frank Burger: 925.541.7625 662 South Dogwood Way
...
...
... Heather Albrecht: 548.326.4584 919 Park Place"""

Die Einträge werden durch ein oder mehrere Zeilenumbrüche getrennt. Nun konvertieren wir die Zeichenkette in eine Liste, wobei jede nicht-leere Zeile ihren eigenen Eintrag hat

>>> entries = re.split("\n+", text)
>>> entries
['Ross McFluff: 834.345.1254 155 Elm Street',
'Ronald Heathmore: 892.345.3428 436 Finley Avenue',
'Frank Burger: 925.541.7625 662 South Dogwood Way',
'Heather Albrecht: 548.326.4584 919 Park Place']

Schließlich wird jeder Eintrag in eine Liste mit Vorname, Nachname, Telefonnummer und Adresse aufgeteilt. Wir verwenden den `maxsplit`-Parameter von `split()`, da die Adresse Leerzeichen enthält, unser Trennmuster, darin

>>> [re.split(":? ", entry, maxsplit=3) for entry in entries]
[['Ross', 'McFluff', '834.345.1254', '155 Elm Street'],
['Ronald', 'Heathmore', '892.345.3428', '436 Finley Avenue'],
['Frank', 'Burger', '925.541.7625', '662 South Dogwood Way'],
['Heather', 'Albrecht', '548.326.4584', '919 Park Place']]

Das Muster `:?` passt auf den Doppelpunkt nach dem Nachnamen, sodass er nicht in der Ergebnisliste vorkommt. Mit einem `maxsplit` von `4` könnten wir die Hausnummer vom Straßennamen trennen

>>> [re.split(":? ", entry, maxsplit=4) for entry in entries]
[['Ross', 'McFluff', '834.345.1254', '155', 'Elm Street'],
['Ronald', 'Heathmore', '892.345.3428', '436', 'Finley Avenue'],
['Frank', 'Burger', '925.541.7625', '662', 'South Dogwood Way'],
['Heather', 'Albrecht', '548.326.4584', '919', 'Park Place']]

Textbearbeitung¶

`sub()` ersetzt jedes Vorkommen eines Musters durch eine Zeichenkette oder das Ergebnis einer Funktion. Dieses Beispiel demonstriert die Verwendung von `sub()` mit einer Funktion, um Text zu "bereinigen" oder die Reihenfolge aller Zeichen in jedem Wort eines Satzes außer den ersten und letzten Zeichen zu randomisieren

>>> def repl(m):
...     inner_word = list(m.group(2))
...     random.shuffle(inner_word)
...     return m.group(1) + "".join(inner_word) + m.group(3)
...
>>> text = "Professor Abdolmalek, please report your absences promptly."
>>> re.sub(r"(\w)(\w+)(\w)", repl, text)
'Poefsrosr Aealmlobdk, pslaee reorpt your abnseces plmrptoy.'
>>> re.sub(r"(\w)(\w+)(\w)", repl, text)
'Pofsroser Aodlambelk, plasee reoprt yuor asnebces potlmrpy.'

Alle Adverbien finden¶

`findall()` findet *alle* Vorkommen eines Musters, nicht nur das erste, wie es `search()` tut. Wenn beispielsweise ein Autor alle Adverbien in einem Text finden wollte, könnte er `findall()` wie folgt verwenden:

>>> text = "He was carefully disguised but captured quickly by police."
>>> re.findall(r"\w+ly\b", text)
['carefully', 'quickly']

Alle Adverbien und ihre Positionen finden¶

Wenn man mehr Informationen über alle Treffer eines Musters als den übereinstimmenden Text wünscht, ist `finditer()` nützlich, da es `Match`-Objekte anstelle von Zeichenketten liefert. Weiter mit dem vorherigen Beispiel: Wenn ein Autor alle Adverbien *und ihre Positionen* in einem Text finden wollte, würde er `finditer()` wie folgt verwenden:

>>> text = "He was carefully disguised but captured quickly by police."
>>> for m in re.finditer(r"\w+ly\b", text):
...     print('%02d-%02d: %s' % (m.start(), m.end(), m.group(0)))
07-16: carefully
40-47: quickly

Rohe String-Notation¶

Rohe String-Notation (`r"text"`) hält reguläre Ausdrücke übersichtlich. Ohne sie müsste jeder Backslash (`'\'`) in einem regulären Ausdruck mit einem weiteren vorangestellten Backslash escaped werden. Zum Beispiel sind die folgenden beiden Codezeilen funktional identisch

>>> re.match(r"\W(.)\1\W", " ff ")
<re.Match object; span=(0, 4), match=' ff '>
>>> re.match("\\W(.)\\1\\W", " ff ")
<re.Match object; span=(0, 4), match=' ff '>

Wenn man einen literalen Backslash abgleichen möchte, muss er im regulären Ausdruck escaped werden. Mit roher String-Notation bedeutet dies `r"\\"`. Ohne rohe String-Notation muss man `"\\\\"` verwenden, was die folgenden Codezeilen funktional identisch macht

>>> re.match(r"\\", r"\\")
<re.Match object; span=(0, 1), match='\\'>
>>> re.match("\\\\", r"\\")
<re.Match object; span=(0, 1), match='\\'>

Einen Tokenizer schreiben¶

Ein Tokenizer oder Scanner analysiert eine Zeichenkette, um Zeichengruppen zu kategorisieren. Dies ist ein nützlicher erster Schritt beim Schreiben eines Compilers oder Interpreters.

Die Textkategorien werden mit regulären Ausdrücken spezifiziert. Die Technik besteht darin, diese zu einem einzigen Haupt-Regulären Ausdruck zu kombinieren und über successive Treffer zu iterieren

from typing import NamedTuple
import re

class Token(NamedTuple):
    type: str
    value: str
    line: int
    column: int

def tokenize(code):
    keywords = {'IF', 'THEN', 'ENDIF', 'FOR', 'NEXT', 'GOSUB', 'RETURN'}
    token_specification = [
        ('NUMBER',   r'\d+(\.\d*)?'),  # Integer or decimal number
        ('ASSIGN',   r':='),           # Assignment operator
        ('END',      r';'),            # Statement terminator
        ('ID',       r'[A-Za-z]+'),    # Identifiers
        ('OP',       r'[+\-*/]'),      # Arithmetic operators
        ('NEWLINE',  r'\n'),           # Line endings
        ('SKIP',     r'[ \t]+'),       # Skip over spaces and tabs
        ('MISMATCH', r'.'),            # Any other character
    ]
    tok_regex = '|'.join('(?P<%s>%s)' % pair for pair in token_specification)
    line_num = 1
    line_start = 0
    for mo in re.finditer(tok_regex, code):
        kind = mo.lastgroup
        value = mo.group()
        column = mo.start() - line_start
        if kind == 'NUMBER':
            value = float(value) if '.' in value else int(value)
        elif kind == 'ID' and value in keywords:
            kind = value
        elif kind == 'NEWLINE':
            line_start = mo.end()
            line_num += 1
            continue
        elif kind == 'SKIP':
            continue
        elif kind == 'MISMATCH':
            raise RuntimeError(f'{value!r} unexpected on line {line_num}')
        yield Token(kind, value, line_num, column)

statements = '''
    IF quantity THEN
        total := total + price * quantity;
        tax := price * 0.05;
    ENDIF;
'''

for token in tokenize(statements):
    print(token)

Der Tokenizer erzeugt die folgende Ausgabe

Token(type='IF', value='IF', line=2, column=4)
Token(type='ID', value='quantity', line=2, column=7)
Token(type='THEN', value='THEN', line=2, column=16)
Token(type='ID', value='total', line=3, column=8)
Token(type='ASSIGN', value=':=', line=3, column=14)
Token(type='ID', value='total', line=3, column=17)
Token(type='OP', value='+', line=3, column=23)
Token(type='ID', value='price', line=3, column=25)
Token(type='OP', value='*', line=3, column=31)
Token(type='ID', value='quantity', line=3, column=33)
Token(type='END', value=';', line=3, column=41)
Token(type='ID', value='tax', line=4, column=8)
Token(type='ASSIGN', value=':=', line=4, column=12)
Token(type='ID', value='price', line=4, column=15)
Token(type='OP', value='*', line=4, column=21)
Token(type='NUMBER', value=0.05, line=4, column=23)
Token(type='END', value=';', line=4, column=27)
Token(type='ENDIF', value='ENDIF', line=5, column=4)
Token(type='END', value=';', line=5, column=9)

[Frie09]

Friedl, Jeffrey. Mastering Regular Expressions. 3. Aufl., O’Reilly Media, 2009. Die dritte Auflage des Buches behandelt Python nicht mehr, aber die erste Auflage behandelte das Schreiben guter regulärer Ausdrucksmuster im Detail.

`re` — Reguläre Ausdrucksoperationen¶

Syntax regulärer Ausdrücke¶

Modulinhalt¶

Flags¶

Funktionen¶

Ausnahmen¶

Objekte für reguläre Ausdrücke¶

Match-Objekte¶

Beispiele für reguläre Ausdrücke¶

Überprüfung auf ein Paar¶

Simulieren von scanf()¶

search() vs. match()¶

Ein Telefonbuch erstellen¶

Textbearbeitung¶

Alle Adverbien finden¶

Alle Adverbien und ihre Positionen finden¶

Rohe String-Notation¶

Einen Tokenizer schreiben¶

Inhaltsverzeichnis

Vorheriges Thema

Nächstes Thema

Diese Seite

re — Reguläre Ausdrucksoperationen¶

Syntax regulärer Ausdrücke¶

Modulinhalt¶

Flags¶

Funktionen¶

Ausnahmen¶

Objekte für reguläre Ausdrücke¶

Match-Objekte¶

Beispiele für reguläre Ausdrücke¶

Überprüfung auf ein Paar¶

Simulieren von scanf()¶

search() vs. match()¶

Ein Telefonbuch erstellen¶

Textbearbeitung¶

Alle Adverbien finden¶

Alle Adverbien und ihre Positionen finden¶

Rohe String-Notation¶

Einen Tokenizer schreiben¶

`re` — Reguläre Ausdrucksoperationen¶