Python-Tutorial über reguläre Ausdrücke

  1. Python Regulärer Ausdruck re.match() Funktion
  2. Python regulärer Ausdruck re.search() Funktion
  3. Kompilieren von regulären Ausdrücken mit re.complie
  4. Flags im Python-Modul für den regulären Ausdruck re
  5. Prüfung auf erlaubte Zeichen
  6. Suchen und Ersetzen
  7. Die findall() Funktion
  8. Die finditer() Funktion
  9. Die Funktion split()
  10. Grundmuster von re
  11. Wiederholungsfälle
  12. Sonderzeichen und Sequenzen in re
  13. Die escape Funktion
  14. Die group() Funktion

In diesem Tutorial lernen Sie die regulären Ausdrücke und die Operationen der regulären Ausdrücke, die im re Modul in Python definiert sind. re ist die Standardbibliothek von Python, die die Operationen der regulären Ausdrücke unterstützt.

Reguläre Ausdrücke in Python sind eine Menge von Zeichen oder Sequenzen, die verwendet werden, um eine Zeichenkette mit Hilfe einer formalen Syntax mit einem anderen Muster abzugleichen. Man könnte sich reguläre Ausdrücke als eine kleine Programmiersprache vorstellen, die in Python eingebettet ist.

Sie können reguläre Ausdrücke verwenden, um einige Regeln zu definieren und diese Regeln werden dann verwendet, um mögliche Zeichenketten aus der gegebenen Zeichenkette zu erzeugen, mit denen Sie das Muster vergleichen wollen. Reguläre Ausdrücke in Python werden als ein Satz von Anweisungen interpretiert.

Python Regulärer Ausdruck re.match() Funktion

Sie können die Funktion match verwenden, um das RE-Muster mit der angegebenen Zeichenfolge abzugleichen. Die Abgleichsfunktion enthält Flags. Flags definieren das Verhalten eines regulären Ausdrucks und können verschiedene Werte enthalten, die Sie später in diesem Tutorial sehen werden.

Im Folgenden wird die Syntax der Match-Funktion in Python beschrieben:

re.match(pattern, string, flags)

Sie hat drei Argumente,

  1. pattern ist das Muster des regulären Ausdrucks, das verglichen werden soll
  2. string ist die angegebene Zeichenkette, die mit dem regulären Ausdruck abgeglichen werden soll
  3. flags wird verwendet, um das Verhalten von regulären Ausdrücken zu ändern, und es ist optional.

Wenn der Abgleich erfolgreich durchgeführt wurde, wird das match Objekt zurückgegeben, andernfalls wird None zurückgegeben. Das match Objekt hat zwei weitere Hauptmethoden, die group(num) und group() Funktionen sind. Der Hauptzweck dieser Funktionen ist es, die Übereinstimmung oder eine bestimmte Untersequenz bzw. alle Untersequenzen zurückzugeben.

Verwendung der re.match Funktion

Das folgende Beispiel demonstriert, wie Sie die match Funktion nutzen können:

import re
strTest = "Hello Python Programming"
mobj = re.match(r"hello", strTest, re.I)
print(mobj.group())

In diesem Code wird zunächst das re Modul importiert. Dann wird ein String strTest mit dem RE-Muster verglichen und der von der Match-Funktion zurückgegebene Wert wird mobj zugewiesen. Die Abgleichsfunktion wird mit re aufgerufen, dann wird in Klammern das erste Argument das abzugleichende Muster angegeben, und dann wird die angegebene Zeichenkette, von der das Muster abgeglichen wird, und auch ein Flag-Wert übergeben. Hier ist re.I der Flag-Wert, was IGNORECASE bedeutet, so dass es ignoriert wird, ob das Muster und die Zeichenkette unterschiedliche Großbuchstaben haben (entweder Groß- oder Kleinbuchstaben).

Die Ausgabe ist :

Hello

In diesem Beispiel wird der Präfix r verwendet, der angibt, dass es sich bei dem String um einen Rohstring handelt. In einem Roh-String müssen keine doppelten Schrägstriche geschrieben werden, wenn Sie z.B. einen Backslash wollen, dann haben Sie nur einen einfachen \, aber keine doppelten Backslashes \\ wie in normalen Strings. Das ist der einzige Unterschied zwischen einem regulären String und einem rohen String.

Die Verwendung der re.match Funktion mit einem regulären String

Betrachten Sie das folgende Beispiel, in dem ein regulärer String anstelle eines rohen Strings verwendet wird:

import re
str = "\\tHello Python Programming"
mobj = re.match("\\thello", str, re.I) #no match

str = "\tHello Python Programming"
mobj = re.match("\\thello", str, re.I) #\thello is matching

Python regulärer Ausdruck re.search() Funktion

Sie können die Funktion re.search() verwenden, um das RE-Muster in der angegebenen Zeichenfolge zu suchen. Die search Funktion enthält drei Argumente in der Funktion das pattern, die gegebene string und die flags (optional).

Das folgende ist die Syntax der Suchfunktion in Python:

re.search(pattern, string, flags)

Der folgende Python-Code demonstriert die Verwendung der search() Funktion:

import re
str = "Hello Python Programming"
sobj = re.search(r"programming", str, re.I)
print(sobj.group())
programming

In diesem Code wird nach dem Wort programming gesucht. Die search Funktion sucht in der gesamten Zeichenkette. Der Unterschied zwischen search und match ist, dass die match Funktion nur am Anfang der Zeichenkette prüft, während search in der gesamten Zeichenkette sucht.

Wenn Sie am Anfang der Zeichenkette suchen wollen, dann können Sie ^ verwenden. Betrachten Sie das folgende Beispiel:

import re
str = "Hello Python Programming"
sobj = re.search(r"^programming", str, re.I)
print(sobj.group()) #no match is found

sobj = re.search(r"^hello", str, re.I)
print(sobj.group()) #matching: Hello

Hier wird ^ die Suche nur am Anfang der Zeichenkette durchführen.

Sie können auch am Ende der angegebenen Zeichenfolge suchen. Dies kann mit $ am Ende des Musters geschehen. Betrachten Sie den folgenden Code:

import re
str = "Hello Python Programming"
sobj = re.search(r"programming$", str, re.I)
print(sobj.group()) #matching: Programming

sobj = re.search(r"hello$", str, re.I)
print(sobj.group()) #no match found

Kompilieren von regulären Ausdrücken mit re.complie

Reguläre Ausdrücke in Python werden beim Kompilieren in Muster umgewandelt. Diese Muster sind eigentlich die Muster-Objekte, die verschiedene Funktionen enthalten, um verschiedene Aufgaben zu erfüllen, wie z.B. Suchen, Abgleichen und Ersetzen, etc.

Wenn Sie ein Muster kompilieren, können Sie dieses Muster später im Programm verwenden.

Vorkompilierte Muster verwenden

Betrachten Sie den folgenden Code, in dem das Muster r"\d" kompiliert wird, das die erste Ziffer in der Zeichenfolge bedeutet, und dann dieses Muster verwendet, um die Suchfunktion aufzurufen und eine Zeichenfolge in der Suchfunktion zu übergeben. Dieses Muster wird in der Zeichenkette, die der Suchfunktion übergeben wird, gesucht. In ähnlicher Weise können Sie dieses vorkompilierte Muster mit der Match-Funktion wie folgt verwenden:

import re
compPat = re.compile(r"(\d)")
sobj = compPat.search("Lalalala 123")
print(mobj.group())

mobj = compPat.match("234Lalalala 123456789")
print(mobj.group())
1
2

Flags im Python-Modul für den regulären Ausdruck re

Sie können Flags verwenden, um das Verhalten eines regulären Ausdrucks zu ändern. In einer Funktion sind Flags optional. Sie können Flags auf zwei verschiedene Arten verwenden, entweder durch die Verwendung des Schlüsselwortes flags und die Zuweisung des Wertes des Flags oder durch direktes Schreiben des Wertes des Flags. Sie koennen mehr als einen Wert des Flags im RE-Literal haben; dies kann durch die Verwendung des bitweisen OR-Operators | geschehen.

Betrachten Sie die folgende Tabelle, in der einige der gebräuchlichen Flags mit Literalen des Regulären Ausdrucks beschrieben werden:

Flag Wert Beschreibung
re.I Dieser Modifikator ignoriert den Fall von Strings und Patterns beim Abgleich.
re.L Dieser Modifikator wird verwendet, um Wörter in Bezug auf das aktuelle Gebietsschema zu interpretieren.
re.M Dieser Modifikator wird verwendet, um $ zum Ende der Zeile und nicht zum Ende der Zeichenkette passend zu machen. Ähnlich wird ^ am Anfang der Zeile statt am Anfang der Zeichenkette übereinstimmen.
re.S Dieser Modifikator wird benutzt, um einen Punkt . zu machen, der auf ein beliebiges Zeichen passt. Dies schließt auch einen Zeilenumbruch ein.
re.U Dieser Modifikator wird verwendet, um die Zeichen als Unicode-Zeichensatz zu interpretieren.
re.X Er wird verwendet, um die Whitespaces zu ignorieren. Er macht # als Markierung für einen Kommentar.

Verwendung mehrerer Flag-Werte

Betrachten Sie den folgenden Python-Code, in dem Sie sehen werden, wie Sie mehrere Flag-Werte verwenden können, um das Verhalten von RE zu ändern. Mehrere Flag-Werte können durch den bitweisen OR (|) Operator eingeschlossen werden:

import re
s = re.search("L", "Hello")
print(s)		#Output: None, L is there but in small letter and we didn't use flags

s = re.search("L", "Hello", re.I)
print(s)		#Output: 1

s = re.search("L", "^Hello", re.I | re.M)
print(s)		#Output: 1, searching will be made from the start of line and case is ignored

Prüfung auf erlaubte Zeichen

Sie können auch prüfen, ob eine bestimmte Zeichenfolge einen bestimmten Bereich von Zeichen enthält oder nicht.

Definieren einer Funktion und Überprüfung der erlaubten Zeichen

Betrachten Sie das folgende Beispiel, in dem eine Funktion definiert und auch vorkompilierte Muster verwendet werden, um zu prüfen, ob bestimmte Zeichen in der übergebenen Zeichenkette enthalten sind oder nicht:

import re
def check(str):
	s = re.compile(r'[^A-Z]')
	str = s.search(str)
	return not bool(str)
print(check("HELLOPYTHON"))		#Output: True
print(check("hellopython"))		#Output: False

In dieser Funktion wird ein Muster, das r '[^A-Z]' ist, kompiliert und verwendet, um in einer Zeichenkette zu suchen, die beim Aufruf dieser Funktion namens check übergeben wird. Diese Funktion prüft tatsächlich, ob die übergebene Zeichenkette die Buchstaben A-Z(Großbuchstaben) enthält oder nicht. Ähnlich kann man sehen, dass bei der Übergabe einer Zeichenkette in Kleinbuchstaben false zurückgegeben wird.

Suchen und Ersetzen

Das re Modul stellt eine Funktion zur Verfügung, die eine sub Funktion ist, die verwendet wird, um alle Vorkommnisse des pattern in der gegebenen string zu ersetzen, indem das repl Attribut in der Funktion verwendet wird. Die Zeichen werden so lange ersetzt, bis die count erreicht ist. Die sub Funktion gibt den aktualisierten String zurück.

Das folgende ist die Syntax der Subfunktion:

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

Verwendung der sub Funktion

Betrachten Sie das folgende Beispiel, in dem die Funktion sub die gesamte Zeichenkette durch eine bestimmte Zeichenkette ersetzt:

import re
s = "Playing 4 hours a day"
obj = re.sub(r'^.*$',"Working",s)
print(obj)
Working

Hier wird die sub Funktion verwendet. Das Muster r'^.*$ bedeutet vom Anfang der Zeichenkette und dann .* bedeutet, was auch immer in der Zeichenkette ist, bis zum Ende $ der Zeichenkette. Dann wird das Argument "Working" ganze Strings s ersetzen.

Mit der Funktion sub alle Ziffern einer Zeichenkette löschen

Betrachten Sie das folgende Beispiel, in dem die sub Funktion die Ziffern in der angegebenen Zeichenkette löscht. Zu diesem Zweck können Sie \d verwenden:

import re
s = "768 Working 2343 789 five 234 656 hours 324 4646 a 345 day"
obj = re.sub(r'\d',"",s)
print(obj)
Working   five   hours   a  day

Auf ähnliche Weise können Sie die Zeichen aus der Zeichenkette löschen. Zu diesem Zweck kann man \D verwenden.

import re
s = "768 Working 2343 789 five 234 656 hours 324 4646 a 345 day"
obj = re.sub(r'\D',"",s)
print(obj)
76823437892346563244646345

Die findall() Funktion

Die Funktion findall gibt eine Liste aller zum Muster passenden Strings zurück. Der Unterschied zwischen search und findall Funktion ist, dass findall alle Übereinstimmungen findet, während search nur die erste Übereinstimmung findet. Diese Funktion findet die nicht-überlappenden Übereinstimmungen und gibt sie als Liste von Zeichenketten zurück.

Das folgende ist die Syntax der Funktion findall:

findall(pattern, string, flags)

Hier ist pattern das RE-Muster, das Sie in der angegebenen string mit einigen flags -Werten finden, z.B. re.I, um Groß- und Kleinschreibung zu ignorieren.

Finde alle nicht überlappenden Übereinstimmungen

Im folgenden Beispiel findet findall nicht überlappende Übereinstimmungen:

import re
str = "Working 6 hours a day. Studying 4 hours a day."
mobj = re.findall(r'[0-9]', str)
print(mobj)
['6', '4']

r'[0-9]' is a pattern finding all the digits in the given string and a list of strings is returned (no matter they are digits) which is stored in mobj.

findall mit Dateien

Sie können auch findall verwenden, um in einer Datei zu finden. Wenn Sie findall mit einer Datei benutzen, wird eine Liste aller passenden Zeichenketten in der Datei zurückgegeben. Da die read() Funktion der Datei verwendet wird, müssen Sie nicht durch jede Zeile der Datei iterieren, indem Sie eine Schleife verwenden, da sie den gesamten Text der Datei als Zeichenkette zurückgibt. Betrachten Sie das folgende Beispiel:

import re
file = open('asd.txt', 'r')
mobj = re.findall(r'arg.', file.read())
print(mobj)
file.close()
['arg,', 'arg,', 'arg,', 'argv', 'argv', 'argv']

In diesem Beispiel wird die Datei zuerst im Lesemodus geöffnet. Das Muster r'arg.' wird mit dem Inhalt der Datei abgeglichen und Sie haben die Liste der passenden Zeichenketten in der Ausgabe.

Die finditer() Funktion

Die finditer Funktion kann verwendet werden, um das RE-Muster in Strings zu finden, zusammen mit der Position der passenden Strings, die der Index der Strings ist. Diese Funktion iteriert tatsächlich durch die übereinstimmenden Zeichenketten und gibt die Indizes oder Positionen der Zeichenkette zurück.

Das Folgende ist die Syntax der finditer Funktion:

finditer(pattern, string, flags)

Iterieren über Übereinstimmungen

Der einzige Unterschied zwischen findall und finditer ist, dass finditer auch den Index zusammen mit passenden Strings zurückgibt. Im folgenden Code wird finditer verwendet, um die Positionen der passenden Zeichenketten zu finden, während die Iteration über Übereinstimmungen (übereinstimmende Zeichenketten) für die Schleife verwendet wird.

import re
str = "Working 6 hours a day. Studying 4 hours a day."
pat = r'[0-9]'
for mobj in re.finditer(pat, str):
    s = mobj.start()
    e = mobj.end()
    g = mobj.group()
    print('{} found at location [{},{}]'.format(g, s, e))
6 found at location [8,9]
4 found at location [32,33]

In diesem Beispiel ist das Muster die Ziffern von 0 bis 9, die in str gefunden werden. for”-Schleife iteriert über die passenden Zeichenketten, die von finditer zurückgegeben werden. In der Schleife geben die Funktionen start, end und group den Start-Index, den End-Index und die gefundene Übereinstimmung in jeder Iteration der von finditer zurückgegebenen Zeichenkette zurück.

Die Funktion split()

Die split Funktion wird verwendet, um einen String zu teilen.

Das folgende ist die Syntax der Split-Funktion:

split(patter, string, maxsplit, flags)

Hier ist max die Gesamtzahl der String-Splits. Wenn höchstens maxsplit Splits auftreten, wird der Rest der Zeichenkette als letztes Element der Liste zurückgegeben. Der Standardwert von max ist 0, was unbegrenzte Splits bedeutet.

Aufteilen einer Zeichenkette

split Funktion gibt jedes Wort in einer Zeichenkette zurück

Im folgenden Code wird ein String nach dem angegebenen Muster und der Anzahl der maximalen Aufteilungen aufgeteilt.

import re
str = "Birds fly high in the sky for ever"
mobj = re.split('\s+', str, 5)
print(mobj)
['Birds', 'fly', 'high', 'in', 'the', 'sky for ever']

In diesem Beispiel ist das Muster-Zeichen \s ein Sonderzeichen, das mit dem Leerzeichen übereinstimmt, also äquivalent zu [ \t\n\r\f\v] ist. Daher könnten Sie Wörter getrennt haben. Der Wert von max ist hier 5, was 6 Split macht, und das letzte Element ist der Rest der Zeichenkette nach dem 5.

Grundmuster von re

Reguläre Ausdrücke können Muster angeben, die mit gegebenen Zeichenketten verglichen werden. Die folgenden sind die grundlegenden Muster von regulären Ausdrücken:

Muster Beschreibung
^ Sie wird verwendet, um am Anfang der Zeichenkette zu passen.
$ Dieses Muster wird am Ende des Strings übereinstimmen.
. Punkt wird verwendet, um ein Zeichen zu finden (Zeilenumbruch ist nicht enthalten).
[...] Es wird verwendet, um ein einzelnes Zeichen innerhalb von Klammern abzugleichen.
[^...] Dies passt auf ein einzelnes Zeichen, aber nicht in Klammern.
* 0 oder mehr Vorkommnisse von vorhergehenden re in der gegebenen Zeichenkette.
+ 1 oder mehrere Vorkommen von vorhergehenden re in der gegebenen Zeichenkette.
? 0 oder 1 Vorkommen des vorhergehenden re in der gegebenen Zeichenkette.
{n} Es wird n Anzahl der Vorkommen in der angegebenen Zeichenkette übereinstimmen.
{n,} Es wird n oder mehr als n Anzahl der Vorkommen entsprechen.
{n,m} Dieses Muster wird verwendet, um mindestens n und höchstens m Übereinstimmungen in der Zeichenkette zu finden.
a | b Es wird entweder mit a oder b übereinstimmen.
(re) Dieses Muster wird verwendet, um die regulären Ausdrücke zu gruppieren und es wird sich den übereinstimmenden Text merken.
(?imx) Es schaltet vorübergehend auf i oder m oder x in RE um. Bei Verwendung von Klammern ist nur der Klammerbereich betroffen.
(?-imx) Es schaltet vorübergehend i oder m oder x in RE aus. Bei Verwendung von Klammern ist nur der Klammerbereich betroffen.
(?: re) Dieses Muster wird verwendet, um die regulären Ausdrücke zu gruppieren, aber es wird sich nicht an den übereinstimmenden Text erinnern.
(?imx: re) Es schaltet vorübergehend auf i oder m oder x in RE in Klammern um.
(?-imx: re) Es schaltet vorübergehend i oder m oder x in RE in Klammern aus.
(?#...) Es ist ein Kommentar.
(?= re) Sie dient zur Angabe der Position mit Hilfe eines Musters. Es hat keine Reichweite.
(?! re) Sie dient zur Angabe der Position durch eine Muster-Negation. Sie hat keine Reichweite.
(?> re) Dieses Muster wird verwendet, um unabhängige Muster abzugleichen.
\w Dieses Muster wird verwendet, um Wörter abzugleichen.
\W Dieses Muster wird verwendet, um Nicht-Wörter abzugleichen.
\s Es wird zu den Leerzeichen passen. \Das ist gleichbedeutend mit…
\S Es wird mit nicht-weißen Räumen übereinstimmen.
\d …gleich “0-9”. Es stimmt mit den Ziffern in der Zeichenkette überein.
\D Es stimmt mit Nicht-Ziffern überein.
\A mit dem Anfang der Zeichenkette übereinstimmen.
\Z das Ende der Zeichenkette übereinstimmen. Und wenn es einen Zeilenumbruch gibt, wird es vor dem Zeilenumbruch übereinstimmen.
\G bis zu dem Punkt, an dem das letzte Spiel beendet wurde.
\b passt zu den Wortgrenzen, wenn es außerhalb der Klammern steht, aber wenn es innerhalb der Klammern steht, passt es zur Rücktaste.
\B mit Nicht-Wortgrenzen übereinstimmen.
\n, \t, etc. \n wird benutzt, um Zeilenumbrüche zu vergleichen, \t wird mit Tabulator übereinstimmen und so weiter.
\1...\9 Dieses Muster wird mit dem n-ten Unterausdruck (gruppiert) übereinstimmen.
\10 \10 stimmt normalerweise mit dem n-ten Unterausdruck (gruppiert) überein, wenn die Übereinstimmung bereits erfolgt ist. Wenn die Übereinstimmung nicht bereits erfolgt ist, liefert \10 eine oktale Darstellung eines Zeichencodes.

Wiederholungsfälle

Die folgende Tabelle zeigt einige Beispiele für Wiederholungsfälle mit Beschreibung:

Beispiele Beschreibungen
ab? Es wird entweder mit a oder ab übereinstimmen.
ab* ab* wird mit ab und a’s übereinstimmen und jedes a’s gefolgt von jedem b’s.
ab+ ab+ bedeutet a’s gefolgt von b’s und nicht nur a. a muss von ungleich Null b gefolgt werden.
\d{2} Sie wird genau 2 Ziffern entsprechen.
\d{2,} Sie wird mit 2 oder mehr Ziffern übereinstimmen.
\d{2,4} Sie wird mit den Ziffern 2, 3 und 4 übereinstimmen.

~ Nongreedy repetition ~

In regulären Ausdrücken ist die Wiederholung standardmäßig gierig, die versucht, so viele Wiederholungen wie möglich abzugleichen.

Die Qualifizierer wie *, + und ? sind gierige Qualifizierer. Wenn Sie .* verwenden, wird ein gieriger Abgleich durchgeführt und die gesamte Zeichenkette wird übereinstimmen, was dazu führt, dass so viele Zeichen wie möglich übereinstimmen. Betrachten Sie den folgenden Code:

import re
mobj = re.match(r'.*', "Birds fly high in sky")
print(mobj.group())
Birds fly high in the sky

So kannst du hier sehen, dass die gesamte Zeichenkette übereinstimmt.

Wenn Sie ? mit .+ hinzufügen, haben Sie ein nicht gieriges re und das Muster .+? wird mit so wenigen Zeichen wie möglich in der Zeichenkette übereinstimmen.

import re
mobj = re.match(r'.*', "Birds fly high in sky")
print(mobj.group())

Das Ergebnis ist das erste Zeichen der Zeichenkette

B

Sonderzeichen und Sequenzen in re

Sonderzeichen in re beginnen mit einem \\. Zum Beispiel haben wir \A, das vom Anfang der Zeichenkette an passt.

Diese Sonderzeichen sind in der obigen Tabelle beschrieben.

In diesem Abschnitt werden Ihnen die Beispiele einiger der Sonderzeichen demonstriert:

import re
str = "Birds fly high in the sky"
# \A
mobj = re.match(r'\Ab', str, re.I) #OUTPUT: B, here \A will match at beginning only.

#\d
mobj = re.match(r'\d', "4 birds are flying") #OUTPUT: 4

#\s
mobj = re.split('\s+', "birds fly high in the sky", 1) #OUTPUT: ['Birds', 'fly']

Die escape Funktion

Die escape Funktion wird verwendet, um alle Zeichen aus der Zeichenkette zu escapen. Die ASCII-Buchstaben, Zahlen und _ werden nicht escaped. Die escape Funktion wird verwendet, wenn Sie Metazeichen aus einer Zeichenkette extrahieren wollen.

Es folgt die Syntax der Escape-Funktion:

escape(pattern)

Im folgenden Beispiel wird eine Zeichenkette www.python.com an die Escape-Funktion übergeben. In diesem Beispiel haben wir ., welches ein Metazeichen ist und es wird extrahiert oder abgeglichen:

print(re.escape('www.python.com'))
www\.python\.com

Hier ist . ein Metazeichen, das extrahiert oder angepasst wird. Wann immer ein Metazeichen mit der Escape-Funktion gefunden wird, steht vor dem Zeichen ein \.

Escaping Sonderzeichen

Die Zeichen wie die Klammern [ und ] können nicht zugeordnet werden. Betrachten Sie das folgende Beispiel:

import re
mobj = re.search(r'[a]', '[a]b')
print(mobj.group())
a

Hier sehen Sie, dass die Klammern [ und ] nicht übereinstimmen.

Sie können sie mit Hilfe der Escape-Funktion anpassen:

import re
mobj = re.search(r'\[a\]', '[a]b')
print(mobj.group())
[a]b

Die group() Funktion

Die group Funktion wird verwendet, um eine oder mehrere Untergruppen der gefundenen Übereinstimmung zurückzugeben. Die group Funktion kann einige Argumente haben.

Das folgende ist die Syntax der group Funktion:

group(group1, group2,..., groupN)

Wenn Sie ein einzelnes Argument in einer Gruppenfunktion haben, wird das Ergebnis eine einzelne Zeichenkette sein, aber wenn Sie mehr als ein Argument haben, dann wird das Ergebnis ein Tupel sein (das ein Element pro Argument enthält).

Wenn es kein Argument gibt, ist das Argument standardmäßig Null und gibt die gesamte Übereinstimmung zurück.

Wenn das Argument groupN null ist, wird die gesamte übereinstimmende Zeichenkette zurückgegeben.

Wenn Sie die Gruppennummer oder das Argument als einen negativen Wert oder einen Wert, der größer als die Anzahl der Gruppen in pattern ist, angeben, dann wird die Ausnahme IndexError auftreten.

Betrachten Sie den folgenden Code, in dem es kein Argument in der Funktion group gibt, das group(0) entspricht.

import re
str = "Working 6 hours a day"
mobj = re.match(r'^.*', str)
print(mobj.group())
Working 6 hours a day

Hier wird group() verwendet und Sie haben die gesamte übereinstimmende Zeichenkette.

Teile von übereinstimmenden Texten auswählen

Im folgenden Beispiel wird die Funktion group mit Argumenten verwendet, um passende Gruppen zu finden:

import re
a = re.compile('(p(q)r)s')
b = a.match('pqrs')
print(b.group(0))
print(b.group(1))
print(b.group(2))
pqrs
pqr
q

Hier gibt group(0) die gesamte Übereinstimmung zurück. group(1) wird die erste Übereinstimmung zurückgeben, die pqr ist, und group(2) wird die zweite Übereinstimmung zurückgeben, die q ist.

Benannte Gruppen

Mit Hilfe von benannten Gruppen können Sie eine Aufnahmegruppe erstellen. Diese Gruppe kann dann über den Namen referenziert werden. Betrachten Sie das folgende Beispiel:

import re
mobj = re.search(r'Hi (?P<name>\w+)', 'Hi Roger')
print(mobj.group('name'))
Roger

Nicht-erfassende Gruppen

Eine nicht-erfassende Gruppe kann mit ?: erstellt werden. Die Non-capturing group wird verwendet, wenn Sie den Inhalt der Gruppe nicht wünschen.

import re
mobj = re.match("(?:[pqr])+", "pqr")
print(mobj.groups())
()
comments powered by Disqus