Python | Erklärung der Verwendung regulärer Ausdrücke (Re-Modul) und Beispiele für jede Funktion

Offizielle Dokumentadresse: https://docs.python.org/zh-cn/3/library/re.html

4 Funktionen, die reguläre Ausdrücke abgleichen und passende Ergebnisse zurückgeben

Im Re-Paket für reguläre Ausdrücke von Python gibt es die folgenden vier Funktionen, die scannen, ob ein reguläres Ausdrucksmuster mit einer bestimmten Position in der Zeichenfolge übereinstimmt, und ein Match-Objekt des übereinstimmenden Ergebnisses zurückgeben oder generieren.

Es ist zu beachten, dass sich bei diesen vier Funktionen das Finden keiner Position, die mit dem Muster in der Zeichenfolge übereinstimmt, von der Suche nach einer Übereinstimmung mit der Länge Null an einer bestimmten Position unterscheidet.

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

Durchsucht die gesamte Zeichenfolge, um die erste Position zu finden, an der das Muster des regulären Ausdrucks eine Übereinstimmung erzeugt , und gibt das entsprechende Match-Objekt zurück. Gibt zurück, wenn es keine Position in der Zeichenfolge gibt, die mit dem Muster übereinstimmt None. Zum Beispiel:

import re

# 定义要匹配的字符串
text = "Hello, how are you today?"

# 定义要查找的正则表达式
word = "y.*u"

# 使用 re.search 查找单词在字符串中的位置
match = re.search(word, text)

print(match)  # 输出: <re.Match object; span=(15, 18), match='you'>

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

Wenn null oder mehr Zeichen am Anfang der Zeichenfolge mit dem regulären Ausdrucksmuster übereinstimmen, wird das entsprechende Match-Objekt zurückgegeben. Wird zurückgegeben, wenn die Zeichenfolge nicht mit dem Muster übereinstimmt None.

Beachten Sie außerdem, dass auch bei Auswahl des Mehrzeilenmodus re.match()nur der Anfang der Zeichenfolge abgeglichen wird, nicht der Anfang jeder Zeile. Wenn Sie die Startposition jeder Zeile anpassen müssen, können Sie dies mithilfe der search()Methodenanpassung ^erreichen. Zum Beispiel:

import re

# 定义要匹配的字符串
text = "Hello, World!"

# 定义要查找的正则表达式
pattern = r"Hel+o"

# 使用 re.match 进行匹配
match = re.match(pattern, text)

print(match)  # 输出: <re.Match object; span=(0, 5), match='Hello'>

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

Wenn die gesamte Zeichenfolge mit dem regulären Ausdrucksmuster übereinstimmt, wird das entsprechende Match-Objekt zurückgegeben. Wird zurückgegeben, wenn die Zeichenfolge nicht mit dem Muster übereinstimmt None. Zum Beispiel:

import re

# 定义要匹配的字符串
string1 = "Hello123"
string2 = "Hello World"
string3 = "Hello_123"

# 定义要查找的正则表达式
pattern = r"^[A-Za-z0-9_]+$"

# 使用 re.fullmatch 进行匹配
match1 = re.fullmatch(pattern, string1)
match2 = re.fullmatch(pattern, string2)
match3 = re.fullmatch(pattern, string3)

print(match1)  # 输出: <re.Match object; span=(0, 8), match='Hello123'>
print(match2)  # 输出: None
print(match3)  # 输出: <re.Match object; span=(0, 9), match='Hello_123'>

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

Gibt einen Iterator zurück, der Match-Objekte für alle nicht überlappenden Übereinstimmungen des regulären Ausdrucksmusters in string liefert. Die Zeichenfolge wird von links nach rechts durchsucht und Treffer werden in der Reihenfolge zurückgegeben, in der sie gefunden wurden.

Auch leere Treffer werden in die Ergebnisse einbezogen. Zum Beispiel:

import re

# 定义要匹配的字符串
string = "I have 3 apples and 5 oranges."

# 定义要查找的正则表达式
pattern = r"\d+"

# 使用 re.finditer 进行匹配
matches = re.finditer(pattern, string)

for match in matches:  # 遍历匹配结果
    print(match.group())

Die Ausgabe des obigen Beispiels ist:

3
5

Eine Änderung in Python 3.7 ermöglicht das Erscheinen einer nicht leeren Übereinstimmung nach einer vorherigen leeren Übereinstimmung.

Objekt abgleichen ( re.Match)

Die von den oben genannten vier Funktionen zurückgegebenen Übereinstimmungsergebnisse sind alle re.MatchObjekte. Match-Objekte verfügen über die folgenden häufig verwendeten Methoden:

Match.expand(template)

Ersetzen Sie den Backslash in der Vorlage durch das übereinstimmende entsprechende Zeichen und geben Sie das ersetzte Ergebnis zurück. Zum Beispiel:

import re

pattern = r"(\d{4})-(\d{2})-(\d{2})"
text = "今天是2023-09-17"

match = re.search(pattern, text)
if match:
    new_text = match.expand(r"现在是\1年\2月\3日")
    print(new_text)  # 输出: 现在是2023年09月17日

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

Gibt eine oder mehrere passende Untergruppen zurück. Wenn es nur ein Argument gibt, ist das Ergebnis ein String; wenn es mehrere Argumente gibt, ist das Ergebnis ein Tupel (ein Element für jedes Argument); wenn es keine Argumente gibt, wird der gesamte String zurückgegeben.

Wenn der Eingabeparameter 0 ist, wird auch der gesamte String zurückgegeben.

Für reguläre Ausdrucksvergleichsergebnisse mithilfe von ()Syntaxannotationsuntergruppen können wir ganzzahlige Parameter verwenden, um die entsprechenden Untergruppen zu erhalten. Zum Beispiel:

import re

pattern = r"(\d{4})-(\d{2})-(\d{2})"
date = "2023-09-07"

match = re.match(pattern, date)
if match:
    year = match.group(1)
    month = match.group(2)
    day = match.group(3)
    print(f"Year: {
      
      year}, Month: {
      
      month}, Day: {
      
      day}")  # 输出: Year: 2023, Month: 09, Day: 17

Für reguläre Ausdrucksvergleichsergebnisse mithilfe von (?P<name>...)Untergruppen mit Syntaxanmerkungen können wir String-Typ-Parameter verwenden, um die entsprechenden Untergruppen zu erhalten. Zum Beispiel:

import re

pattern = r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})"
date = "2023-09-07"

match = re.match(pattern, date)
if match:
    year = match.group("year")
    month = match.group("month")
    day = match.group("day")
    print(f"Year: {
      
      year}, Month: {
      
      month}, Day: {
      
      day}")  # 输出: Year: 2023, Month: 09, Day: 17

Wenn keine Parameter angegeben werden, wird die gesamte übereinstimmende Zeichenfolge zurückgegeben. Zum Beispiel:

import re

pattern = r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})"
date = "2023-09-07"

match = re.match(pattern, date)
if match:
    matched_string = match.group()
    print(matched_string)  # 输出: 2023-09-07

Match.__getitem__(g)

Entspricht Match.group(g).

Match.groups(default=None)

Gibt ein Tupel zurück, das alle passenden Untergruppen enthält.

Wenn der Standardparameter lautet None, werden keine passenden Untergruppen zurückgegeben None. Zum Beispiel:

import re

pattern = r"(\d{3})-(\d{3})-(\d{3})?"
text = "Phone numbers: 123-456-"

match = re.search(pattern, text)

# 返回匹配到的所有分组
groups_without_default = match.groups()

print(groups_without_default)  # 输出: ('123', '456', None)

Wenn der Standardparameter nicht lautet None, werden nicht übereinstimmende Untergruppen durch den Wert des Standardparameters ersetzt. Zum Beispiel:

import re

pattern = r"(\d{3})-(\d{3})-(\d{3})?"
text = "Phone numbers: 123-456-"

match = re.search(pattern, text)

# 返回匹配到的所有分组，如果分组没有匹配到内容，则返回默认值 "-"
groups_with_default = match.groups("-")

print(groups_with_default)  # 输出: ('123', '456', '-')

Match.groupdict(default=None)

Gibt ein Wörterbuch zurück, das alle benannten Untergruppen enthält. Der Schlüssel des Wörterbuchs ist der Gruppenname. Wenn der Standardparameter lautet None, werden keine passenden Untergruppen zurückgegeben None. Wenn der Standardparameter nicht lautet None, werden nicht übereinstimmende Untergruppen durch den Wert des Standardparameters ersetzt. Zum Beispiel:

import re

pattern = r"(?P<first_name>\w+) (?P<last_name>\w+)"
text = "John Doe"

match = re.search(pattern, text)

# 使用 groupdict() 方法获取命名分组的字典
name_dict = match.groupdict()

print(name_dict)  # 输出: {'first_name': 'John', 'last_name': 'Doe'}

Match.start([group])、Match.end([group])

Gibt die Start- und Endpositionsindizes der Teilzeichenfolge zurück, die mit der Gruppe in der Originalzeichenfolge übereinstimmt. Verwenden Sie in der Originalzeichenfolge Slicing, m.string[m.start(g), m.end(g)]um die übereinstimmende Zeichenfolge zu erhalten, die äquivalent ist m.group(g). Die Gruppe ist standardmäßig auf 0 eingestellt, was der gesamten übereinstimmenden Zeichenfolge entspricht.

import re

pattern = r"\b\w{3,5}\b"
text = "Hello, world! This is a test."

for match in re.finditer(pattern, text):
    # 获取匹配子串的起始位置和结束位置索引
    start_index = match.start()
    end_index = match.end()

    # 打印结果
    print(f"Match: {
      
      text[start_index:end_index]}, Start: {
      
      start_index}, End: {
      
      end_index}")

Die Ausgabe des obigen Beispiels ist:

Match: Hello, Start: 0, End: 5
Match: world, Start: 7, End: 12
Match: This, Start: 14, End: 18
Match: test, Start: 24, End: 28

Wenn der Gruppenparameter vorhanden ist, die entsprechende Teilzeichenfolge jedoch nicht in der Zeichenfolge übereinstimmt, wird er zurückgegeben -1. Zum Beispiel:

import re

pattern = r"(\w+),? (\w+)?"
text = "John, "

match = re.search(pattern, text)

print(f"Group 1: {
      
      text[match.start(1):match.end(1)]}, Start: {
      
      match.start(1)}, End: {
      
      match.end(1)}")  # 输出: Group 1: John, Start: 0, End: 4
print(f"Group 2: {
      
      text[match.start(2):match.end(2)]}, Start: {
      
      match.start(2)}, End: {
      
      match.end(2)}")  # 输出: Group 2: , Start: -1, End: -1

Match.span([group])

Gibt ein Tupel zurück (m.start(group), m.end(group)). Wenn der Gruppenparameter vorhanden ist, die entsprechende Teilzeichenfolge jedoch nicht in der Zeichenfolge übereinstimmt, wird er zurückgegeben (-1, -1).

Match.pos、Match.endpos

Der Positionsindex in der Zeichenfolge zum Starten und Beenden der Suche. Diese beiden Parameter können nur bei Verwendung von regulären Ausdrucksobjekten konfiguriert werden.

Match.lastindex

Der Indexwert der letzten übereinstimmenden Untergruppe. Wenn die zweite Untergruppe nicht übereinstimmt, die dritte Untergruppe jedoch übereinstimmt, wird sie zurückgegeben 3. Wenn keine Untergruppen übereinstimmen, wird zurückgegeben None.

Zum Beispiel:

import re

pattern = r"(\w+)?\s+(\d+)?\s+(\w+)?"
text = "John 4 Dog, Jane  Tiger, Tom  ,  "

for match in re.finditer(pattern, text):
    print(f"Name: {
      
      match[1]}, Age: {
      
      match[2]}, Species: {
      
      match[3]}, Last captured group index: {
      
      match.lastindex}")

Die Ausgabe des obigen Beispiels ist:

Name: John, Age: 4, Species: Dog, Last captured group index: 3
Name: Jane, Age: None, Species: Tiger, Last captured group index: 3
Name: Tom, Age: None, Species: None, Last captured group index: 1
Name: None, Age: None, Species: None, Last captured group index: None

Match.lastgroup

Der Name der zuletzt genannten Gruppe stimmte überein. Wenn die zweite Untergruppe nicht übereinstimmt, die dritte Untergruppe jedoch übereinstimmt, wird der Name der dritten Untergruppe zurückgegeben. Wenn keine Untergruppen übereinstimmen, wird zurückgegeben None. Die spezifischen Rückgaberegeln Match.groupindexähneln denen von .

Zum Beispiel:

import re

pattern = r"(?P<name>\w+)?\s+(?P<age>\d+)?\s+(?P<species>\w+)?"
text = "John 4 Dog, Jane  Tiger, Tom  ,  "

for match in re.finditer(pattern, text):
    print(f"Name: {
      
      match['name']}, Age: {
      
      match['age']}, Species: {
      
      match['species']}, "
          f"Last captured group name: {
      
      match.lastgroup}")

Die Ausgabe des obigen Beispiels ist:

Name: John, Age: 4, Species: Dog, Last captured group name: species
Name: Jane, Age: None, Species: Tiger, Last captured group name: species
Name: Tom, Age: None, Species: None, Last captured group name: name
Name: None, Age: None, Species: None, Last captured group name: None

Match.re

Gibt die reguläre Objektinstanz zurück, die diese passende Objektinstanz erzeugt hat.

Match.string

match()Gibt die an and übergebene Zeichenfolge zurück search().

5 Funktionen zum direkten Arbeiten mit Strings

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

Trennen Sie Zeichenfolgen mithilfe eines Musters und geben Sie eine Liste von Zeichenfolgen zurück. Zum Beispiel:

import re

pattern = r"\W+"  # 用任意非单词字符分割
text = "Words, words, words."

print(re.split(pattern, text))  # 输出: ['Words', 'words', 'words', '']

Wenn Untergruppen im Muster erfasst werden, wird auch der gesamte Text der Gruppe in die Liste aufgenommen.

import re

pattern = r"(\W+)"  # 用任意非单词字符分割
text = "Words, words, words."

print(re.split(pattern, text))  # 输出: ['Words', 'words', 'words', '']

Wenn der Parameter maxsplit ungleich Null ist, werden höchstens maxsplit-Splits durchgeführt und alle verbleibenden Zeichen werden an das letzte Element der Liste zurückgegeben.

import re

pattern = r"\W+"  # 用任意非单词字符分割
text = "Words, words, words."

print(re.split(pattern, text, maxsplit=1))  # 输出: ['Words', 'words, words.']

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

Gibt alle überlappenden Musterübereinstimmungen in der Zeichenfolge als Liste von Zeichenfolgen oder Tupel von Zeichenfolgen zurück. Die Zeichenfolge wird von links nach rechts durchsucht und übereinstimmende Ergebnisse werden in der gefundenen Reihenfolge zurückgegeben. Auch leere Treffer werden in die Ergebnisse einbezogen.

Das Format der zurückgegebenen Ergebnisse hängt von der Anzahl der Untergruppen im Muster ab. Wenn keine Gruppen vorhanden sind, wird eine Liste von Zeichenfolgen zurückgegeben, die dem gesamten Muster entsprechen. Wenn es genau eine Gruppe gibt, wird eine Liste von Zeichenfolgen zurückgegeben, die dieser Gruppe entsprechen. Wenn mehrere Gruppen vorhanden sind, wird eine Liste von Zeichenfolgentupeln zurückgegeben, die diesen Gruppen entsprechen. Zum Beispiel:

import re

print(re.findall(r"\d+", "I have 3 apples and 5 oranges."))  # 输出: ['3', '5']
print(re.findall(r"(\w+)=(\d+)", "set width=20 and height=10"))  # 输出: [('width', '20'), ('height', '10')]
print(re.findall(r"(\d+)", "set width=20 and height=10"))  # 输出: ['20', '10']

Eine Änderung in Python 3.7 ermöglicht das Erscheinen einer nicht leeren Übereinstimmung nach einer vorherigen leeren Übereinstimmung.

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

Verwenden Sie repl nacheinander, um die nicht überlappenden Muster auf der äußersten linken Seite der Zeichenfolge zu ersetzen, bis der Musterstil nicht mehr in der Zeichenfolge vorhanden ist, und geben Sie die ersetzte Zeichenfolge zurück. Wenn der Stil nicht gefunden wird, wird die Zeichenfolge unverändert zurückgegeben. repl kann ein String oder eine Funktion sein.

Wenn repl eine Zeichenfolge ist, wird das übereinstimmende Muster direkt durch repl ersetzt. Zum Beispiel:

import re

text = "Helo! Hello, World!"

# 使用 re.sub() 方法将 "Hello" 替换为 "Hi"
new_text = re.sub("Hel+o", "Hi", text)

print(new_text) # 输出: Hi! Hi, World!

Wenn repl eine Funktion ist, wird sie für jedes übereinstimmende Muster aufgerufen. Die Funktion sollte einen einzelnen re.MatchParameter akzeptieren und die ersetzte Zeichenfolge zurückgeben. Zum Beispiel:

import re


def my_repl(match: re.Match) -> str:
    """自定义替换方法"""
    return match.group(0) + len(match.group(0)) * "o"


text = "Helo! Hello, World!"

# 使用 re.sub() 方法将 "Hello" 替换为 "Hi"
new_text = re.sub("Hel+o", my_repl, text)

print(new_text)  # Helooooo! Helloooooo, World!

Der optionale Parameter count gibt die maximale Anzahl der durchzuführenden Ersetzungen an und count muss eine nicht negative ganze Zahl sein. Wenn dieser Parameter weggelassen oder auf 0 gesetzt wird, werden alle Übereinstimmungen ersetzt.

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

Identisch mit re.sub(), gibt aber ein Tupel zurück (字符串, 替换次数). Zum Beispiel:

import re

text = "Helo! Hello, World!"

# 使用 re.sub() 方法将 "Hello" 替换为 "Hi"
new_text = re.subn("Hel+o", "Hi", text)

print(new_text)  # 输出: ('Hi! Hi, World!', 2)

re.escape(pattern)

Wird verwendet, um Sonderzeichen im Muster zu maskieren. Sie können dies verwenden, wenn Sie Textzeichenfolgen abgleichen müssen, die Metazeichen regulärer Ausdrücke enthalten.

import re

# 假设我们要匹配一个字符串中的所有特殊字符
text = "Hello! How are you? [This] is a test."

# 使用 re.escape 转义特殊字符
pattern = re.escape("[")

print(pattern)  # 输出: \[

# 使用转义后的模式进行匹配
matches = re.findall(pattern, text)

print(matches)  # 输出: ['[']

Reguläres Objekt ( re.Pattern) und regelmäßige Matching-Leistungsoptimierung

Wenn wir einen regulären Ausdruck häufig verwenden müssen, können wir den regulären Ausdruck zunächst kompilieren, re.compile()um eine häufige Kompilierung des regulären Ausdrucks zu vermeiden.

re.compile(pattern, flags=0)

Kompiliert den regulären Ausdruck in ein reguläres Ausdrucksobjekt ( re.Pattern). Das reguläre Ausdrucksobjekt kann nicht re.search()nur re.match()für den Musterparameter jeder RE-Modulfunktion verwendet werden, sondern auch für die direkte Verwendung der Methode dieses match()Objekts search(). Zum Beispiel:

import re

# 编译正则表达式模式
pattern = re.compile("Hel+o")

print(type(pattern), pattern)  # 输出: <class 're.Pattern'> re.compile('Hel+o')

# 使用正则表达式的模式进行匹配
match = re.search(pattern, "Helo! Hello, World!")

print(match)  # 输出: <re.Match object; span=(0, 4), match='Helo'>

re.Pattern

Im PatternObjekt sind die folgenden regulären Matching-Methoden implementiert: Zusätzlich zum Hinzufügen optionaler Parameter posund endposentsprechen andere Funktionen dieser Methoden den entsprechenden Funktionen des re-Moduls.

Methodenname	Äquivalenter Name der Modulfunktion
Pattern.search()	re.search()
Pattern.match()	re.match()
Pattern.fullmatch()	re.fullmatch()
Pattern.split()	re.split()
Pattern.findall()	re.findall()
Pattern.finditer()	re.finditer()
Pattern.sub()	re.sub()
Pattern.subn()	re.subn()

Darüber hinaus re.Patternverfügt das Objekt über 4 Attribute, deren Bedeutung und Beispiele wie folgt lauten:

Attributname	Bedeutung von Attributen
Pattern.flags	Regulärer Ausdrucksmarker, der als re.compile()Parameter an übergeben wird
Pattern.groups	Die erfasste Musterzeichenfolge ist diejenige, aus der die Ratte stammt
Pattern.groupindex	(?P<id>)Ein Wörterbuch , das benannte Symbolkombinationen und durch definierte Zahlenkombinationen zuordnet . Wenn keine Symbolgruppe vorhanden ist, ist das Wörterbuch leer
Pattern.pattern	Die rohe Stilzeichenfolge des kompilierten Objekts.

import re

pattern = re.compile(r"(?P<name>\w+)?\s+(?P<age>\d+)?\s+(?P<species>\w+)?")

print(pattern.flags)  # 输出: 32
print(pattern.groups)  # 输出: 3
print(pattern.groupindex)  # 输出: {'name': 1, 'age': 2, 'species': 3}
print(pattern.pattern)  # 输出: (?P<name>\w+)?\s+(?P<age>\d+)?\s+(?P<species>\w+)?

posund endposParameter

Von den fünf Methoden re.Patternvon re.search(), re.match(), re.fullmatch(), unterstützen alle die optionalen re.findall()und - Parameter.re.finditer()posendpos

Optionales Argument pos, das den Index in der Zeichenfolge angibt, bei dem die Suche gestartet werden soll. Der Standardwert ist 0. Es ist zu beachten, dass dies nicht genau dem String-Slicing entspricht. "^"Das Stilzeichen stimmt mit dem tatsächlichen Anfang der Zeichenfolge und dem ersten Zeichen nach dem Zeilenumbruchzeichen überein, stimmt jedoch nicht mit dem Positionsindex überein, an dem die Suche beginnt.

Das optionale Argument endposqualifiziert den Index, an dem die Zeichenfolgensuche endet, vorausgesetzt, die Zeichenfolge ist nur so lang wie endpos.

Es werden also nur Zeichen von posbis abgeglichen. endpos - 1 Wenn posgrößer als, endposerfolgt keine Übereinstimmung.

Zum Beispiel:

import re

pattern = re.compile(r"(?P<name>\w+)?\s+(?P<age>\d+)?\s+(?P<species>\w+)?")
text = "John 4 Dog, Jane  Tiger"

print(pattern.findall(text))  # 输出: [('John', '4', 'Dog'), ('Jane', '', 'Tiger')]
print(pattern.findall(text, 2))  # 输出: [('hn', '4', 'Dog'), ('Jane', '', 'Tiger')]
print(pattern.findall(text, 2, 9))  # 输出: [('hn', '4', 'Do')]

re.purge()

Darüber hinaus bietet das re-Modul eine re.purge()Funktion zum Leeren des Caches von regulären Ausdrücken. Dieser Cache bezieht sich hauptsächlich auf kompilierte reguläre Ausdrucksobjekte ( re.Pattern), einschließlich re.compile()mit erstellter Objekte und Objekte, die beim Aufrufen von Funktionen in anderen Re-Modulen automatisch erstellt werden.