re – Operationen mit regulären Ausdrücken¶

Syntax regulärer Ausdrücke¶

Ein regulärer Ausdruck (oder RE) gibt eine Menge von Zeichenketten an, die auf ihn passen; mit den Funktionen in diesem Modul können Sie prüfen, ob eine bestimmte Zeichenkette auf einen bestimmten regulären Ausdruck passt (oder ob ein bestimmter regulärer Ausdruck auf eine bestimmte 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 beide reguläre Ausdrücke sind, dann ist AB auch ein regulärer Ausdruck.im Allgemeinen, wenn eine Zeichenkette p mit A und eine andere Zeichenkette q mit B übereinstimmt, wird die Zeichenkette pq mit AB übereinstimmen. Dies gilt, es sei denn, A oder B enthalten Operationen mit niedriger Priorität, Randbedingungen zwischen A und B oder haben nummerierte Gruppenreferenzen. Auf diese Weise können komplexe Ausdrücke leicht aus einfacheren primitiven Ausdrücken wie den hier beschriebenen konstruiert werden. Einzelheiten zur Theorie und Implementierung regulärer Ausdrücke finden Sie in dem Buch von Friedl oder in fast jedem Lehrbuch über Compilerbau.

Eine kurze Erklärung des Formats regulärer Ausdrücke folgt. Für weitere Informationen und eine sanftere Darstellung konsultieren Sie das Regular Expression HOWTO.

Reguläre Ausdrücke können sowohl spezielle als auch gewöhnliche Zeichen enthalten. Die meisten gewöhnlichen Zeichen, wie 'A', 'a' oder '0', sind die einfachsten regulären Ausdrücke; sie passen einfach zu sich selbst. Sie können gewöhnliche Zeichen aneinanderhängen, so dass last mit der Zeichenfolge 'last' übereinstimmt. (Im Rest dieses Abschnitts werden wir REs in this special style schreiben, normalerweise ohne Anführungszeichen, und die zu übereinstimmenden Zeichenfolgen 'in single quotes'.)

Einige Zeichen, wie '|' oder '(', sind Sonderzeichen. Sonderzeichen stehen entweder für Klassen von gewöhnlichen Zeichen oder beeinflussen, wie die regulären Ausdrücke um sie herum interpretiert werden.

Wiederholungsqualifizierer (*, +, ?, {m,n}, usw.) können nicht direkt verschachtelt werden. Dies vermeidet Mehrdeutigkeiten mit dem Suffix ?, das keine Wiederholung zulässt, 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 ein beliebiges Vielfaches 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.

^

(Caret.) Passt auf den Anfang der Zeichenfolge und im Modus MULTILINE auch unmittelbar nach jedem Zeilenumbruch.

$

Passt auf das Ende der Zeichenfolge oder unmittelbar vor dem Zeilenumbruch am Ende der Zeichenfolge und im Modus MULTILINE auch vor einem Zeilenumbruch. foopaßt sowohl auf ‚foo‘ als auch auf ‚foobar‘, während der reguläre Ausdruck foo$ nur auf ‚foo‘ paßt. Interessanter ist, dass die Suche nach foo.$ in 'foo1\nfoo2\n' normalerweise auf ‚foo2‘, im Modus MULTILINE aber auf ‚foo1‘ zutrifft; die Suche nach einem einzelnen $ in 'foo\n' findet zwei (leere) Übereinstimmungen: eine vor dem Zeilenumbruch und eine am Ende der Zeichenkette.

*

Veranlasst den resultierenden RE, mit 0 oder mehr Wiederholungen des vorhergehenden RE übereinzustimmen, und zwar so viele Wiederholungen wie möglich. ab* stimmt mit ‚a‘, ‚ab‘ oder ‚a‘ gefolgt von einer beliebigen Anzahl von ‚b’s überein.

+

Bewirkt, dass der resultierende RE mit 1 oder mehr Wiederholungen des vorhergehenden RE übereinstimmt.ab+ stimmt mit ‚a‘ gefolgt von einer beliebigen Anzahl von ‚b’s ungleich Null überein; er stimmt nicht nur mit ‚a‘ überein.

?

Bewirkt, dass die resultierende RE mit 0 oder 1 Wiederholungen der vorhergehenden RE übereinstimmt.ab? stimmt entweder mit ‚a‘ oder ‚ab‘ überein.

*?,+?,??

Die Qualifizierer '*', '+' und '?' sind alle gierig; sie stimmen mit so viel Text wie möglich überein. Manchmal ist dieses Verhalten nicht erwünscht; wenn der RE<.*> mit '<a> b <c>' abgeglichen wird, wird er mit dem gesamten Ring abgeglichen und nicht nur mit '<a>'. Das Hinzufügen von ? nach dem Qualifier bewirkt, dass der Abgleich auf nicht-gierige oder minimale Weise durchgeführt wird; es werden so wenige Zeichen wie möglich abgeglichen. Bei Verwendung des RE <.*?> wird nur '<a>' abgeglichen.

{m}

Bestimmt, dass genau m Kopien des vorherigen RE abgeglichen werden sollen; weniger Zeichen führen dazu, dass der gesamte RE nicht abgeglichen wird. Beispiel: a{6} entspricht genau sechs 'a'-Zeichen, aber nicht fünf.

{m,n}

Veranlasst, dass die resultierende RE zwischen m und n Wiederholungen der vorhergehenden RE entspricht, wobei versucht wird, so viele Wiederholungen wie möglich zu finden. Zum Beispiel passt a{3,5} auf 3 bis 5 'a' Zeichen. Das Weglassen von m bedeutet eine untere Grenze von Null, und das Weglassen von n bedeutet eine unendliche obere Grenze. Ein Beispiel: a{4,}b entspricht 'aaaab' oder tausend 'a'-Zeichen, gefolgt von einem 'b', aber nicht 'aaab'. Das Komma darf nicht weggelassen werden, sonst würde der Kodifikator mit der zuvor beschriebenen Form verwechselt.

{m,n}?

Bewirkt, dass die resultierende RE mit m bis n Wiederholungen der vorhergehenden RE übereinstimmt, wobei versucht wird, so wenige Wiederholungen wie möglich zu finden. Dies ist die „on-greedy“-Version des vorherigen Qualifiers. Bei der 6-stelligen Zeichenkette 'aaaaaa' passt a{3,5} beispielsweise auf 5 'a'-Zeichen, während a{3,5}? nur auf 3 Zeichen passt.

\

Es werden entweder Sonderzeichen umgangen (so dass Sie auf Zeichen wie'*', '?' usw. passen können) oder es wird eine spezielle Sequenz angezeigt; spezielle Sequenzen werden weiter unten behandelt.

Wenn Sie keine rohe Zeichenkette verwenden, um das Muster auszudrücken, denken Sie daran, dass Python auch den Backslash als Escape-Sequenz in String-Literalen verwendet; wenn die Escape-Sequenz von Pythons Parser nicht erkannt wird, werden der Backslash und das nachfolgende Zeichen in die resultierende Zeichenkette aufgenommen. Wenn Python die resultierende Sequenz jedoch erkennen würde, sollte der Backslash zweimal wiederholt werden. Dies ist kompliziert und schwer zu verstehen, daher wird dringend empfohlen, die Zeichenketten nur für die einfachsten Ausdrücke zu verwenden.

Wird verwendet, um eine Reihe von Zeichen anzugeben. In einer Menge:

• Zeichen können einzeln aufgeführt werden, z.B. entspricht 'a','m' oder 'k'.

• Zeichenbereiche können angegeben werden, indem zwei Zeichen angegeben und durch ein '-' getrennt werden, z.B. passt auf jeden ASCII-Kleinbuchstaben, passt auf alle zweistelligen Zahlen von 00 bis 59, und passt auf jede hexadezimale Ziffer. Wenn - mit einem Escape-Zeichen versehen ist (z.B.) oder wenn es als erstes oder letztes Zeichen steht (z.B. oder ), passt es auf ein Literal '-'.

• Sonderzeichen verlieren ihre besondere Bedeutung innerhalb von Sets. Zum Beispiel passt auf jedes der Zeichen '(', '+','*' oder ')'.

• Zeichenklassen wie \w oder \S (unten definiert) werden auch innerhalb einer Menge akzeptiert, obwohl die Zeichen, auf die sie passen, davon abhängen, ob der Modus ASCII oder LOCALE in Kraft ist.

• Zeichen, die nicht in einem Bereich liegen, können durch Ergänzung der Menge angepasst werden. Wenn das erste Zeichen der Menge '^' ist, werden alle Zeichen, die nicht in der Menge enthalten sind, abgeglichen. Zum Beispiel passt auf jedes Zeichen außer '5' und auf jedes Zeichen außer'^'. ^ hat keine besondere Bedeutung, wenn es nicht das erste Zeichen in der Menge ist.

• Um ein Literal ']' innerhalb einer Menge zu finden, stellen Sie ihm einen umgekehrten Schrägstrich voran oder setzen es an den Anfang der Menge. Zum Beispiel passen sowohl {}] als auch () auf eine Klammer.

• Die Unterstützung von verschachtelten Mengen und Mengenoperationen wie im Unicode TechnicalStandard #18 könnte in Zukunft hinzugefügt werden. Dies würde die Syntax ändern, so dass zur Erleichterung dieser Änderung in zweideutigen Fällen vorerst ein FutureWarning ausgegeben wird, auch bei Mengen, die mit einem Literal ' beginnen.

  (...)

  Passt auf jeden regulären Ausdruck, der sich innerhalb der Klammern befindet, und gibt den Anfang und das Ende einer Gruppe an; der Inhalt einer Gruppe kann nach einer Übereinstimmung abgerufen werden und kann später in der Zeichenkette mit der unten beschriebenen \numberSondersequenz abgeglichen werden. Für die Übereinstimmung mit den Literalen '(' oder ')' verwenden Sie \( oder \), oder schließen Sie sie in eine Zeichenklasse ein: , .

  (?...)

  Dies ist eine Erweiterungsschreibweise (ein '?' nach einem '(' ist ansonsten nicht sinnvoll). Das erste Zeichen nach '?' bestimmt die Bedeutung und die weitere Syntax des Konstrukts. Erweiterungen erzeugen normalerweise keine neue Gruppe; (?P<name>...) ist die einzige Ausnahme von dieser Regel. Nachstehend 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 entspricht der leeren Zeichenkette; die Buchstaben setzen die entsprechenden Flags: re.A (nur ASCII-Übereinstimmung),re.I (Groß- und Kleinschreibung ignorieren), re.L (abhängig vom Gebietsschema),re.M (mehrzeilig), re.S (Punkt stimmt mit allen überein),re.U (Unicode-Übereinstimmung) und re.X (ausführlich),für den gesamten regulären Ausdruck.(Die Flags sind in Modulinhalt beschrieben.)Dies ist nützlich, wenn Sie die Flags als Teil des regulären Ausdrucks einschließen möchten, anstatt ein Flag-Argument an die Funktionre.compile() zu übergeben. Flags sollten zuerst in der Ausdruckszeichenkette verwendet werden.

  (?:...)

  Eine nicht-einfangende Version der regulären Klammern. Passt auf jeden regulären Ausdruck innerhalb der Klammern, aber die Teilzeichenkette, auf die die Gruppe passt, kann nach der Ausführung einer Übereinstimmung nicht mehr 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:re.A (nur ASCII-Übereinstimmung), re.I (Groß- und Kleinschreibung ignorieren),re.L (abhängig vom Gebietsschema), re.M (mehrzeilig),re.S (Punkt stimmt mit allen überein), re.U (Unicode-Übereinstimmung) und re.X (ausführlich), für den Teil des Ausdrucks.(Die Flags werden in Modulinhalt beschrieben.)

  Die Buchstaben 'a', 'L' und 'u' schließen sich gegenseitig aus, wenn sie als Inline-Flags verwendet werden, daher können sie nicht kombiniert werden oder auf '-' folgen. Wenn einer von ihnen in einer Inline-Gruppe auftaucht, hat er Vorrang vor dem Übereinstimmungsmodus in der umgebenden Gruppe. Bei Unicode-Mustern schaltet (?a:...) auf reinenASCII-Abgleich und (?u:...) auf Unicode-Abgleich (Standard). Bei Byte-Mustern schaltet (?L:...) auf lokalitätsabhängige Anpassung und (?a:...) auf reine ASCII-Anpassung (Standard) um.

  Neu in Version 3.6.

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

  (?P<name>...)

  Ähnlich wie bei regulären Klammern, aber die Teilzeichenkette, auf die die Gruppe passt, ist über den symbolischen Gruppennamen zugreifbar. Gruppennamen müssen gültige Python-Bezeichner sein, und jeder Gruppenname darf nur einmal innerhalb eines regulären Ausdrucks 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 mit einfachen oder doppelten Anführungszeichen versehene Zeichenkette entspricht):

  Kontext des Verweises auf die Gruppe „Anführungszeichen“	Möglichkeiten des Verweises darauf
  im gleichen Muster selbst	(?P=quote) (wie gezeigt)
  bei der Verarbeitung von Match-Objekt m	m.group('quote') m.end('quote') (usw.)
  in einem String, der an das Re-Argument von re.sub()	\g<quote> übergeben wird \g<1>

  (?P=name)

  Ein Rückverweis auf eine benannte Gruppe; Sie entspricht dem Text, auf den die frühere Gruppe mit dem Namen name zutraf.

  (?#...)

  Ein Kommentar; der Inhalt der Klammern wird einfach ignoriert.

  (?=...)

  Passt, wenn ... als Nächstes passt, verbraucht aber keinen Teil der Zeichenkette. Dies ist eine sogenannte Vorausschau-Behauptung. Zum Beispiel passt Isaac (?=Asimov) nur dann auf'Isaac ', wenn darauf 'Asimov' folgt.

  (?!...)

  Passt, wenn ... nicht als nächstes passt. Zum Beispiel passt Isaac (?!Asimov) nur auf 'Isaac ', wenn darauf nicht 'Asimov' folgt.

  (?<=...)

  Passt, wenn der aktuellen Position in der Zeichenfolge eine Übereinstimmung für ... vorausgeht, die an der aktuellen Position endet. Dies nennt man eine positive Lookbehind-Assertion. (?<=abc)def findet eine Übereinstimmung in 'abcdef', da das Lookbehind 3 Zeichen zurückgeht und prüft, ob das enthaltene Muster übereinstimmt.Das enthaltene Muster darf nur mit Zeichenketten einer bestimmten Länge übereinstimmen, was bedeutet, dassabc oder a|b erlaubt sind, a* und a{3,4} jedoch nicht. Beachten Sie, dass Muster, die mit positiven Lookbehind-Assertions beginnen, nicht am Anfang der gesuchten Zeichenfolge übereinstimmen; Sie werden wahrscheinlich eher die Funktionsearch() als die Funktion match() verwenden wollen:

  >>> 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 mit fester Länge wurde hinzugefügt.

  (?<!...)

  Sucht, wenn der aktuellen Position in der Zeichenfolge keine Übereinstimmung für... vorausgeht. Dies wird als negative lookbehind-Behauptung bezeichnet. Ähnlich wie bei positiven Lookbehind-Assertionen darf das enthaltene Muster nur mit Zeichenketten einer bestimmten Länge übereinstimmen. Muster, die mit einer negativen lookbehind-Behauptung beginnen, können am Anfang der gesuchten Zeichenkette übereinstimmen.

  (?(id/name)yes-pattern|no-pattern)

  Wird versuchen, mit yes-pattern übereinzustimmen, wenn die Gruppe mit der gegebenen id oder dem gegebenen name existiert, und mit no-pattern, wenn sie nicht existiert. no-pattern ist optional und kann weggelassen werden. Zum Beispiel ist (<)?(\w+@\w+(?:\.\w+)+)(?(1)>|$) ein schlechtes E-Mail-Muster, das sowohl mit '<[email protected]>' als auch mit '[email protected]' übereinstimmt, aber weder mit '<[email protected]' noch mit '[email protected]>'.

  Die speziellen Sequenzen bestehen aus '\' und einem Zeichen aus der nachstehenden Liste.Wenn das gewöhnliche Zeichen keine ASCII-Ziffer oder kein ASCII-Buchstabe ist, passt die resultierende RE auf das zweite Zeichen. Zum Beispiel passt $ auf das Zeichen '$'.

  \number

  Passt auf den Inhalt der Gruppe mit der gleichen Nummer. Die Gruppen werden von 1 beginnend nummeriert. (.+) passt z. B. zu 'the the' oder '55 55', aber nicht zu 'thethe' (beachten Sie das Leerzeichen nach der Gruppe). Diese spezielle Sequenz kann nur verwendet werden, um eine der ersten 99 Gruppen zu finden. Wenn die erste Ziffer der Zahl 0 ist oder die Zahl 3 Oktalstellen lang ist, wird sie nicht als Gruppenübereinstimmung interpretiert, sondern als das Zeichen mit dem Oktalwert Zahl. Innerhalb der'' einer Zeichenklasse werden alle numerischen Escape-Zeichen als Zeichen behandelt.

  \A

  Passt nur am Anfang der Zeichenkette.

  \b

  Passt auf die leere Zeichenkette, aber nur am Anfang oder Ende eines Wortes.Ein Wort ist definiert als eine Folge von Wortzeichen. Beachten Sie, dass \b formal als die Grenze zwischen einem \w und einem \W Zeichen (oder umgekehrt) oder zwischen \w und dem Anfang/Ende der Zeichenfolge definiert ist.Das bedeutet, dass r'\bfoo\b' mit 'foo', 'foo.', '(foo)','bar foo baz' übereinstimmt, aber nicht mit 'foobar' oder 'foo3'.

  Standardmäßig werden die alphanumerischen Zeichen in Unicode-Mustern verwendet, aber dies kann mit dem Flag ASCII geändert werden. Wortgrenzen werden durch das aktuelle Gebietsschema bestimmt, wenn das Flag LOCALE verwendet wird.\b steht innerhalb eines Zeichenbereichs für das Backspace-Zeichen, um die Kompatibilität mit den String-Literalen von Python zu gewährleisten.

  \B

  Passt auf die leere Zeichenkette, aber nur, wenn sie nicht am Anfang oder Ende eines Worts steht. Das bedeutet, dass r'py\B' mit 'python', 'py3','py2' übereinstimmt, aber nicht mit 'py', 'py.' oder 'py!'.\B ist genau das Gegenteil von \b, so dass Wortzeichen in Unicode-Mustern alphanumerische Unicode-Zeichen oder der Unterstrich sind, obwohl dies mit dem Flag ASCII geändert werden kann. Wortgrenzen werden durch das aktuelle Gebietsschema bestimmt, wenn das Flag LOCALE verwendet wird.

  \d Für Unicode-Muster (str):

  Passt auf jede Unicode-Dezimalziffer (d.h. jedes Zeichen der Unicode-Zeichenkategorie). Dazu gehören und auch viele andere Ziffernzeichen. Wenn das Kennzeichen ASCII verwendet wird, wird nur abgeglichen.

  Für 8-Bit-Muster (Bytes):

  Findet jede Dezimalziffer; dies entspricht .

  \D

  Findet jedes Zeichen, das keine Dezimalziffer ist. Dies ist das Gegenteil von \d. Wenn das Kennzeichen ASCII verwendet wird, entspricht dies .

  \s Für Unicode (str) Muster:

  Findet Unicode-Whitespace-Zeichen (einschließlich, aber auch viele andere Zeichen, z.B. Leerzeichen, die in vielen Sprachen durch typografische Regeln vorgeschrieben sind). Wenn das Kennzeichen ASCII verwendet wird, wird nur gefunden.

  Für 8-Bit-Muster (Bytes):

  Findet Zeichen, die im ASCII-Zeichensatz als Leerzeichen gelten; dies entspricht .

  \S

  Findet jedes Zeichen, das kein Leerzeichen ist. Dies ist das Gegenteil von \s. Wenn das Kennzeichen ASCII verwendet wird, entspricht dies .

  \w Für Unicode (str)-Muster:

  Findet Unicode-Wortzeichen; dazu gehören die meisten Zeichen, die in jeder Sprache Teil eines Wortes sein können, sowie Zahlen und der Unterstrich. Wenn das Kennzeichen ASCII verwendet wird, wird nur abgeglichen.

  Für 8-Bit-Muster (Bytes):

  Findet Zeichen, die im ASCII-Zeichensatz als alphanumerisch gelten; dies entspricht . Wenn das Kennzeichen LOCALE verwendet wird, werden Zeichen, die im aktuellen Gebietsschema als alphanumerisch gelten, und der Unterstrich gefunden.

  \W

  Findet jedes Zeichen, das kein Wortzeichen ist. Dies ist das Gegenteil von \w. Wenn das Kennzeichen ASCII verwendet wird, entspricht dies . Wenn das LOCALE-Flag verwendet wird, passt es auf Zeichen, die weder alphanumerisch im aktuellen Localen noch der Unterstrich sind.

  \Z

  Passt nur am Ende der Zeichenfolge.

  Die meisten der Standard-Escapes, die von Python-Stringliteralen 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-Mustern erkannt. In Byte-Mustern sind sie Fehler. Unbekannte Escape-Sequenzen von ASCII-Buchstaben sind für die zukünftige Verwendung reserviert und werden als Fehler behandelt.

  Oktale Escape-Sequenzen sind in begrenzter Form enthalten. Wenn die erste Ziffer eine 0 ist oder wenn es drei oktale Ziffern gibt, wird es als oktales Escape betrachtet. Andernfalls handelt es sich um eine Gruppenreferenz. Wie bei String-Literalen sind Oktal-Escapes immer höchstens 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 Escape-Sequenzen, die aus '\' und einem ASCII-Buchstaben bestehen, sind jetzt Fehler.

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