Python で re モジュールのメタキャラクターを使用する方法

メタキャラクターとは、正規表現において特別な意味を持つ特殊文字で、Python でも例外ではなく、対象オブジェクト内の先頭文字 (メタキャラクターの前の文字) の出現パターンを示すために使用されます。

正規表現では、角括弧 ( [] ) で指定された一連の文字が文字クラスを形成します。

# 元字符序列匹配类中的任何单个字符
>>> 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

ワイルドカード ドット ( . ) メタ文字は、改行文字を除く任意の文字と一致します。

>>> 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 モジュールでサポートされるメタキャラクター

次のリストはメタキャラクターの説明です。メタキャラクターは、記憶しやすいように分類して説明されています。これが理解できない場合は、以下の例に進んでください。

#文字説明##\^##$ は入力の終了位置と一致しますRegExp オブジェクトの Multiline プロパティが設定されている場合、$ は ‘\n’ または ‘\r’ の前の位置にも一致します。式の前のゼロ個以上のサブゼロと一致します。たとえば、zo* は「z」および「zoo」と一致します。* は {0,} と同等です。match 前述の部分式を 1 回以上一致させます。たとえば、‘zo ’ は、「zo」と「zoo」には一致しますが、「z」には一致しません。{1,} と同等。 #[xyz]文字セット。含まれる任意の文字と一致します。たとえば、‘[abc]’ は、「plain」a’ の ‘ と一致します。#[^xyz][a-z][^a-z] \b\B\cx \d\D\f\n\r\s\S\t\v\w\W\xn

次の文字をマークします特殊文字、リテラル文字、後方参照、または 8 進エスケープ文字。たとえば、‘n’ は文字「n」と一致します。 ‘\n’ は改行文字と一致します。シーケンス ‘\’ は "" に一致し、"(" は "(" に一致します。
は入力文字列の先頭に一致します。RegExp が設定されている場合オブジェクトの Multiline 属性 ^ は、‘\n’ または ‘\r’ の後の位置とも一致します。
?	前述の部分式と 0 回または 1 回一致します。たとえば、「do(es)?」は「do」または「does」と一致します。 ? {0,1} に相当します。
{n}	n は負ではない整数です。特定の回数 n 回一致します。たとえば、‘o{2}’ は、「Bob」の ‘o’ とは一致しませんが、「food」の両方の o には一致します。
{n,}	n は負ではない整数です。少なくとも n 回一致します。たとえば、‘o{2,}’ は、「Bob」の ‘o’ とは一致しませんが、「foooood」のすべての o には一致します。 ‘o{1,}’ は ‘o ’ と同等です。 ‘o{0,}’ は ‘o*’ と同等です。
{n,m}	m と n は両方とも非負の整数であり、n <= m です。少なくとも n 回、最大で m 回一致します。たとえば、「o{1,3}」は「fooooood」の最初の 3 つの o と一致します。 ‘o{0,1}’ は ‘o?’ と同等です。カンマと 2 つの数字の間にスペースを入れることはできないことに注意してください。
?	この文字の直後に他のリミッター (*、 、 ?、 {n}、 {n,}、 {n,m} ) が続く場合、一致するパターンは貪欲ではありません。非貪欲モードは検索文字列の可能な限り少ない部分と一致しますが、デフォルトの貪欲モードは検索文字列の可能な限り多くの部分と一致します。たとえば、文字列「oooo」の場合、‘o ?’ は単一の「o」と一致しますが、‘o ’ はすべての「o」と一致します。
.	改行文字 (\n、\r) を除く任意の 1 文字と一致します。 ‘\n’ を含む任意の文字と一致するには、「(.
x|y	のようなものを使用して x または y と一致します。たとえば、'z
否定文字のコレクション。含まれていない任意の文字と一致します。たとえば、‘[^abc]’ は " ’p&rsquo と一致します;、‘l’、‘i’、‘n’ in plain"。
文字範囲。指定された任意の文字と一致します。たとえば、‘[a-z]’ は、範囲 ‘a’ から ‘z’ 内の任意の小文字のアルファベット文字と一致します。
負の文字範囲。指定された範囲内にない任意の文字と一致します。たとえば、‘[^a-z]’ は、‘a’ から ‘z’ までの範囲内にない任意の文字と一致します。
単語とスペースの間の位置を指す単語境界に一致します。たとえば、‘er\b’ は、次の &lsquo に一致します。 「never」 ;er’ ですが、「verb」の ‘er’ には一致しません。
は単語以外の境界に一致します。‘er\B’ 「verb」には一致しますが、「never」の ‘er’ には一致できません。
x で指定された制御文字と一致します。たとえば、次のようになります。 \cM は、Control-M またはキャリッジ リターン文字と一致します。x の値は、A ～ Z または a ～ z のいずれかである必要があります。それ以外の場合、c はリテラル ‘c’ 文字として扱われます。
数字と一致します。[0-9] と同等です。
数字以外の文字と一致します。など。 [^0-9].
はフォーム フィード文字と一致します。 \x0c および \cL に相当します。
改行文字と一致します。 \x0a および \cJ に相当します。
復帰文字と一致します。 \x0d および \cM に相当します。
スペース、タブ、フォーム フィードなどの任意の空白文字と一致します。 [ \f\n\r\t\v] と同等。
空白以外の任意の文字と一致します。 [^ \f\n\r\t\v] と同等。
タブ文字と一致します。 \x09 および \cI に相当します。
垂直タブ文字と一致します。 \x0b および \cK に相当します。
文字、数字、アンダースコアと一致します。 「[A-Za-z0-9_]」と同等。
文字、数字、アンダースコア以外の文字に一致します。 「[^A-Za-z0-9_]」と同等。
n と一致します。n は 16 進数のエスケープ値です。 16 進数のエスケープ値は、正確に 2 桁の長さである必要があります。たとえば、「\x41」は「A」と一致します。 ‘\x041’ は ‘\x04’ & “1” と同等です。正则表达式中可以使用 ASCII 编码。
\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

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

>>> 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;>

以上がPython で re モジュールのメタキャラクターを使用する方法の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。