Python中re模塊的元字符怎么使用

這篇文章主要介紹“Python中re模塊的元字符怎么使用”的相關(guān)知識(shí)，小編通過(guò)實(shí)際案例向大家展示操作過(guò)程，操作方法簡(jiǎn)單快捷，實(shí)用性強(qiáng)，希望這篇“Python中re模塊的元字符怎么使用”文章能幫助大家解決問(wèn)題。

元字符（Meta Characters）是正則表達(dá)式中具有特殊意義的專用字符，在Python中也不例外，是用來(lái)指明前導(dǎo)字符（位于元字符前的字符）在目標(biāo)對(duì)象中的出現(xiàn)模式。

在正則表達(dá)式中，方括號(hào) ( [] ) 中指定的一組字符組成一個(gè)字符類。

# 元字符序列匹配類中的任何單個(gè)字符
>>> s = 'foo123bar'

# 3個(gè)任意連續(xù)字符匹配
>>> re.search('[0-9][0-9][0-9]', s)
<_sre.SRE_Match object; span=(3, 6), match='123'>

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

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

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

# 匹配不上的情況
>>> print(re.search('[0-9][0-9][0-9]', '12foo34'))
None

通配符點(diǎn) ( . ) 元字符匹配除換行符以外的任何字符。

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

>>> s = 'foo13bar'
>>> print(re.search('1.3', s))
None

re模塊支持的元字符

下面列表都是元字符的描述，對(duì)元字符進(jìn)行分類描述方便記憶。 這個(gè)要是看不懂直接看跳過(guò)看下面的例子。

類別1：匹配單個(gè)字符的元字符

方括號(hào)( [] ) 字符集

指定要匹配的特定字符集。 字符類元字符序列將匹配該類中包含的任何單個(gè)字符。

# 元字符序列[artz]匹配任何單個(gè)'a'、'r'、't'或'z'字符
# ba[artz]同時(shí)匹配'bar'and 'baz'（也將匹配'baa'and 'bat'）。
>>> re.search('ba[artz]', 'foobarqux')
<_sre.SRE_Match object; span=(3, 6), match='bar'>
>>> re.search('ba[artz]', 'foobazqux')
<_sre.SRE_Match object; span=(3, 6), match='baz'>

匹配和[a-z]之間的任何小寫(xiě)字母字符。

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

匹配和[0-9]之間任何數(shù)字字符。

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

[0-9a-fA-F]匹配任何十六進(jìn)制數(shù)字字符。

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

[^0-9]匹配任何不是數(shù)字的字符開(kāi)頭的字符。

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

如果一個(gè)^字符出現(xiàn)在字符類中但不是第一個(gè)字符則無(wú)結(jié)果。

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

可以通過(guò)用連字符分隔字符來(lái)指定字符類中的字符范圍，可以將其作為第一個(gè)或最后一個(gè)字符放置，或者使用反斜杠 ( \ ) 對(duì)其進(jìn)行轉(zhuǎn)義。

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


# 查找轉(zhuǎn)義符號(hào)
>>> re.search('[]]', 'foo[1]')
<_sre.SRE_Match object; span=(5, 6), match=']'>
>>> re.search('[ab\]cd]', 'foo[1]')
<_sre.SRE_Match object; span=(5, 6), match=']'>


# [ ] 內(nèi)的元字符失去意義轉(zhuǎn)義成字符處理
>>> re.search('[)*+|]', '123*456')
<_sre.SRE_Match object; span=(3, 4), match='*'>
>>> re.search('[)*+|]', '123+456')
<_sre.SRE_Match object; span=(3, 4), match='+'>

點(diǎn) ( . ) 通配符

匹配除換行符以外的任何單個(gè)字符。

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

\w 和 \W 單詞字符匹配

\w匹配任何字母數(shù)字字符，單詞字符是大寫(xiě)和小寫(xiě)字母、數(shù)字和下劃線 ( _) 字符。

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

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

\W是相反的。它匹配任何非單詞字符。

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

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

\d 和 \D 字符十進(jìn)制數(shù)字匹配

\d匹配任何十進(jìn)制數(shù)字字符，等價(jià)于[0-9]。

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

\D匹配任何不是十進(jìn)制數(shù)字的字符，等價(jià)于[^0-9]。

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

\s 和 \S 字符空格匹配

\s匹配任何空白字符，同時(shí)也匹配換行符。

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

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

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

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

字符類序列\(zhòng)w, \W, \d, \D, \s, 和\S也可以出現(xiàn)在方括號(hào)字符類中。

# [\d\w\s]匹配任何數(shù)字、單詞或空白字符

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

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

類別2：轉(zhuǎn)義元字符

反斜杠 ( \ ) 轉(zhuǎn)義元字符

反斜杠會(huì)刪除元字符的特殊含義。

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

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

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

類別3：錨點(diǎn)

不匹配搜索字符串中的任何實(shí)際字符，并且在解析期間它們不使用任何搜索字符串。指示搜索字符串中必須發(fā)生匹配的特定位置。

^ 和 \A 字符串的開(kāi)頭匹配項(xiàng)

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

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

$ 和\Z 字符串的結(jié)尾匹配項(xiàng)

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

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

# 特殊$也在搜索字符串末尾的單個(gè)換行符之前匹配
>>> re.search('bar$', 'foobar\n')
<_sre.SRE_Match object; span=(3, 6), match='bar'>

\b 和 \B 單詞匹配

\b 必須在單詞的開(kāi)頭或結(jié)尾。

# 單詞開(kāi)頭
>>> re.search(r'\bbar', 'foo bar')
<_sre.SRE_Match object; span=(4, 7), match='bar'>
>>> re.search(r'\bbar', 'foo.bar')
<_sre.SRE_Match object; span=(4, 7), match='bar'>
>>> print(re.search(r'\bbar', 'foobar'))
None

# 單詞結(jié)尾
>>> re.search(r'foo\b', 'foo bar')
<_sre.SRE_Match object; span=(0, 3), match='foo'>
>>> re.search(r'foo\b', 'foo.bar')
<_sre.SRE_Match object; span=(0, 3), match='foo'>
>>> print(re.search(r'foo\b', 'foobar'))
None


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

\B 不能在單詞的開(kāi)頭或結(jié)尾。

>>> 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='foo'>

類別4：量詞

該部分必須出現(xiàn)多少次才能使匹配成功。

* 匹配前面的子表達(dá)式零次或多次

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

匹配2個(gè)字符中全部的內(nèi)容。

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

+ 匹配前面的子表達(dá)式一次或多次

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

? 匹配前面的子表達(dá)式零次或一次

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

.*?、+?、?? 最小長(zhǎng)度匹配

加問(wèn)號(hào)則表示為最小長(zhǎng)度匹配的懶惰模式。

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

# .*全匹配貪婪模式
>>> re.search('<.*>', '%<foo> <bar> <baz>%')
<_sre.SRE_Match object; span=(1, 18), match='<foo> <bar> <baz>'>
# *? 前一個(gè)字符0次或無(wú)限次擴(kuò)展，最小匹配
>>> re.search('<.*?>', '%<foo> <bar> <baz>%')
<_sre.SRE_Match object; span=(1, 6), match='<foo>'>
# .+ 前一個(gè)字符1次或無(wú)限次擴(kuò)展，最小匹配
>>> re.search('<.+>', '%<foo> <bar> <baz>%')
<_sre.SRE_Match object; span=(1, 18), match='<foo> <bar> <baz>'>
# .+? 前一個(gè)字符1次或無(wú)限次擴(kuò)展，最小匹配
>>> re.search('<.+?>', '%<foo> <bar> <baz>%')
<_sre.SRE_Match object; span=(1, 6), match='<foo>'>

# ? 匹配懶惰模式
>>> re.search('ba?', 'baaaa')
<_sre.SRE_Match object; span=(0, 2), match='ba'>
# ?? 前一個(gè)字符0次或1次擴(kuò)展，最小匹配
>>> re.search('ba??', 'baaaa')
<_sre.SRE_Match object; span=(0, 1), match='b'>

{m} 完全匹配m次前面元字符的正則表達(dá)式。

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

{m,n} 匹配前面正則表達(dá)式的任意數(shù)量的重復(fù)從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='x--x'>
3  x---x      <_sre.SRE_Match object; span=(0, 5), match='x---x'>
4  x----x     <_sre.SRE_Match object; span=(0, 6), match='x----x'>
5  x-----x    None

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

{m,n}? 只匹配一次

非貪婪（懶惰）版本 {m,n}。

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

類別5：分組構(gòu)造和反向引用

分組構(gòu)造將 Python 中的正則表達(dá)式分解為子表達(dá)式或組。

• 分組：一個(gè)組代表一個(gè)單一的句法實(shí)體。附加元字符作為一個(gè)單元應(yīng)用于整個(gè)組。

• 捕獲：一些分組結(jié)構(gòu)還捕獲與組中的子表達(dá)式匹配的搜索字符串部分?？梢酝ㄟ^(guò)幾種不同的機(jī)制檢索捕獲的匹配項(xiàng)。

(<regex>)，定義子表達(dá)式或組。

# 括號(hào)中的正則表達(dá)式僅匹配括號(hào)的內(nèi)容
>>> re.search('(bar)', 'foo bar baz')
<_sre.SRE_Match object; span=(4, 7), match='bar'>
>>> re.search('bar', 'foo bar baz')
<_sre.SRE_Match object; span=(4, 7), match='bar'>

將組視為一個(gè)單元

組后面的量詞元字符對(duì)組中指定的整個(gè)子表達(dá)式作為一個(gè)單元進(jìn)行操作。

# 元字符+僅適用于字符'r'，'ba'隨后出現(xiàn)一次或多次'r'。
>>> re.search('bar+', 'foo bar baz')
<_sre.SRE_Match object; span=(4, 7), match='bar'>
>>> re.search('(bar)+', 'foo bar baz')
<_sre.SRE_Match object; span=(4, 7), match='bar'>
>>> re.search('(bar)+', 'foo barbar baz')
<_sre.SRE_Match object; span=(4, 10), match='barbar'>
>>> re.search('(bar)+', 'foo barbarbarbar baz')
<_sre.SRE_Match object; span=(4, 16), match='barbarbarbar'>

捕獲組，m.groups()

返回一個(gè)元組，其中包含從正則表達(dá)式匹配中捕獲的所有組。

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

捕獲組，m.group(<n>)

返回包含<n>捕獲的匹配項(xiàng)的字符串。

>>> 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(<n1>, <n2>, &hellip;)

返回一個(gè)包含指定捕獲匹配序號(hào)的元組。

>>> 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：反向引用

\<num> 匹配連續(xù)相同字符

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

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

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

>>> m = re.search(regex, 'foo,qux')
>>> print(m)
None

類別7：其他分組結(jié)構(gòu)

(?P<name><regex>) 創(chuàng)建捕獲組并命名

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

>>> m.group('w1')
'foo'
>>> m.group('w3')
'baz'
>>> m.group('w1', 'w2', 'w3')
('foo', 'quux', 'baz')
>>> m.group(1, 2, 3)
('foo', 'quux', 'baz')

(?P=<name>) 匹配先前捕獲名的內(nèi)容

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

(?:<regex>) 創(chuàng)建一個(gè)非捕獲組

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

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

指定條件匹配

(?(<n>)<yes-regex>|<no-regex>)

(?(<name>)<yes-regex>|<no-regex>)

# ^(###)?表示搜索字符串可選地以 . 開(kāi)頭'###'。如果是這樣，那么周圍的分組括號(hào)###將創(chuàng)建一個(gè)編號(hào)為的組1。否則，不會(huì)存在這樣的組
# foo字面上匹配字符串'foo'
# (?(1)bar|baz)匹配'bar'組是否1存在和'baz'不存在
regex = r'^(###)?foo(?(1)bar|baz)'


# 搜索字符串'###foobar'確實(shí)以 開(kāi)頭'###'，因此解析器創(chuàng)建了一個(gè)編號(hào)為 的組1。然后條件匹配是針對(duì)'bar'匹配的
>>> re.search(regex, '###foobar')
<_sre.SRE_Match object; span=(0, 9), match='###foobar'>

# 搜索字符串'###foobaz'確實(shí)以 開(kāi)頭'###'，因此解析器創(chuàng)建了一個(gè)編號(hào)為 的組1。然后條件匹配是反對(duì)'bar'，不匹配。
>>> print(re.search(regex, '###foobaz'))
None

# 搜索字符串'foobar'不以 開(kāi)頭'###'，因此沒(méi)有編號(hào)為 的組1。然后條件匹配是反對(duì)'baz'，不匹配。
>>> print(re.search(regex, 'foobar'))
None

# 搜索字符串'foobaz'不以 開(kāi)頭'###'，因此沒(méi)有編號(hào)為 的組1。然后條件匹配是針對(duì)'baz'匹配的。
>>> re.search(regex, 'foobaz')
<_sre.SRE_Match object; span=(0, 6), match='foobaz'>

類別8：Lookahead 和 Lookbehind 斷言

根據(jù)解析器在搜索字符串中當(dāng)前位置的后面（左側(cè)）或前面（右側(cè)）來(lái)確定 Python 中正則表達(dá)式匹配的成功或失敗。(?=<lookahead_regex>) 積極前瞻斷言

(?=<lookahead_regex>) 積極前瞻斷言

# 斷言正則表達(dá)式解析器當(dāng)前位置之后的內(nèi)容必須匹配
# 前瞻斷言(?=[a-z])指定后面的'foo'必須是小寫(xiě)字母字符。
>>> re.search('foo(?=[a-z])', 'foobar')
<_sre.SRE_Match object; span=(0, 3), match='foo'>
# 前瞻失敗的例子，foo的下一個(gè)字符是'1'
>>> print(re.search('foo(?=[a-z])', 'foo123'))
None

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

# 舉例對(duì)比觀察，?=斷言的區(qū)別
>>> m = re.search('foo(?=[a-z])(?P<ch>.)', 'foobar')
>>> m.group('ch')
'b'
>>> m = re.search('foo([a-z])(?P<ch>.)', 'foobar')
>>> m.group('ch')
'a'

(?!<lookahead_regex>) 否定的前瞻斷言

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

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

(?<=<lookbehind_regex>) 積極的后向斷言

# 斷言正則表達(dá)式解析器當(dāng)前位置之前的內(nèi)容匹配
# 斷言指定'foo'必須先于'bar'
>>> re.search('(?<=foo)bar', 'foobar')
<_sre.SRE_Match object; span=(3, 6), match='bar'>
>>> print(re.search('(?<=qux)bar', 'foobar'))
None

(?<!&ndash;<lookbehind_regex&ndash;>) 否定的向后斷言

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

類別9：雜項(xiàng)元字符

(?#&hellip;) 指定注釋

# 正則表達(dá)式解析器忽略(?#...)序列中包含的任何內(nèi)容
>>> re.search('bar(?#This is a comment) *baz', 'foo bar baz qux')
<_sre.SRE_Match object; span=(4, 11), match='bar baz'>

豎條或管道 ( | ) 指定要匹配的一組備選方案

# 形式的表達(dá)式最多匹配一個(gè)指定的表達(dá)式：<regex1>|<regex2>|...|<regexn><regexi>
>>> re.search('foo|bar|baz', 'bar')
<_sre.SRE_Match object; span=(0, 3), match='bar'>
>>> re.search('foo|bar|baz', 'baz')
<_sre.SRE_Match object; span=(0, 3), match='baz'>
>>> print(re.search('foo|bar|baz', 'quux'))
None

# 結(jié)合交替、分組和任何其他元字符來(lái)實(shí)現(xiàn)您需要的任何復(fù)雜程度。
# (foo|bar|baz)+表示一個(gè)或多個(gè)字符串
>>> re.search('(foo|bar|baz)+', 'foofoofoo')
<_sre.SRE_Match object; span=(0, 9), match='foofoofoo'>
>>> re.search('(foo|bar|baz)+', 'bazbazbazbaz')
<_sre.SRE_Match object; span=(0, 12), match='bazbazbazbaz'>
>>> re.search('(foo|bar|baz)+', 'barbazfoo')
<_sre.SRE_Match object; span=(0, 9), match='barbazfoo'>

# ([0-9]+|[a-f]+)表示一個(gè)或多個(gè)十進(jìn)制數(shù)字字符的序列或一個(gè)或多個(gè)'a-f'字符的序列
>>> re.search('([0-9]+|[a-f]+)', '456')
<_sre.SRE_Match object; span=(0, 3), match='456'>
>>> re.search('([0-9]+|[a-f]+)', 'ffda')
<_sre.SRE_Match object; span=(0, 4), match='ffda'>

關(guān)于“Python中re模塊的元字符怎么使用”的內(nèi)容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業(yè)相關(guān)的知識(shí)，可以關(guān)注億速云行業(yè)資訊頻道，小編每天都會(huì)為大家更新不同的知識(shí)點(diǎn)。