Sieben Anwendungsbeispiele für reguläre Python-Ausdrücke

Reguläre Ausdrücke gibt es als Konzept nicht nur in Python. Allerdings gibt es noch einige kleinere Unterschiede in der tatsächlichen Verwendung regulärer Ausdrücke in Python.

Dieser Artikel ist Teil einer Artikelserie über reguläre Python-Ausdrücke. In diesem ersten Artikel dieser Reihe konzentrieren wir uns auf die Verwendung regulärer Ausdrücke in Python und beleuchten einige der einzigartigen Funktionen von Python.

Wir stellen einige Methoden zum Suchen und Finden von Zeichenfolgen in Python vor. Anschließend besprechen wir, wie wir mithilfe der Gruppierung die Unterelemente der gefundenen übereinstimmenden Objekte verarbeiten.

Das Modul für reguläre Ausdrücke in Python, das wir verwenden möchten, heißt normalerweise „re“.

>>> import re

1. Primitive Zeichenfolgen in Python

Der Python-Compiler verwendet '' (Backslash), um Zeichenfolgen als Escape-Zeichen in Konstanten darzustellen .

Wenn auf den Backslash eine vom Compiler erkannte Folge von Sonderzeichen folgt, wird die gesamte Escape-Sequenz durch das entsprechende Sonderzeichen ersetzt (z. B. wird „n“ durch ein Zeilenumbruchzeichen ersetzt). Compiler).

Dies stellt jedoch ein Problem für die Verwendung regulärer Ausdrücke in Python dar, da Backslashes auch im Modul „re“ verwendet werden, um Sonderzeichen in regulären Ausdrücken (wie * und ) zu maskieren.

Eine Mischung aus beidem bedeutet, dass Sie manchmal das Escape-Zeichen selbst maskieren müssen (wenn das Sonderzeichen sowohl von Python als auch vom Compiler für reguläre Ausdrücke erkannt wird), aber manchmal ist dies nicht erforderlich (wenn das Sonderzeichen werden nur vom Python-Compiler erkannt.

Anstatt herauszufinden, wie viele Backslashes benötigt werden, können wir stattdessen rohe Zeichenfolgen verwenden.

Primitive Zeichenfolgen können einfach durch Hinzufügen eines „r“-Zeichens vor den doppelten Anführungszeichen einer gewöhnlichen Zeichenfolge erstellt werden. Wenn eine Zeichenfolge vom primitiven Typ ist, versucht der Python-Compiler keine Ersetzungen. Im Wesentlichen weisen Sie den Compiler an, Ihre Zeichenfolge überhaupt nicht zu beeinträchtigen.

>>> string = 'This is a\nnormal string'
>>> rawString = r'and this is a\nraw string'
>>> print string

Dies ist eine normale Zeichenfolge

>>> print rawString
and this is a\nraw string

Dies ist A Zeichenfolge vom primitiven Typ.

Reguläre Ausdrücke zur Suche in Python verwenden

Das Modul „re“ bietet mehrere Methoden, um exakte Abfragen für die Eingabezeichenfolge durchzuführen. Die Methoden, die wir besprechen werden, sind:

•re.match()
•re.search()
•re.findall()

Jede Methode erhält einen regulären Ausdruck und eine abzugleichende Zeichenfolge. Schauen wir uns jede dieser Methoden genauer an, um zu verstehen, wie sie funktionieren und worin sie sich unterscheiden.

2. Verwenden Sie re.match zum Suchen – der Abgleich beginnt

Werfen wir zunächst einen Blick auf die Methode match(). Die Methode match() funktioniert so, dass sie nur dann eine Übereinstimmung findet, wenn der Anfang der durchsuchten Zeichenfolge mit dem Muster übereinstimmt.

Wenn Sie beispielsweise die Methode mathch() für die Zeichenfolge „Hund, Katze, Hund“ aufrufen, wird das Suchmuster „Hund“ gefunden:

>>> re.match(r'dog', 'dog cat dog')
<_sre.SRE_Match object at 0xb743e720<
>>> match = re.match(r&#39;dog&#39;, &#39;dog cat dog&#39;)
>>> match.group(0)
&#39;dog&#39;

Wir werden die Methode group() später ausführlicher besprechen. Im Moment müssen wir nur wissen, dass wir es mit 0 als Argument aufgerufen haben und dass die Methode group() das gefundene passende Muster zurückgibt.

Ich habe das zurückgegebene SRE_Match-Objekt vorerst übersprungen, wir werden das bald besprechen.

Wenn wir jedoch die Methode math() für dieselbe Zeichenfolge aufrufen und nach dem Muster „Katze“ suchen, wird keine Übereinstimmung gefunden.

>>> re.match(r'cat', 'dog cat dog')
>>>

3 Verwenden Sie re.search, um eine beliebige Position zu finden.

Die Methode search() ähnelt match(). , aber die Methode search () beschränkt uns nicht darauf, nur am Anfang der Zeichenfolge nach Übereinstimmungen zu suchen. Wenn Sie also in unserer Beispielzeichenfolge nach „cat“ suchen, finden Sie eine Übereinstimmung:

search(r'cat', 'dog cat dog')
>>> match.group(0)
'cat'

Die search()-Methode stoppt jedoch, nachdem sie eine Übereinstimmung gefunden hat, sodass die Suche nach „dog“ mit der searc()-Methode in unserer Beispielzeichenfolge nur ihr erstes Vorkommen findet.

>>> match = re.search(r'dog', 'dog cat dog')
>>> match.group(0)
'dog'

4. Verwenden Sie re.findall – alle passenden Objekte

Die Suchmethode, die ich bisher in Python am häufigsten verwende, ist findall( ) Methode. Wenn wir die Methode findall() aufrufen, können wir einfach eine Liste aller übereinstimmenden Muster abrufen, anstatt das Übereinstimmungsobjekt abzurufen (wir werden das Übereinstimmungsobjekt als Nächstes ausführlicher besprechen). Für mich ist es einfacher. Wenn wir die findall()-Methode für die Beispielzeichenfolge aufrufen, erhalten wir:

['dog', 'dog']
>>> re.findall(r'cat', 'dog cat dog')
['cat']

5. Verwenden Sie die Methoden match.start und match.end

Was genau ist also das „Match“-Objekt, das zuvor von den Methoden „search()“ und „match()“ an uns zurückgegeben wurde?

Anders als bei der einfachen Rückgabe des übereinstimmenden Teils der Zeichenfolge: „search()“ und „match“. ( ) ist eigentlich eine Wrapper-Klasse zum Abgleichen von Teilzeichenfolgen

Zuvor haben Sie gesehen, dass ich die passende Teilzeichenfolge erhalten kann, indem ich die Methode group() aufrufe (wir werden dies im nächsten Abschnitt tun. Siehe, tatsächlich Objekte abgleichen sind sehr nützlich, wenn es um Gruppierungsprobleme geht), aber Match-Objekte enthalten auch weitere Informationen über die übereinstimmende Teilzeichenfolge

Das Match-Objekt kann uns beispielsweise mitteilen, welche Start- und Endpositionen in der Originalzeichenfolge übereinstimmen Zeichenfolge:

>>> match = re.search(r'dog', 'dog cat dog')
>>> match.start()
>>> match.end()

Die Kenntnis dieser Informationen ist manchmal sehr nützlich

Verwenden Sie mathch.group via

就像我之前提到的，匹配对象在处理分组时非常得心应手。

分组是对整个正则表达式的特定子串进行定位的能力。我们可以定义一个分组做为整个正则表达式的一部分，然后单独的对这部分对应匹配到的内容定位。

让我们来看一下它是怎么工作的：

>>> contactInfo = 'Doe, John: 555-1212'

我刚才创建的字符串类似一个从某人的地址本里取出来的一个片段。我们可以通过这样一个正则表达式来匹配这一行：

>>> re.search(r'\w+, \w+: \S+', contactInfo)
<_sre.SRE_Match object at 0xb74e1ad8<

通过用圆括号来（字符‘('和‘)'）包围正则表达式的特定部分，我们可以对内容进行分组然后对这些子组做单独处理。

>>> match = re.search(r'(\w+), (\w+): (\S+)', contactInfo)

这些分组可以通过用分组对象的group()方法得到。它们可以通过其在正则表达式中从左到右出现的数字顺序来定位（从1开始）：

>>> match.group(1)
'Doe'
>>> match.group(2)
'John'
>>> match.group(3)
'555-1212'

组的序数从1开始的原因是因为第0个组被预留来存放所有匹配对象（我们在之前学习match()方法和search()方法到时候看到过）。

>>> match.group(0)
'Doe, John: 555-1212'

7. 使用 match.group 通过别名来分组

有时候，特别是当一个正则表达式有很多分组的时候，通过组的出现次序来定位就会变的不现实。Python还允许你通过下面的语句来指定一个组名：

 >>> match = re.search(r&#39;(?P<last>\w+), (?P<first>\w+): (?P<phone>\S+)&#39;, contactInfo)

我们还是可以用group()方法获取分组的内容，但这时候我们要用我们所指定的组名而不是之前所使用的组的所在位数。

>>> match.group('last')
'Doe'
>>> match.group('first')
'John'
>>> match.group('phone')
'555-1212'

这大大加强了代码的明确性和可读性。你可以想像当正则表达式变得越来越复杂，去弄懂一个分组到捕获了什么内容将会变得越来越困难。给你的分组命名将明确的告诉了你和你的读者你的意图。

尽管findall()方法不返回分组对象，它也可以使用分组。类似的，findall()方法将返回一个元组的集合，其中每个元组中的第N个元素对应了正则表达式中的第N个分组。

>>> re.findall(r'(\w+), (\w+): (\S+)', contactInfo)
[('Doe', 'John', '555-1212')]

   

但是，给分组命名并不适用于findall()方法。

在本文中我们介绍了Python中使用正则表达式的一些基础。我们学习了原始字符串类型（还有它能帮你解决的在使用正则表达式中一些头痛的问题）。我们还学习了如何适使用match(), search(), and findall()方法进行基本的查询，以及如何使用分组来处理匹配对象的子组件。

和往常一样，如果想查看更多关于这个主题的内容，re模块的Python官方文档是一个非常好的资源。

在以后的文章中，我们将更深入的讨论Python中正则表达式的应用。我们将更加全面的学习匹配对象，学习如何使用它们在字符串中做替换，甚至使用它们从文本文件中去解析Python数据结构。