Detaillierte Einführung in den regulären Ausdruck des Python-Moduls

1. Kurze Einführung

Regulärer Ausdruck ist eine kleine, hochspezialisierte Programmiersprache, nicht Python Es ist eine grundlegende und wichtige Sprache Bestandteil vieler Programmiersprachen. In Python wird es hauptsächlich über das Re-Modul implementiert.

Muster regulärer Ausdrücke werden in einer Reihe von Bytecodes kompiliert und dann von einer in C geschriebenen Matching-Engine ausgeführt. Was sind also die häufigsten Verwendungsszenarien für reguläre Ausdrücke?

Geben Sie beispielsweise eine Regel für den entsprechenden String-Satz an, den Sie abgleichen möchten.

Der String-Satz kann E-Mail-Adressen, Internetadressen und Telefonnummern umfassen , oder Es handelt sich um einige an die Bedürfnisse angepasste Zeichenfolgensätze.

Natürlich können Sie auch beurteilen, ob ein Zeichenfolgensatz den von uns definierten Übereinstimmungsregeln entspricht.

Finden Sie den Teil der Zeichenfolge entspricht der Regel ;

Eine Reihe von Textverarbeitungen wie Modifizieren und Ausschneiden;

......

2. Spezielle Symbole und Zeichen (Metazeichen )

Hier sind einige gängige Metazeichen, die regulären Ausdrücken leistungsstarke Funktionalität und Flexibilität verleihen. Tabelle 2-1 listet die gebräuchlichsten Symbole und Zeichen auf.

3. Reguläre Ausdrücke

1. Verwenden Sie die Funktion „compile()“um reguläre Ausdrücke zu kompilieren

Aufgrund von Python-Code wird schließlich in Bytecode übersetzt und dann auf dem Interpreter ausgeführt. Daher ist es bequemer, einige reguläre Ausdrücke, die in unserem Code häufig verwendet werden, vorab zu kompilieren. Die meisten Funktionen im

re-Modul haben die gleichen Namen und haben die gleiche Funktionalität wie die Methoden des kompilierten

regulären Ausdrucksobjekts und der regulären Matching-Objekte.

Beispiel:

>>> import re
>>> r1 = r'bugs'                            # 字符串前加"r"反斜杠就不会被任何特殊方式处理，这是个习惯，虽然这里没用到
>>> re.findall(r1, 'bugsbunny')             # 直接利用re模块进行解释性地匹配
['bugs']                         
>>>
>>> r2 = re.compile(r1)                     # 如果r1这个匹配规则你会经常用到，为了提高效率，那就进行预编译吧
>>> r2                                      # 编译后的正则对象
<_sre.SRE_Pattern object at 0x7f5d7db99bb0>
>>>
>>> r2.findall(&#39;bugsbunny&#39;)                 # 访问对象的findall方法得到的匹配结果与上面是一致的
[&#39;bugs&#39;]                                    # 所以说，re模块中的大多数函数和已经编译的正则表达式对象和正则匹配对象的方法同名并且具有相同的功能

Die Funktion re.compile() akzeptiert auch optionale Flag-Parameter, die häufig zum Implementieren verschiedener Sonderfunktionen und Syntaxänderungen verwendet werden. Diese Flags sind auch als Argumente für die meisten re-Modulfunktionen verfügbar. Diese Flags können mit dem

-Operator (|) kombiniert werden.

Beispiel:

>>> import re
>>> r1 = r'bugs'
>>> r2 = re.compile(r1,re.I)  # 这里选择的是忽略大小写的标志，完整的是re.IGNORECASE，这里简写re.I
>>> r2.findall('BugsBunny')
['Bugs']
 
# re.S 使.匹配换行符在内的所有字符
# re.M 多行匹配，英雄^和$
# re,X 用来使正则匹配模式组织得更加清晰

Eine vollständige Liste der Flaggenparameter und deren Verwendung finden Sie in den entsprechenden offiziellen Dokumenten.

2. Verwendung regulärer Ausdrücke

re-Modul stellt eine

Schnittstelle für eine reguläre Ausdrucks-Engine bereit. Hier sind einige häufig verwendete Funktionen und Methoden.

Match-Objekt und die Methoden group() und groups()

Beim Umgang mit regulären Ausdrücken gibt es zusätzlich zum regulären Ausdrucksobjekt einen weiteren Objekttyp: das Match-Objekt. Dies sind die Objekte, die von einem erfolgreichen Aufruf von match() oder search() zurückgegeben werden. Match-Objekte haben zwei Hauptmethoden: group() und groups().

group() gibt auf Anfrage entweder das gesamte Match-Objekt oder eine bestimmte Untergruppe zurück. groups() gibt einfach ein Tupel zurück, das nur oder alle Untergruppen enthält. Wenn keine Untergruppierung erforderlich ist, gibt groups ein leeres Tupel zurück, während group() weiterhin die gesamte Übereinstimmung zurückgibt. Einige Funktionsbeispiele unten demonstrieren diese Methode.

Verwenden Sie die Methode match(), um eine Zeichenfolge abzugleichen.

Die Funktion match() gleicht das Muster vom Anfang der Zeichenfolge ab. Wenn die Übereinstimmung erfolgreich ist, wird ein Übereinstimmungsobjekt zurückgegeben. Wenn die Übereinstimmung fehlschlägt, wird „Keine“ zurückgegeben, und die Methode „group()“ des Übereinstimmungsobjekts kann verwendet werden, um die erfolgreiche Übereinstimmung anzuzeigen.

Ein Beispiel ist wie folgt:

>>> m = re.match('bugs', 'bugsbunny')     # 模式匹配字符串
>>> if m is not None:                     # 如果匹配成功，就输出匹配内容
...     m.group()
...
'bugs'
>>> m
<_sre.SRE_Match object at 0x7f5d7da1f168> # 确认返回的匹配对象

Verwenden Sie search(), um ein Muster in einer Zeichenfolge zu finden

search()的工作方式与match()完全一致，不同之处在于search()是对给定正则表达式模式搜索第一次出现的匹配情况。简单来说，就是在任意位置符合都能匹配成功，不仅仅是字符串的起始部分，这就是与match()函数的区别，用脚指头想想search()方法使用的范围更多更广。

示例：

>>> m = re.search('bugs', 'hello bugsbunny')
>>> if m is not None:
...     m.group()
...
'bugs'

使用findall()和finditer()查找每一次出现的位置

findall()是用来查找字符串中所有（非重复）出现的正则表达式模式，并返回一个匹配列表；finditer()与findall()不同的地方是返回一个迭代器，对于每一次匹配，迭代器都返回一个匹配对象。

>>> m = re.findall('bugs', 'bugsbunnybugs')
>>> m
['bugs', 'bugs']
>>> m = re.finditer('bugs', 'bugsbunnybugs')
>>> m.next()                                   # 迭代器用next()方法返回一个匹配对象
<_sre.SRE_Match object at 0x7f5d7da71a58>      # 匹配用group()方法显示出来
>>> m.next().group()
&#39;bugs&#39;

使用sub()和subn()搜索与替换

都是将某字符串中所有匹配正则表达式的部分进行某种形式的替换。sub()返回一个用来替换的字符串，可以定义替换次数，默认替换所有出现的位置。subn()和sub()一样，但subn()还返回一个表示替换的总是，替换后的字符串和表示替换总数一起作为一个拥有两个元素的元组返回。

示例：

>>> r = 'a.b'
>>> m = 'acb abc aab aac'
>>> re.sub(r,'hello',m)
'hello abc hello aac'
>>> re.subn(r,'hello',m)
('hello abc hello aac', 2)

字符串也有一个replace()方法，当遇到一些模糊搜索替换的时候，就需要更为灵活的sub()方法了。

使用split()分割字符串

同样的，字符串中也有split()，但它也不能处理正则表达式匹配的分割。在re模块中，分居正则表达式的模式分隔符，split函数将字符串分割为列表，然后返回成功匹配的列表。

示例：

>>> s = '1+2-3*4'
>>> re.split(r'[\+\-\*]',s)
['1', '2', '3', '4']

分组

有时在匹配的时候我们只想提取一些想要的信息或者对提取的信息作一个分类，这时就需要对正则匹配模式进行分组，只需要加上()即可。

示例：

>>> m = re.match('(\w{3})-(\d{3})','abc-123')
>>> m.group()       # 完整匹配                        
'abc-123'
>>> m.group(1)      # 子组1
'abc'
>>> m.group(2)      # 子组2
'123'
>>> m.groups()      # 全部子组
('abc', '123')

由以上的例子可以看出，group()通常用于以普通方式显示所有的匹配部分，但也能用于获取各个匹配的子组。可以使用groups()方法来获取一个包含所有匹配字符串的元组。

Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in den regulären Ausdruck des Python-Moduls. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!