So verwenden Sie reguläre Ausdrücke in Python

Strings sind die am häufigsten verwendete Datenstruktur in der Programmierung, und die Notwendigkeit, Strings zu bearbeiten, besteht fast überall. Um beispielsweise festzustellen, ob es sich bei einer Zeichenfolge um eine legale E-Mail-Adresse handelt, können Sie zwar die Teilzeichenfolgen vor und nach @ programmgesteuert extrahieren und dann feststellen, ob es sich um ein Wort und einen Domänennamen handelt, dies ist jedoch nicht nur mühsam, sondern auch schwierig wiederzuverwenden der Code. Reguläre Ausdrücke sind eine leistungsstarke Waffe zum Abgleichen von Zeichenfolgen. Seine Entwurfsidee besteht darin, eine beschreibende Sprache zu verwenden, um eine Regel für eine Zeichenfolge zu definieren. Jede Zeichenfolge, die der Regel entspricht, gilt als „übereinstimmend“.

So beurteilen wir, ob eine Zeichenfolge eine zulässige E-Mail ist:

Erstellen Sie einen regulären Ausdruck, der mit der E-Mail übereinstimmt.

Verwenden Sie dies Regulärer Ausdruck, der mit der Eingabe des Benutzers übereinstimmt, um festzustellen, ob sie zulässig ist.

Da reguläre Ausdrücke auch durch Zeichenfolgen dargestellt werden, müssen wir zunächst verstehen, wie Zeichen zur Beschreibung von Zeichen verwendet werden.

Wenn in regulären Ausdrücken Zeichen direkt angegeben werden, handelt es sich um eine exakte Übereinstimmung. Verwenden Sie d, um eine Zahl abzugleichen, und w, um einen Buchstaben oder eine Zahl abzugleichen, sodass:

'00d' mit '007' übereinstimmen kann, aber nicht '00A'; '010';

'wwd' kann mit 'py3' übereinstimmen;

kann mit jedem Zeichen übereinstimmen, also:

'pyc'. pyo‘, ‚py!‘ usw.

Um Zeichen variabler Länge in regulären Ausdrücken abzugleichen, verwenden Sie * zur Darstellung einer beliebigen Anzahl von Zeichen (einschließlich 0), + zur Darstellung von mindestens einem Zeichen, ? zur Darstellung von 0 oder 1 Zeichen und {n} stellt n Zeichen dar und {n,m} stellt n-m Zeichen dar:

Schauen wir uns ein komplexes Beispiel an: d{3}s+d{3,8}.

Interpretieren wir es von links nach rechts:

d{3} bedeutet, dass 3 Zahlen übereinstimmen, z. B. „010“;

s kann mit einem Leerzeichen übereinstimmen (einschließlich Tab und andere Leerzeichen), also bedeutet s+, dass mindestens ein Leerzeichen vorhanden ist, z. B. passend zu „ ', ‚ ' usw.;

d{3,8} bedeutet 3-8 Zahlen, z. B. „1234567“. '.

Zusammengenommen kann der obige reguläre Ausdruck Telefonnummern mit Vorwahlen zuordnen, die durch beliebig viele Leerzeichen getrennt sind.

Was ist, wenn Sie eine Nummer wie „010-12345“ zuordnen möchten? Da „-“ ein Sonderzeichen ist, muss es in regulären Ausdrücken mit „“ maskiert werden. Daher ist der obige reguläre Ausdruck d{3}-d{3,8}.

Allerdings kann „010 – 12345“ aufgrund der Leerzeichen immer noch nicht gefunden werden. Wir brauchen also komplexere Matching-Methoden.

Verwandte Empfehlungen: „

Python-Video-Tutorial

“

Erweitert

Für eine genauere Übereinstimmung können Sie [ ] verwenden ein Bereich, zum Beispiel:

[0-9a-zA-Z_] kann mit einer Zahl, einem Buchstaben oder einem Unterstrich übereinstimmen;

[0-9a-zA-Z_]+ kann mindestens übereinstimmen Eine Zeichenfolge bestehend aus Zahlen, Buchstaben oder Unterstrichen, z. B. „a100“, „0_Z“, „Py3000“ usw.; OK Entspricht einer Zeichenfolge, die mit einem Buchstaben oder Unterstrich beginnt, gefolgt von einer beliebigen Anzahl von Zahlen, Buchstaben oder Unterstrichen. Dies ist eine zulässige Variable in Python - Z_]{0, 19} begrenzt die Länge der Variablen genauer auf 1–20 Zeichen (1 Zeichen vorne + bis zu 19 Zeichen hinten).

A|B kann mit A oder B übereinstimmen, also kann (P|p)ython mit „Python“ oder „Python“ übereinstimmen.

^ bedeutet den Anfang der Zeile, ^d bedeutet, dass sie mit einer Zahl beginnen muss.

$ gibt das Ende der Zeile an und d$ gibt an, dass sie mit einer Zahl enden muss.

Sie haben vielleicht bemerkt, dass py auch mit „python“ übereinstimmen kann, aber das Hinzufügen von ^py$ entspricht der gesamten Zeile und kann nur mit „py“ übereinstimmen.

Re-Modul

Mit den vorbereitenden Kenntnissen können wir reguläre Ausdrücke in Python verwenden. Python stellt das re-Modul bereit, das alle regulären Ausdrucksfunktionen enthält. Da Pythons String selbst ebenfalls Escape verwendet, sollte besonderes Augenmerk auf Folgendes gelegt werden:

s = 'ABC\-001' # Pythons String # Der entsprechende reguläre Ausdrucksstring wird zu: # 'ABC- 001'

Daher empfehlen wir dringend die Verwendung des r-Präfixes von Python, damit Sie sich keine Gedanken über Escapezeichen machen müssen:

s = r'ABC-001' # Python string# Die entsprechende Zeichenfolge des regulären Ausdrucks bleibt unverändert : # 'ABC-001'

Schauen wir uns zunächst an, wie man ermittelt, ob der reguläre Ausdruck übereinstimmt:

>>> import re
>>> re.match(r'^\d{3}\-\d{3,8}$', '010-12345')
<_sre.SRE_Match object; span=(0, 9), match=&#39;010-12345&#39;
>>>> re.match(r&#39;^\d{3}\-\d{3,8}$&#39;, &#39;010 12345&#39;)
>>>

match()-Methode bestimmt, ob er übereinstimmt, wenn die Übereinstimmung vorliegt Erfolgreich, gibt ein Match-Objekt zurück, andernfalls wird None zurückgegeben. Die übliche Beurteilungsmethode ist:

test = 'vom Benutzer eingegebene Zeichenfolge' if re.match(r'regular expression', test):

print('ok')else:
print('failed')

cut String-Aufteilung

Die Verwendung regulärer Ausdrücke zum Aufteilen von Zeichenfolgen ist flexibler als die Verwendung fester Zeichen. Bitte beachten Sie den normalen Aufteilungscode:

>>> 'a b   c'.split(' ')
['a', 'b', '', '', 'c']

Nun, fortlaufende Leerzeichen können nicht erkannt werden. Versuchen Sie es mit regulären Ausdrücken:

>>> re.split(r'\s+', 'a b   c')
['a', 'b', 'c']

Es kann normal geteilt werden, egal wie viele Plätze vorhanden sind. Beitreten, versuchen Sie:

>>> re.split(r'[\s\,]+', 'a,b, c  d')
['a', 'b', 'c', 'd']

Erneut beitreten; versuchen Sie:

>>> re.split(r'[\s\,\;]+', 'a,b;; c  d')
['a', 'b', 'c', 'd']

Wenn der Benutzer eine Reihe von Tags eingibt, denken Sie daran, beim nächsten Mal reguläre Ausdrücke zu verwenden, um unregelmäßige Eingaben in korrekte Arrays umzuwandeln.

Gruppe

除了简单地判断是否匹配之外，正则表达式还有提取子串的强大功能。用()表示的就是要提取的分组（Group）。比如：

^(\d{3})-(\d{3,8})$分别定义了两个组，可以直接从匹配的字符串中提取出区号和本地号码：

>>> m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345')
>>> m
<_sre.SRE_Match object; span=(0, 9), match=&#39;010-12345&#39;
>>>> m.group(0)&#39;010-12345&#39;
>>> m.group(1)&#39;010&#39;
>>> m.group(2)&#39;12345&#39;

如果正则表达式中定义了组，就可以在Match对象上用group()方法提取出子串来。

注意到group(0)永远是原始字符串，group(1)、group(2)……表示第1、2、……个子串。

提取子串非常有用。来看一个更凶残的例子：

>>> t = '19:05:30'
>>> m = re.match(r'^(0[0-9]|1[0-9]|2[0-3]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])$', t)>>> m.groups()
('19', '05', '30')

这个正则表达式可以直接识别合法的时间。但是有些时候，用正则表达式也无法做到完全验证，比如识别日期：

'^(0[1-9]|1[0-2]|[0-9])-(0[1-9]|1[0-9]|2[0-9]|3[0-1]|[0-9])$'

对于'2-30'，'4-31'这样的非法日期，用正则还是识别不了，或者说写出来非常困难，这时就需要程序配合识别了。

贪婪匹配

最后需要特别指出的是，正则匹配默认是贪婪匹配，也就是匹配尽可能多的字符。举例如下，匹配出数字后面的0：

>>> re.match(r'^(\d+)(0*)$', '102300').groups()
('102300', '')

由于\d+采用贪婪匹配，直接把后面的0全部匹配了，结果0*只能匹配空字符串了。

必须让\d+采用非贪婪匹配（也就是尽可能少匹配），才能把后面的0匹配出来，加个?就可以让\d+采用非贪婪匹配：

>>> re.match(r'^(\d+?)(0*)$', '102300').groups()
('1023', '00')

编译

当我们在Python中使用正则表达式时，re模块内部会干两件事情：

编译正则表达式，如果正则表达式的字符串本身不合法，会报错；

用编译后的正则表达式去匹配字符串。

如果一个正则表达式要重复使用几千次，出于效率的考虑，我们可以预编译该正则表达式，接下来重复使用时就不需要编译这个步骤了，直接匹配：

>>> import re
# 编译:
>>> re_telephone = re.compile(r'^(\d{3})-(\d{3,8})$')
# 使用：
>>> re_telephone.match('010-12345').groups()
('010', '12345')
>>> re_telephone.match('010-8086').groups()
('010', '8086')

编译后生成Regular Expression对象，由于该对象自己包含了正则表达式，所以调用对应的方法时不用给出正则字符串。

参数

修饰符

模式

Das obige ist der detaillierte Inhalt vonSo verwenden Sie reguläre Ausdrücke in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!