So verwenden Sie Metazeichen des re-Moduls in Python

Meta-Zeichen sind Sonderzeichen mit besonderer Bedeutung in regulären Ausdrücken und stellen in Python keine Ausnahme dar. Sie werden verwendet, um das Erscheinungsmuster führender Zeichen (Zeichen vor Meta-Zeichen) im Zielobjekt anzuzeigen.

In regulären Ausdrücken bildet ein in eckigen Klammern ([]) angegebener Zeichensatz eine Zeichenklasse.

# 元字符序列匹配类中的任何单个字符
>>> s = 'foo123bar'

# 3个任意连续字符匹配
>>> re.search('[0-9][0-9][0-9]', s)
<_sre.SRE_Match object; span=(3, 6), match=&#39;123&#39;>

>>> re.search(&#39;[0-9][0-9][0-9]&#39;, &#39;foo456bar&#39;)
<_sre.SRE_Match object; span=(3, 6), match=&#39;456&#39;>

>>> re.search(&#39;[0-9][0-9][0-9]&#39;, &#39;234baz&#39;)
<_sre.SRE_Match object; span=(0, 3), match=&#39;234&#39;>

>>> re.search(&#39;[0-9][0-9][0-9]&#39;, &#39;qux678&#39;)
<_sre.SRE_Match object; span=(3, 6), match=&#39;678&#39;>

# 匹配不上的情况
>>> print(re.search(&#39;[0-9][0-9][0-9]&#39;, &#39;12foo34&#39;))
None

Das Platzhalter-Punkt-Metazeichen ( . ) entspricht jedem Zeichen außer einem Zeilenumbruchzeichen.

>>> s = 'foo123bar'
>>> re.search('1.3', s)
<_sre.SRE_Match object; span=(3, 6), match=&#39;123&#39;>

>>> s = &#39;foo13bar&#39;
>>> print(re.search(&#39;1.3&#39;, s))
None

re-Modul unterstützt Metazeichen

Die folgende Liste ist eine Beschreibung der Metazeichen. Die Metazeichen werden klassifiziert und beschrieben, um das Gedächtnis zu erleichtern. Wenn Sie das nicht verstehen, springen Sie einfach zu den Beispielen unten.

[xyz] passt zu jedem darin enthaltenen Zeichen ‘a’ . Der Satz negativer Zeichen ist nicht enthalten. Beispielsweise kann „[^abc]“ mit „p“, „i“ und „n“ übereinstimmen. 🎜🎜#Zeichenbereich von „a“ bis „z“ kann verwendet werden Entspricht jedem Zeichen, das nicht im angegebenen Bereich liegt. Beispielsweise ‘[^a-z]’ Entspricht jedem Zeichen, das nicht im Bereich „a“ bis „z“ liegt. Entspricht einer Wortgrenze, die sich auf die Position zwischen einem Wort und einem Leerzeichen bezieht. ähm in „nie“, aber nicht das „äh“ in „verb“ # ;erB’ kann mit „er“ in „verb“ übereinstimmen, aber nicht mit „never“. # entspricht dem durch x angegebenen Steuerzeichen. Der Wert von x muss beispielsweise A-Z oder a-z sein # entspricht einem numerischen Zeichen, äquivalent zu [0-9]. Entspricht einem nicht numerischen Zeichen. Entspricht [^0-9]. entspricht einem Formularvorschub. Entspricht x0c und cL. entspricht einem Zeilenumbruchzeichen. Entspricht x0a und cJ. entspricht einem Wagenrücklaufzeichen. Entspricht x0d und cM. Entspricht jedem Leerzeichen, einschließlich Leerzeichen, Tabulatoren, Formularvorschüben usw. Entspricht [fnrtv]. entspricht jedem Zeichen, das kein Leerzeichen ist. Entspricht [^ fnrtv]. entspricht einem Tabulatorzeichen. Entspricht x09 und cI. Entspricht einem vertikalen Tabulatorzeichen. Entspricht x0b und cK. Ordnen Sie Buchstaben, Zahlen und Unterstriche zu. Entspricht „[A-Za-z0-9_]“. Entspricht Nicht-Buchstaben, Zahlen und Unterstrichen. Entspricht „[^A-Za-z0-9_]“. entspricht n, wobei n ein hexadezimaler Escape-Wert ist. Der hexadezimale Escape-Wert muss genau zwei Ziffern lang sein. Beispielsweise entspricht „x41“ „A“. „x041“ entspricht „x04“ und „1“.正则表达式中可以使用 ASCII 编码。

Zeichen	Beschreibung
	Markieren Sie das nächste Zeichen als Sonderzeichen, Literalzeichen, Rückverweis oder oktales Escapezeichen. Beispielsweise entspricht „n“ dem Zeichen „n“. „n“ entspricht einem Zeilenumbruchzeichen. Die Sequenz ‘’ entspricht „“ und „(“ entspricht „(“.
^	entspricht dem Anfang der Eingabezeichenfolge. Wenn die Multiline-Eigenschaft des RegExp-Objekts festgelegt ist, stimmt ^ auch mit „n“ überein ; oder Die Position nach „r“ stimmt mit dem Ende der Eingabezeichenfolge überein. $ stimmt auch mit der Position vor „n“ überein Der vorherige Unterausdruck kann beispielsweise null oder mehrmals übereinstimmen, und „zoo“ entspricht {0,}. Beispielsweise passt „zo+“ zu „zo“ und „zoo“, aber nicht zu „z“.+ entspricht {1,}.
?	Entspricht null oder einmal dem vorhergehenden Unterausdruck. Beispielsweise würde „do(es)?“ mit „do“ oder „does“ übereinstimmen. ? Entspricht {0,1}.
{n}	n ist eine nicht negative ganze Zahl. Passen Sie eine bestimmte Anzahl n-mal an. Beispielsweise stimmt „o{2}“ nicht mit dem „o“ in „Bob“ überein, wohl aber mit beiden „o“ in „food“.
{n,}	n ist eine nicht negative ganze Zahl. Passt mindestens n-mal zusammen. Beispielsweise stimmt „o{2,}“ nicht mit dem „o“ in „Bob“ überein, stimmt aber mit allen „o“ in „foooood“ überein. „o{1,}“ entspricht „o+“. „o{0,}“ entspricht „o*“.
{n,m}	Sowohl m als auch n sind nicht negative ganze Zahlen, wobei n
?	Wenn diesem Zeichen ein anderer Begrenzer folgt (*, +, ?, {n}, {n, }, {n,m}), das passende Muster ist nicht gierig. Der Non-Greedy-Modus stimmt so wenig wie möglich mit der gesuchten Zeichenfolge überein, während der Standard-Greedy-Modus so viel wie möglich mit der gesuchten Zeichenfolge übereinstimmt. Beispielsweise entspricht bei der Zeichenfolge „oooo“ „o+?“ einem einzelnen „o“, während „o+“ allen „o“ entspricht.
.	Entspricht jedem einzelnen Zeichen außer Zeilenumbrüchen (n, r). Um ein beliebiges Zeichen einschließlich „n“ zu finden, verwenden Sie etwas wie „(.
x|y	, um x oder y zu finden. Für Beispiel: 'z
	[a-z]
	[^a-z]
	D
	f
	n
	r
	s
	S
	t
	v
	w
	W
	xn
\num	匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，‘(.)\1’ 匹配两个连续的相同字符。
\n	标识一个八进制转义值或一个向后引用。如果 \n 之前至少 n 个获取的子表达式，则 n 为向后引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。
\nm	标识一个八进制转义值或一个向后引用。如果 \nm 之前至少有 nm 个获得子表达式，则 nm 为向后引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的向后引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。
\nml	如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。
\un	匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如， \u00A9 匹配版权符号 (?)。

类别1：匹配单个字符的元字符

方括号( [] ) 字符集

指定要匹配的特定字符集。 字符类元字符序列将匹配该类中包含的任何单个字符。

# 元字符序列[artz]匹配任何单个'a'、'r'、't'或'z'字符
# ba[artz]同时匹配'bar'and 'baz'（也将匹配'baa'and 'bat'）。
>>> re.search('ba[artz]', 'foobarqux')
<_sre.SRE_Match object; span=(3, 6), match=&#39;bar&#39;>
>>> re.search(&#39;ba[artz]&#39;, &#39;foobazqux&#39;)
<_sre.SRE_Match object; span=(3, 6), match=&#39;baz&#39;>

匹配和[a-z]之间的任何小写字母字符。

>>> re.search('[a-z]', 'FOObar')
<_sre.SRE_Match object; span=(3, 4), match=&#39;b&#39;>

匹配和[0-9]之间任何数字字符。

>>> re.search('[0-9][0-9]', 'foo123bar')
<_sre.SRE_Match object; span=(3, 5), match=&#39;12&#39;>

[0-9a-fA-F]匹配任何十六进制数字字符。

>>> re.search('[0-9a-fA-f]', '--- a0 ---')
<_sre.SRE_Match object; span=(4, 5), match=&#39;a&#39;>

[^0-9]匹配任何不是数字的字符开头的字符。

>>> re.search('[^0-9]', '12345foo')
<_sre.SRE_Match object; span=(5, 6), match=&#39;f&#39;>

如果一个^字符出现在字符类中但不是第一个字符则无结果。

>>> re.search('[#:^]', 'foo^bar:baz#qux')
<_sre.SRE_Match object; span=(3, 4), match=&#39;^&#39;>

可以通过用连字符分隔字符来指定字符类中的字符范围，可以将其作为第一个或最后一个字符放置，或者使用反斜杠 ( \ ) 对其进行转义。

# 直接查找符号
>>> re.search('[-abc]', '123-456')
<_sre.SRE_Match object; span=(3, 4), match=&#39;-&#39;>
>>> re.search(&#39;[abc-]&#39;, &#39;123-456&#39;)
<_sre.SRE_Match object; span=(3, 4), match=&#39;-&#39;>
>>> re.search(&#39;[ab\-c]&#39;, &#39;123-456&#39;)
<_sre.SRE_Match object; span=(3, 4), match=&#39;-&#39;>


# 查找转义符号
>>> re.search(&#39;[]]&#39;, &#39;foo[1]&#39;)
<_sre.SRE_Match object; span=(5, 6), match=&#39;]&#39;>
>>> re.search(&#39;[ab\]cd]&#39;, &#39;foo[1]&#39;)
<_sre.SRE_Match object; span=(5, 6), match=&#39;]&#39;>


# [ ] 内的元字符失去意义转义成字符处理
>>> re.search(&#39;[)*+|]&#39;, &#39;123*456&#39;)
<_sre.SRE_Match object; span=(3, 4), match=&#39;*&#39;>
>>> re.search(&#39;[)*+|]&#39;, &#39;123+456&#39;)
<_sre.SRE_Match object; span=(3, 4), match=&#39;+&#39;>

点 ( . ) 通配符

匹配除换行符以外的任何单个字符。

>>> re.search('foo.bar', 'fooxbar')
<_sre.SRE_Match object; span=(0, 7), match=&#39;fooxbar&#39;>
>>> print(re.search(&#39;foo.bar&#39;, &#39;foobar&#39;))
None
>>> print(re.search(&#39;foo.bar&#39;, &#39;foo\nbar&#39;))
None
>>> print(re.search(&#39;foo.bar&#39;, &#39;foosbar&#39;))
<_sre.SRE_Match object; span=(0, 7), match=&#39;foosbar&#39;>

\w 和 \W 单词字符匹配

\w匹配任何字母数字字符，单词字符是大写和小写字母、数字和下划线 ( _) 字符。

\w 等于 [a-zA-Z0-9_] 。

>>> re.search('\w', '#(.a$@&')
<_sre.SRE_Match object; span=(3, 4), match=&#39;a&#39;>
>>> re.search(&#39;[a-zA-Z0-9_]&#39;, &#39;#(.a$@&&#39;)
<_sre.SRE_Match object; span=(3, 4), match=&#39;a&#39;>

\W是相反的。它匹配任何非单词字符。

\W 等于 [^a-zA-Z0-9_] 。

>>> re.search('\W', 'a_1*3Qb')
<_sre.SRE_Match object; span=(3, 4), match=&#39;*&#39;>
>>> re.search(&#39;[^a-zA-Z0-9_]&#39;, &#39;a_1*3Qb&#39;)
<_sre.SRE_Match object; span=(3, 4), match=&#39;*&#39;>

\d 和 \D 字符十进制数字匹配

\d匹配任何十进制数字字符，等价于[0-9]。

>>> re.search('\d', 'abc4def')
<_sre.SRE_Match object; span=(3, 4), match=&#39;4&#39;>

\D匹配任何不是十进制数字的字符，等价于[^0-9]。

>>> re.search('\D', '234Q678')
<_sre.SRE_Match object; span=(3, 4), match=&#39;Q&#39;>

\s 和 \S 字符空格匹配

\s匹配任何空白字符，同时也匹配换行符。

>>> re.search('\s', 'foo\nbar baz')
<_sre.SRE_Match object; span=(3, 4), match=&#39;\n&#39;>

\S匹配任何不是空格的字符。

>>> re.search('\S', '  \n foo  \n  ')
<_sre.SRE_Match object; span=(4, 5), match=&#39;f&#39;>

混合使用 \w, \W, \d, \D, \s, 和\S

字符类序列\w, \W, \d, \D, \s, 和\S也可以出现在方括号字符类中。

# [\d\w\s]匹配任何数字、单词或空白字符

>>> re.search('[\d\w\s]', '---3---')
<_sre.SRE_Match object; span=(3, 4), match=&#39;3&#39;>
>>> re.search(&#39;[\d\w\s]&#39;, &#39;---a---&#39;)
<_sre.SRE_Match object; span=(3, 4), match=&#39;a&#39;>
>>> re.search(&#39;[\d\w\s]&#39;, &#39;--- ---&#39;)
<_sre.SRE_Match object; span=(3, 4), match=&#39; &#39;>

# 由于\w包含\d，相同的字符类也可以表示为略短[\w\s]
>>> re.search(&#39;[\w\s]&#39;, &#39;---a---&#39;)
<_sre.SRE_Match object; span=(3, 4), match=&#39;a&#39;>
>>> re.search(&#39;[\w\s]&#39;, &#39;---a---&#39;)
<_sre.SRE_Match object; span=(3, 4), match=&#39;a&#39;>
>>> re.search(&#39;[\w\s]&#39;, &#39;--- ---&#39;)
<_sre.SRE_Match object; span=(3, 4), match=&#39; &#39;>

类别2：转义元字符

反斜杠 ( \ ) 转义元字符

反斜杠会删除元字符的特殊含义。

>>> re.search('.', 'foo.bar')
<_sre.SRE_Match object; span=(0, 1), match=&#39;f&#39;>

>>> re.search(&#39;\.&#39;, &#39;foo.bar&#39;) # 非通配符
<_sre.SRE_Match object; span=(3, 4), match=&#39;.&#39;>

>>> re.search(r&#39;\\&#39;, &#39;foo\bar&#39;)
<_sre.SRE_Match object; span=(3, 4), match=&#39;\\&#39;>

类别3：锚点

不匹配搜索字符串中的任何实际字符，并且在解析期间它们不使用任何搜索字符串。指示搜索字符串中必须发生匹配的特定位置。

^ 和 \A 字符串的开头匹配项

>>> re.search('^foo', 'foobar')
<_sre.SRE_Match object; span=(0, 3), match=&#39;foo&#39;>
>>> print(re.search(&#39;^foo&#39;, &#39;barfoo&#39;))
None

>>> re.search(&#39;\Afoo&#39;, &#39;foobar&#39;)
<_sre.SRE_Match object; span=(0, 3), match=&#39;foo&#39;>
>>> print(re.search(&#39;\Afoo&#39;, &#39;barfoo&#39;))
None

$ 和\Z 字符串的结尾匹配项

>>> re.search('bar$', 'foobar')
<_sre.SRE_Match object; span=(3, 6), match=&#39;bar&#39;>
>>> print(re.search(&#39;bar$&#39;, &#39;barfoo&#39;))
None

>>> re.search(&#39;bar\Z&#39;, &#39;foobar&#39;)
<_sre.SRE_Match object; span=(3, 6), match=&#39;bar&#39;>
>>> print(re.search(&#39;bar\Z&#39;, &#39;barfoo&#39;))
None

# 特殊$也在搜索字符串末尾的单个换行符之前匹配
>>> re.search(&#39;bar$&#39;, &#39;foobar\n&#39;)
<_sre.SRE_Match object; span=(3, 6), match=&#39;bar&#39;>

\b 和 \B 单词匹配

\b 必须在单词的开头或结尾。

# 单词开头
>>> re.search(r'\bbar', 'foo bar')
<_sre.SRE_Match object; span=(4, 7), match=&#39;bar&#39;>
>>> re.search(r&#39;\bbar&#39;, &#39;foo.bar&#39;)
<_sre.SRE_Match object; span=(4, 7), match=&#39;bar&#39;>
>>> print(re.search(r&#39;\bbar&#39;, &#39;foobar&#39;))
None

# 单词结尾
>>> re.search(r&#39;foo\b&#39;, &#39;foo bar&#39;)
<_sre.SRE_Match object; span=(0, 3), match=&#39;foo&#39;>
>>> re.search(r&#39;foo\b&#39;, &#39;foo.bar&#39;)
<_sre.SRE_Match object; span=(0, 3), match=&#39;foo&#39;>
>>> print(re.search(r&#39;foo\b&#39;, &#39;foobar&#39;))
None


# 单词居中
>>> re.search(r&#39;\bbar\b&#39;, &#39;foo bar baz&#39;)
<_sre.SRE_Match object; span=(4, 7), match=&#39;bar&#39;>
>>> re.search(r&#39;\bbar\b&#39;, &#39;foo(bar)baz&#39;)
<_sre.SRE_Match object; span=(4, 7), match=&#39;bar&#39;>
>>> print(re.search(r&#39;\bbar\b&#39;, &#39;foobarbaz&#39;))
None

\B 不能在单词的开头或结尾。

>>> print(re.search(r'\Bfoo\B', 'foo'))
None
>>> print(re.search(r'\Bfoo\B', '.foo.'))
None
>>> re.search(r'\Bfoo\B', 'barfoobaz')
<_sre.SRE_Match object; span=(3, 6), match=&#39;foo&#39;>

类别4：量词

该部分必须出现多少次才能使匹配成功。

* 匹配前面的子表达式零次或多次

>>> re.search('foo-*bar', 'foobar')                 
<_sre.SRE_Match object; span=(0, 6), match=&#39;foobar&#39;>
>>> re.search(&#39;foo-*bar&#39;, &#39;foo-bar&#39;)                   
<_sre.SRE_Match object; span=(0, 7), match=&#39;foo-bar&#39;>
>>> re.search(&#39;foo-*bar&#39;, &#39;foo--bar&#39;)                
<_sre.SRE_Match object; span=(0, 8), match=&#39;foo--bar&#39;>

匹配2个字符中全部的内容。

>>> re.search('foo.*bar', '# foo jklasajk#*(@ bar #')
<_sre.SRE_Match object; span=(2, 22), match=&#39;foo jklasajk#*(@ bar&#39;>

+ 匹配前面的子表达式一次或多次

>>> print(re.search('foo-+bar', 'foobar'))              
None
>>> re.search('foo-+bar', 'foo-bar')                   
<_sre.SRE_Match object; span=(0, 7), match=&#39;foo-bar&#39;>
>>> re.search(&#39;foo-+bar&#39;, &#39;foo--bar&#39;)                  
<_sre.SRE_Match object; span=(0, 8), match=&#39;foo--bar&#39;>

? 匹配前面的子表达式零次或一次

>>> re.search('foo-?bar', 'foobar')                    
<_sre.SRE_Match object; span=(0, 6), match=&#39;foobar&#39;>
>>> re.search(&#39;foo-?bar&#39;, &#39;foo-bar&#39;)                   
<_sre.SRE_Match object; span=(0, 7), match=&#39;foo-bar&#39;>
>>> print(re.search(&#39;foo-?bar&#39;, &#39;foo--bar&#39;))           
None

.*?、+?、?? 最小长度匹配

加问号则表示为最小长度匹配的懒惰模式。

### + 和 +? 代替了 * 和 *?

# .*全匹配贪婪模式
>>> re.search(&#39;<.*>&#39;, &#39;%<foo> <bar> <baz>%&#39;)
<_sre.SRE_Match object; span=(1, 18), match=&#39;<foo> <bar> <baz>&#39;>
# *? 前一个字符0次或无限次扩展，最小匹配
>>> re.search(&#39;<.*?>&#39;, &#39;%<foo> <bar> <baz>%&#39;)
<_sre.SRE_Match object; span=(1, 6), match=&#39;<foo>&#39;>
# .+ 前一个字符1次或无限次扩展，最小匹配
>>> re.search(&#39;<.+>&#39;, &#39;%<foo> <bar> <baz>%&#39;)
<_sre.SRE_Match object; span=(1, 18), match=&#39;<foo> <bar> <baz>&#39;>
# .+? 前一个字符1次或无限次扩展，最小匹配
>>> re.search(&#39;<.+?>&#39;, &#39;%<foo> <bar> <baz>%&#39;)
<_sre.SRE_Match object; span=(1, 6), match=&#39;<foo>&#39;>

# ? 匹配懒惰模式
>>> re.search(&#39;ba?&#39;, &#39;baaaa&#39;)
<_sre.SRE_Match object; span=(0, 2), match=&#39;ba&#39;>
# ?? 前一个字符0次或1次扩展，最小匹配
>>> re.search(&#39;ba??&#39;, &#39;baaaa&#39;)
<_sre.SRE_Match object; span=(0, 1), match=&#39;b&#39;>

{m} 完全匹配m次前面元字符的正则表达式。

>>> print(re.search('x-{3}x', 'x--x'))                
None
>>> re.search('x-{3}x', 'x---x')                     
<_sre.SRE_Match object; span=(0, 5), match=&#39;x---x&#39;>
>>> print(re.search(&#39;x-{3}x&#39;, &#39;x----x&#39;))             
None

{m,n} 匹配前面正则表达式的任意数量的重复从m到n次

>>> for i in range(1, 6):
...     s = f"x{'-' * i}x"
...     print(f'{i}  {s:10}', re.search('x-{2,4}x', s))
...
1  x-x        None
2  x--x       <_sre.SRE_Match object; span=(0, 4), match=&#39;x--x&#39;>
3  x---x      <_sre.SRE_Match object; span=(0, 5), match=&#39;x---x&#39;>
4  x----x     <_sre.SRE_Match object; span=(0, 6), match=&#39;x----x&#39;>
5  x-----x    None

正则表达式	匹配说明	相同语法
{,n}	任何小于或等于的重复次数n	{0,n}
{m,}	任何大于或等于的重复次数m	----
{,}	任意次数的重复	{0,} ， *

>>> re.search('x{}y', 'x{}y')
<_sre.SRE_Match object; span=(0, 4), match=&#39;x{}y&#39;>
>>> re.search(&#39;x{foo}y&#39;, &#39;x{foo}y&#39;)
<_sre.SRE_Match object; span=(0, 7), match=&#39;x{foo}y&#39;>
>>> re.search(&#39;x{a:b}y&#39;, &#39;x{a:b}y&#39;)
<_sre.SRE_Match object; span=(0, 7), match=&#39;x{a:b}y&#39;>
>>> re.search(&#39;x{1,3,5}y&#39;, &#39;x{1,3,5}y&#39;)
<_sre.SRE_Match object; span=(0, 9), match=&#39;x{1,3,5}y&#39;>
>>> re.search(&#39;x{foo,bar}y&#39;, &#39;x{foo,bar}y&#39;)
<_sre.SRE_Match object; span=(0, 11), match=&#39;x{foo,bar}y&#39;>

{m,n}? 只匹配一次

非贪婪（懒惰）版本 {m,n}。

>>> re.search('a{3,5}', 'aaaaaaaa')
<_sre.SRE_Match object; span=(0, 5), match=&#39;aaaaa&#39;>
>>> re.search(&#39;a{3,5}?&#39;, &#39;aaaaaaaa&#39;)
<_sre.SRE_Match object; span=(0, 3), match=&#39;aaa&#39;>

类别5：分组构造和反向引用

分组构造将 Python 中的正则表达式分解为子表达式或组。

• 分组：一个组代表一个单一的句法实体。附加元字符作为一个单元应用于整个组。

• 捕获：一些分组结构还捕获与组中的子表达式匹配的搜索字符串部分。可以通过几种不同的机制检索捕获的匹配项。

()，定义子表达式或组。

# 括号中的正则表达式仅匹配括号的内容
>>> re.search('(bar)', 'foo bar baz')
<_sre.SRE_Match object; span=(4, 7), match=&#39;bar&#39;>
>>> re.search(&#39;bar&#39;, &#39;foo bar baz&#39;)
<_sre.SRE_Match object; span=(4, 7), match=&#39;bar&#39;>

将组视为一个单元

组后面的量词元字符对组中指定的整个子表达式作为一个单元进行操作。

# 元字符+仅适用于字符'r'，'ba'随后出现一次或多次'r'。
>>> re.search('bar+', 'foo bar baz')
<_sre.SRE_Match object; span=(4, 7), match=&#39;bar&#39;>
>>> re.search(&#39;(bar)+&#39;, &#39;foo bar baz&#39;)
<_sre.SRE_Match object; span=(4, 7), match=&#39;bar&#39;>
>>> re.search(&#39;(bar)+&#39;, &#39;foo barbar baz&#39;)
<_sre.SRE_Match object; span=(4, 10), match=&#39;barbar&#39;>
>>> re.search(&#39;(bar)+&#39;, &#39;foo barbarbarbar baz&#39;)
<_sre.SRE_Match object; span=(4, 16), match=&#39;barbarbarbar&#39;>

正则表达式	解释	匹配说明	例子
bar+	元字符+仅适用于字符’r’。	‘ba’随后出现一次或多次’r’	bar、barr、barrr等
(bar)+	元字符+适用于整个字符串’bar’。	出现一次或多次’bar’	bar、barbar、barbarbar

捕获组，m.groups()

返回一个元组，其中包含从正则表达式匹配中捕获的所有组。

>>> m = re.search('(\w+),(\w+),(\w+)', 'foo,quux,baz')
>>> m
<_sre.SRE_Match object; span=(0, 12), match=&#39;foo:quux:baz&#39;>
>>> m.groups()
(&#39;foo&#39;, &#39;quux&#39;, &#39;baz&#39;)

捕获组，m.group()

返回包含捕获的匹配项的字符串。

>>> m = re.search('(\w+),(\w+),(\w+)', 'foo,quux,baz')
>>> m.groups()
('foo', 'quux', 'baz')
>>> m.group(0)
('foo', 'quux', 'baz')
>>> m.group(1)
'foo'
>>> m.group(2)
'quux'
>>> m.group(3)
'baz'

捕获组，m.group(, , …)

返回一个包含指定捕获匹配序号的元组。

>>> m = re.search('(\w+),(\w+),(\w+)', 'foo,quux,baz')
>>> m.groups()
('foo', 'quux', 'baz')
>>> m.group(2, 3)
('quux', 'baz')
>>> m.group(3, 2, 1)
('baz', 'quux', 'foo')

类别6：反向引用

\ 匹配连续相同字符

>>> regex = r'(\w+),\1'

>>> m = re.search(regex, 'foo,foo')
>>> m
<_sre.SRE_Match object; span=(0, 7), match=&#39;foo,foo&#39;>
>>> m.group(1)
&#39;foo&#39;

>>> m = re.search(regex, &#39;qux,qux&#39;)
>>> m
<_sre.SRE_Match object; span=(0, 7), match=&#39;qux,qux&#39;>
>>> m.group(1)
&#39;qux&#39;

>>> m = re.search(regex, &#39;foo,qux&#39;)
>>> print(m)
None

类别7：其他分组结构

(?P) 创建捕获组并命名

>>> m = re.search(&#39;(?P<w1>\w+),(?P<w2>\w+),(?P<w3>\w+)&#39;, &#39;foo,quux,baz&#39;)
>>> m.groups()
(&#39;foo&#39;, &#39;quux&#39;, &#39;baz&#39;)

>>> m.group(&#39;w1&#39;)
&#39;foo&#39;
>>> m.group(&#39;w3&#39;)
&#39;baz&#39;
>>> m.group(&#39;w1&#39;, &#39;w2&#39;, &#39;w3&#39;)
(&#39;foo&#39;, &#39;quux&#39;, &#39;baz&#39;)
>>> m.group(1, 2, 3)
(&#39;foo&#39;, &#39;quux&#39;, &#39;baz&#39;)

(?P=) 匹配先前捕获名的内容

>>> m = re.search(r'(\w+),\1', 'foo,foo')
>>> m
<_sre.SRE_Match object; span=(0, 7), match=&#39;foo,foo&#39;>
>>> m.group(1)
&#39;foo&#39;
>>> m = re.search(r&#39;(?P<word>\w+),(?P=word)&#39;, &#39;foo,foo&#39;)
>>> m
<_sre.SRE_Match object; span=(0, 7), match=&#39;foo,foo&#39;>
>>> m.group(&#39;word&#39;)
&#39;foo&#39;

(?:) 创建一个非捕获组

>>> m = re.search('(\w+),(?:\w+),(\w+)', 'foo,quux,baz')
>>> m.groups()
('foo', 'baz')

>>> m.group(1)
'foo'
>>> m.group(2)
'baz'

指定条件匹配

(?()|)

(?()|)

# ^(###)?表示搜索字符串可选地以 . 开头'###'。如果是这样，那么周围的分组括号###将创建一个编号为的组1。否则，不会存在这样的组
# foo字面上匹配字符串'foo'
# (?(1)bar|baz)匹配'bar'组是否1存在和'baz'不存在
regex = r'^(###)?foo(?(1)bar|baz)'


# 搜索字符串'###foobar'确实以 开头'###'，因此解析器创建了一个编号为 的组1。然后条件匹配是针对'bar'匹配的
>>> re.search(regex, '###foobar')
<_sre.SRE_Match object; span=(0, 9), match=&#39;###foobar&#39;>

# 搜索字符串&#39;###foobaz&#39;确实以 开头&#39;###&#39;，因此解析器创建了一个编号为 的组1。然后条件匹配是反对&#39;bar&#39;，不匹配。
>>> print(re.search(regex, &#39;###foobaz&#39;))
None

# 搜索字符串&#39;foobar&#39;不以 开头&#39;###&#39;，因此没有编号为 的组1。然后条件匹配是反对&#39;baz&#39;，不匹配。
>>> print(re.search(regex, &#39;foobar&#39;))
None

# 搜索字符串&#39;foobaz&#39;不以 开头&#39;###&#39;，因此没有编号为 的组1。然后条件匹配是针对&#39;baz&#39;匹配的。
>>> re.search(regex, &#39;foobaz&#39;)
<_sre.SRE_Match object; span=(0, 6), match=&#39;foobaz&#39;>

类别8：Lookahead 和 Lookbehind 断言

根据解析器在搜索字符串中当前位置的后面（左侧）或前面（右侧）来确定 Python 中正则表达式匹配的成功或失败。积极前瞻断言可表示为：(?=lookahead_regex)

(?=) 积极前瞻断言

# 断言正则表达式解析器当前位置之后的内容必须匹配
# 前瞻断言(?=[a-z])指定后面的'foo'必须是小写字母字符。
>>> re.search('foo(?=[a-z])', 'foobar')
<_sre.SRE_Match object; span=(0, 3), match=&#39;foo&#39;>
# 前瞻失败的例子，foo的下一个字符是&#39;1&#39;
>>> print(re.search(&#39;foo(?=[a-z])&#39;, &#39;foo123&#39;))
None

# 前瞻的独特之处<lookahead_regex>在于不消耗搜索字符串中匹配的部分，并且它不是返回的匹配对象的一部分。
>>> re.search(&#39;foo(?=[a-z])&#39;, &#39;foobar&#39;)
<_sre.SRE_Match object; span=(0, 3), match=&#39;foo&#39;>

# 举例对比观察，?=断言的区别
>>> m = re.search(&#39;foo(?=[a-z])(?P<ch>.)&#39;, &#39;foobar&#39;)
>>> m.group(&#39;ch&#39;)
&#39;b&#39;
>>> m = re.search(&#39;foo([a-z])(?P<ch>.)&#39;, &#39;foobar&#39;)
>>> m.group(&#39;ch&#39;)
&#39;a&#39;

(?!) 否定的前瞻断言

# 例子和之前的前瞻积极断言相反
>>> re.search('foo(?=[a-z])', 'foobar')
<_sre.SRE_Match object; span=(0, 3), match=&#39;foo&#39;>
>>> print(re.search(&#39;foo(?![a-z])&#39;, &#39;foobar&#39;))
None

>>> print(re.search(&#39;foo(?=[a-z])&#39;, &#39;foo123&#39;))
None
>>> re.search(&#39;foo(?![a-z])&#39;, &#39;foo123&#39;)
<_sre.SRE_Match object; span=(0, 3), match=&#39;foo&#39;>

(?) 积极的后向断言

# 断言正则表达式解析器当前位置之前的内容匹配
# 断言指定'foo'必须先于'bar'
>>> re.search(&#39;(?<=foo)bar&#39;, &#39;foobar&#39;)
<_sre.SRE_Match object; span=(3, 6), match=&#39;bar&#39;>
>>> print(re.search(&#39;(?<=qux)bar&#39;, &#39;foobar&#39;))
None

(?) 否定的向后断言

# 例子和之前的向后积极断言相反
>>> print(re.search(&#39;(?<!foo)bar&#39;, &#39;foobar&#39;))
None
>>> re.search(&#39;(?<!qux)bar&#39;, &#39;foobar&#39;)
<_sre.SRE_Match object; span=(3, 6), match=&#39;bar&#39;>

类别9：杂项元字符

(?#…) 指定注释

# 正则表达式解析器忽略(?#...)序列中包含的任何内容
>>> re.search('bar(?#This is a comment) *baz', 'foo bar baz qux')
<_sre.SRE_Match object; span=(4, 11), match=&#39;bar baz&#39;>

竖条或管道 ( | ) 指定要匹配的一组备选方案

# 形式的表达式最多匹配一个指定的表达式：<regex1>|<regex2>|...|<regexn><regexi>
>>> re.search(&#39;foo|bar|baz&#39;, &#39;bar&#39;)
<_sre.SRE_Match object; span=(0, 3), match=&#39;bar&#39;>
>>> re.search(&#39;foo|bar|baz&#39;, &#39;baz&#39;)
<_sre.SRE_Match object; span=(0, 3), match=&#39;baz&#39;>
>>> print(re.search(&#39;foo|bar|baz&#39;, &#39;quux&#39;))
None

# 结合交替、分组和任何其他元字符来实现您需要的任何复杂程度。
# (foo|bar|baz)+表示一个或多个字符串
>>> re.search(&#39;(foo|bar|baz)+&#39;, &#39;foofoofoo&#39;)
<_sre.SRE_Match object; span=(0, 9), match=&#39;foofoofoo&#39;>
>>> re.search(&#39;(foo|bar|baz)+&#39;, &#39;bazbazbazbaz&#39;)
<_sre.SRE_Match object; span=(0, 12), match=&#39;bazbazbazbaz&#39;>
>>> re.search(&#39;(foo|bar|baz)+&#39;, &#39;barbazfoo&#39;)
<_sre.SRE_Match object; span=(0, 9), match=&#39;barbazfoo&#39;>

# ([0-9]+|[a-f]+)表示一个或多个十进制数字字符的序列或一个或多个&#39;a-f&#39;字符的序列
>>> re.search(&#39;([0-9]+|[a-f]+)&#39;, &#39;456&#39;)
<_sre.SRE_Match object; span=(0, 3), match=&#39;456&#39;>
>>> re.search(&#39;([0-9]+|[a-f]+)&#39;, &#39;ffda&#39;)
<_sre.SRE_Match object; span=(0, 4), match=&#39;ffda&#39;>

Das obige ist der detaillierte Inhalt vonSo verwenden Sie Metazeichen des re-Moduls in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!