Rumah > pembangunan bahagian belakang > Tutorial Python > Cara menggunakan metacharacters modul semula dalam Python

Cara menggunakan metacharacters modul semula dalam Python

WBOY
Lepaskan: 2023-06-02 20:19:35
ke hadapan
1597 orang telah melayarinya

Watak Meta ialah watak istimewa dengan makna istimewa dalam ungkapan biasa, dan tidak terkecuali dalam Python Ia digunakan untuk menunjukkan corak penampilan watak utama (watak sebelum aksara meta) dalam objek sasaran.

Dalam ungkapan biasa, satu set aksara yang dinyatakan dalam kurungan segi empat sama ( [] ) membentuk kelas aksara.

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

Kad bebas dot ( . ) Metakarakter sepadan dengan mana-mana aksara kecuali aksara baris baharu.

>>> s = &#39;foo123bar&#39;
>>> re.search(&#39;1.3&#39;, 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
Salin selepas log masuk

Karakter meta yang disokong oleh modul semula

Cara menggunakan metacharacters modul semula dalam Python

Senarai berikut ialah penerangan tentang aksara meta dikelaskan dan diterangkan untuk memudahkan ingatan. Jika anda tidak faham perkara ini, langkau sahaja ke contoh di bawah.

sepadan dengan formula satu atau lebih banyak kali, contohnya, ‘zo+’+ adalah bersamaan dengan {1,}. [^xyz] sepadan dengan mana-mana aksara yang tidak disertakan, contohnya, ‘[^abc]’ , ‘i’, ‘n’ [a-z] julat aksara Sebagai contoh, ‘[a-z]’ mana-mana aksara kecil dalam julat ‘a’ hingga ‘z’ julat yang ditentukan, contohnya, ‘[^a-z]’ dD nrsStvwWxn
Watak Penerangan
Tandakan watak seterusnya sebagai Istimewa watak, atau watak literal, atau rujukan belakang, atau watak pelarian oktal. Contohnya, ‘n’ ‘n’ padan dengan watak baris baharu. Urutan ‘’ sepadan dengan "" dan "(" sepadan dengan "(".
^ sepadan dengan permulaan rentetan input. Jika objek RegExp ialah set Untuk atribut Multiline, ^ juga sepadan dengan kedudukan selepas ‘n’ atau ‘r’ Sifat Multiline objek RegExp, $ juga sepadan dengan kedudukan sebelum ‘n’ atau ‘r’ kali. Contohnya, zo* boleh memadankan "z" dan "zoo * bersamaan dengan {0,}.
+
? sepadan dengan subungkapan sebelumnya sifar atau satu kali. Contohnya, "do(es)?" akan sepadan dengan "do" atau "does" . ? Bersamaan dengan {0,1}.
{n}n ialah integer bukan negatif. Padankan bilangan n kali tertentu. Contohnya, ‘o{2}’ tidak sepadan dengan ‘o’
{n,}n ialah integer bukan negatif. Padankan sekurang-kurangnya n kali. Contohnya, ‘o{2,}’ tidak sepadan dengan ‘o’ ‘o{1,}’ bersamaan dengan ‘o+’. ‘o{0,}’ bersamaan dengan ‘o*’.
{n,m}m dan n kedua-duanya adalah integer bukan negatif, dengan n <= m. Padankan sekurang-kurangnya n kali dan paling banyak m masa. Contohnya, "o{1,3}" akan sepadan dengan tiga o pertama dalam "fooooood". ‘o{0,1}’ adalah bersamaan dengan ‘o?’. Sila ambil perhatian bahawa tidak boleh ada ruang antara koma dan dua nombor.
?Apabila watak ini diikuti dengan serta-merta oleh mana-mana pengehad lain (*, +, ?, {n}, {n,}, {n,m } ) nanti corak padan tak tamak. Mod tidak tamak sepadan dengan sedikit rentetan yang dicari, manakala mod tamak lalai sepadan dengan seberapa banyak rentetan yang dicari yang mungkin. Contohnya, untuk rentetan "oooo", ‘o+?’ akan sepadan dengan satu "o", manakala ‘o+’
. sepadan dengan mana-mana aksara kecuali baris baharu (n, r). Untuk memadankan mana-mana aksara termasuk ‘n’, gunakan sesuatu seperti "(.
x|y untuk memadankan x atau y. Contohnya, 'z
[xyz] sepadan dengan mana-mana watak yang terkandung di dalamnya, contohnya, ‘[abc]’ >
sepadan dengan sempadan perkataan, iaitu, kedudukan antara perkataan dan ruang Contohnya, ‘erb’ ".
B boleh memadankan sempadan bukan perkataan. ;er’, tetapi tidak boleh memadankan ‘er’ dalam "tidak pernah".
cx sepadan dengan aksara kawalan yang ditentukan oleh x Contohnya, cM sepadan dengan aksara Kawalan -M atau nilai carriage return. c dianggap sebagai ‘c’
sepadan dengan aksara angka bersamaan dengan
sepadan dengan aksara bukan angka ]. Bersamaan dengan x0c dan cL.
sepadan dengan watak baris baharu. Bersamaan dengan x0a dan cJ.
sepadan dengan watak carriage return. Bersamaan dengan x0d dan cM.
sepadan dengan mana-mana aksara ruang putih, termasuk ruang, tab, suapan borang, dsb. Bersamaan dengan [fnrtv].
sepadan dengan mana-mana aksara bukan ruang putih. Bersamaan dengan [^ fnrtv].
sepadan dengan watak tab. Bersamaan dengan x09 dan cI.
sepadan dengan aksara tab menegak. Bersamaan dengan x0b dan cK.
Memadankan huruf, nombor dan garis bawah. Bersamaan dengan ’[A-Za-z0-9_]'.
sepadan dengan bukan huruf, nombor dan garis bawah. Bersamaan dengan ‘[^A-Za-z0-9_]’.
sepadan dengan n, di mana n ialah nilai pelarian heksadesimal. Nilai luput heksadesimal mestilah tepat dua digit panjang. Contohnya, ‘x41’ ‘x041’正则表达式中可以使用 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]匹配任何单个&#39;a&#39;、&#39;r&#39;、&#39;t&#39;或&#39;z&#39;字符
# ba[artz]同时匹配&#39;bar&#39;and &#39;baz&#39;(也将匹配&#39;baa&#39;and &#39;bat&#39;)。
>>> re.search(&#39;ba[artz]&#39;, &#39;foobarqux&#39;)
<_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;>
Salin selepas log masuk

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

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

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

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

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

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

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

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

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

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

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

# 直接查找符号
>>> re.search(&#39;[-abc]&#39;, &#39;123-456&#39;)
<_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;>
Salin selepas log masuk

点 ( . ) 通配符

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

>>> re.search(&#39;foo.bar&#39;, &#39;fooxbar&#39;)
<_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;>
Salin selepas log masuk

\w 和 \W 单词字符匹配

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

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

>>> re.search(&#39;\w&#39;, &#39;#(.a$@&&#39;)
<_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;>
Salin selepas log masuk

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

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

>>> re.search(&#39;\W&#39;, &#39;a_1*3Qb&#39;)
<_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;>
Salin selepas log masuk

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

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

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

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

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

\s 和 \S 字符空格匹配

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

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

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

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

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

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

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

>>> re.search(&#39;[\d\w\s]&#39;, &#39;---3---&#39;)
<_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;>
Salin selepas log masuk

类别2:转义元字符

反斜杠 ( \ ) 转义元字符

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

>>> re.search(&#39;.&#39;, &#39;foo.bar&#39;)
<_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;>
Salin selepas log masuk

类别3:锚点

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

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

>>> re.search(&#39;^foo&#39;, &#39;foobar&#39;)
<_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
Salin selepas log masuk

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

>>> re.search(&#39;bar$&#39;, &#39;foobar&#39;)
<_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;>
Salin selepas log masuk

\b 和 \B 单词匹配

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

# 单词开头
>>> re.search(r&#39;\bbar&#39;, &#39;foo bar&#39;)
<_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
Salin selepas log masuk

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

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

类别4:量词

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

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

>>> re.search(&#39;foo-*bar&#39;, &#39;foobar&#39;)                 
<_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;>
Salin selepas log masuk

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

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

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

>>> print(re.search(&#39;foo-+bar&#39;, &#39;foobar&#39;))              
None
>>> 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;>
Salin selepas log masuk

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

>>> re.search(&#39;foo-?bar&#39;, &#39;foobar&#39;)                    
<_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
Salin selepas log masuk

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

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

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

# .*全匹配贪婪模式
>>> 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;>
Salin selepas log masuk

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

>>> print(re.search(&#39;x-{3}x&#39;, &#39;x--x&#39;))                
None
>>> re.search(&#39;x-{3}x&#39;, &#39;x---x&#39;)                     
<_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
Salin selepas log masuk

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

>>> for i in range(1, 6):
...     s = f"x{&#39;-&#39; * i}x"
...     print(f&#39;{i}  {s:10}&#39;, re.search(&#39;x-{2,4}x&#39;, 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
Salin selepas log masuk
正则表达式匹配说明相同语法
< regex > {,n}任何小于或等于的重复次数n< regex > {0,n}
< regex > {m,}任何大于或等于的重复次数m----
< regex > {,}任意次数的重复< regex > {0,} , < regex > *
>>> re.search(&#39;x{}y&#39;, &#39;x{}y&#39;)
<_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;>
Salin selepas log masuk

{m,n}? 只匹配一次

非贪婪(懒惰)版本 {m,n}。

>>> re.search(&#39;a{3,5}&#39;, &#39;aaaaaaaa&#39;)
<_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;>
Salin selepas log masuk

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

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

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

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

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

# 括号中的正则表达式仅匹配括号的内容
>>> 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 bar baz&#39;)
<_sre.SRE_Match object; span=(4, 7), match=&#39;bar&#39;>
Salin selepas log masuk

将组视为一个单元

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

# 元字符+仅适用于字符&#39;r&#39;,&#39;ba&#39;随后出现一次或多次&#39;r&#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 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;>
Salin selepas log masuk
正则表达式解释匹配说明例子
bar+元字符+仅适用于字符’r’。‘ba’随后出现一次或多次’r’bar、barr、barrr等
(bar)+元字符+适用于整个字符串’bar’。出现一次或多次’bar’bar、barbar、barbarbar

捕获组,m.groups()

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

>>> m = re.search(&#39;(\w+),(\w+),(\w+)&#39;, &#39;foo,quux,baz&#39;)
>>> 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;)
Salin selepas log masuk

捕获组,m.group()

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

>>> m = re.search(&#39;(\w+),(\w+),(\w+)&#39;, &#39;foo,quux,baz&#39;)
>>> m.groups()
(&#39;foo&#39;, &#39;quux&#39;, &#39;baz&#39;)
>>> m.group(0)
(&#39;foo&#39;, &#39;quux&#39;, &#39;baz&#39;)
>>> m.group(1)
&#39;foo&#39;
>>> m.group(2)
&#39;quux&#39;
>>> m.group(3)
&#39;baz&#39;
Salin selepas log masuk

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

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

>>> m = re.search(&#39;(\w+),(\w+),(\w+)&#39;, &#39;foo,quux,baz&#39;)
>>> m.groups()
(&#39;foo&#39;, &#39;quux&#39;, &#39;baz&#39;)
>>> m.group(2, 3)
(&#39;quux&#39;, &#39;baz&#39;)
>>> m.group(3, 2, 1)
(&#39;baz&#39;, &#39;quux&#39;, &#39;foo&#39;)
Salin selepas log masuk

类别6:反向引用

\ 匹配连续相同字符

>>> regex = r&#39;(\w+),\1&#39;

>>> m = re.search(regex, &#39;foo,foo&#39;)
>>> 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
Salin selepas log masuk

类别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;)
Salin selepas log masuk

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

>>> m = re.search(r&#39;(\w+),\1&#39;, &#39;foo,foo&#39;)
>>> 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;
Salin selepas log masuk

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

>>> m = re.search(&#39;(\w+),(?:\w+),(\w+)&#39;, &#39;foo,quux,baz&#39;)
>>> m.groups()
(&#39;foo&#39;, &#39;baz&#39;)

>>> m.group(1)
&#39;foo&#39;
>>> m.group(2)
&#39;baz&#39;
Salin selepas log masuk

指定条件匹配

(?()|)

(?()|)

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


# 搜索字符串&#39;###foobar&#39;确实以 开头&#39;###&#39;,因此解析器创建了一个编号为 的组1。然后条件匹配是针对&#39;bar&#39;匹配的
>>> re.search(regex, &#39;###foobar&#39;)
<_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;>
Salin selepas log masuk

类别8:Lookahead 和 Lookbehind 断言

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

(?=) 积极前瞻断言

# 断言正则表达式解析器当前位置之后的内容必须匹配
# 前瞻断言(?=[a-z])指定后面的&#39;foo&#39;必须是小写字母字符。
>>> re.search(&#39;foo(?=[a-z])&#39;, &#39;foobar&#39;)
<_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;
Salin selepas log masuk

(?!) 否定的前瞻断言

# 例子和之前的前瞻积极断言相反
>>> re.search(&#39;foo(?=[a-z])&#39;, &#39;foobar&#39;)
<_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;>
Salin selepas log masuk

(?<=) 积极的后向断言

# 断言正则表达式解析器当前位置之前的内容匹配
# 断言指定&#39;foo&#39;必须先于&#39;bar&#39;
>>> 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
Salin selepas log masuk

(?) 否定的向后断言

# 例子和之前的向后积极断言相反
>>> 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;>
Salin selepas log masuk

类别9:杂项元字符

(?#…) 指定注释

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

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

# 形式的表达式最多匹配一个指定的表达式:<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;>
Salin selepas log masuk

Atas ialah kandungan terperinci Cara menggunakan metacharacters modul semula dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!

Label berkaitan:
sumber:yisu.com
Kenyataan Laman Web ini
Kandungan artikel ini disumbangkan secara sukarela oleh netizen, dan hak cipta adalah milik pengarang asal. Laman web ini tidak memikul tanggungjawab undang-undang yang sepadan. Jika anda menemui sebarang kandungan yang disyaki plagiarisme atau pelanggaran, sila hubungi admin@php.cn
Tutorial Popular
Lagi>
Muat turun terkini
Lagi>
kesan web
Kod sumber laman web
Bahan laman web
Templat hujung hadapan