메타 문자는 정규식에서 특별한 의미를 갖는 특수 문자이며, Python에서도 예외는 아닙니다. 대상 개체에서 선행 문자(메타 문자 앞의 문자)의 모양 패턴을 나타내는 데 사용됩니다.
정규 표현식에서는 대괄호( [] ) 안에 지정된 문자 집합이 문자 클래스를 형성합니다.
# 元字符序列匹配类中的任何单个字符 >>> s = 'foo123bar' # 3个任意连续字符匹配 >>> 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
와일드카드 점( . ) 메타 문자는 개행 문자를 제외한 모든 문자와 일치합니다.
>>> 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 모듈은 메타문자를 지원합니다
다음 목록은 메타문자에 대한 설명입니다. 이해가 되지 않는다면 아래 예시로 건너뛰세요.
Character | Description |
---|---|
다음 문자를 특수 문자, 리터럴 문자, 역참조 또는 8진수 이스케이프 문자로 표시합니다. 예를 들어 ‘n’은 문자 "n"과 일치합니다. ‘n’은 개행 문자와 일치합니다. 시퀀스 ‘’는 ""와 일치하고 "("는 "("와 일치합니다. | |
^ | 는 입력 문자열의 시작 부분과 일치합니다. RegExp 개체의 Multiline 속성이 설정된 경우 ^는 ‘n&rsquo와도 일치합니다. ; 또는 ‘r’ 뒤의 위치는 입력 문자열의 끝과 일치합니다. RegExp 개체의 Multiline 속성이 설정된 경우 $는 ‘n’과 일치합니다. 예를 들어, zo*는 "z" 및 "zoo"와 일치할 수 있습니다. *는 {0,}와 동일합니다. | +
? | 이전 하위 표현식과 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"의 처음 세 개의 o와 일치합니다. ‘o{0,1}’는 ‘o?’와 동일합니다. 쉼표와 두 숫자 사이에는 공백이 있어서는 안 됩니다. |
? | 문자가 다른 제한자(*, +, ?, {n}, {n,}, {n,m}) 바로 뒤에 오면 일치 패턴은 탐욕스럽지 않습니다. Non-greedy 모드는 검색된 문자열을 최대한 적게 일치시키는 반면, 기본 Greedy 모드는 검색된 문자열을 최대한 많이 일치시킵니다. 예를 들어, 문자열 "oooo"의 경우 ‘o+?’는 단일 "o"와 일치하고 ‘o+’는 모든 ‘o’와 일치합니다. |
. | 은 개행(n, r)을 제외한 모든 단일 문자와 일치합니다. ‘n’을 포함한 모든 문자를 일치시키려면 "(. |
x|y | 와 같은 것을 사용하여 x 또는 y와 일치시키십시오. 예를 들어 'z |
[xyz] | 문자 세트와 일치하십시오. 예를 들어 ‘[abc]’는 "plain"에서 ‘a’와 일치할 수 있습니다. |
[^xyz] | 는 모든 음수 문자와 일치합니다. ’는 "plain"의 ’p’, ‘i’, ‘n’과 일치할 수 있습니다. 예를 들어 ‘[a-z]’ ‘a’부터 ‘z’ |
[^a-z] | 지정된 범위에 없는 모든 문자와 일치합니다. 예를 들어 ‘[^a-z]’ |
b | 범위는 단어 경계와 일치합니다. 예를 들어 ‘erb’ ; "never"에서는 |
이 아닙니다. "erB"는 "verb"에서 "er"와 일치하지 않습니다. cx | 는 x로 지정된 제어 문자와 일치합니다. 예를 들어, cM은 Control-M 또는 캐리지 리턴 문자와 일치합니다. x의 값은 A-Z 또는 a-z 중 하나여야 합니다. 그렇지 않으면 c는 리터럴 ‘c’ |
d | 은 [0-9]와 동일합니다. |
D | 은 x0c 및 cJ와 동일합니다. x0d 및 cM과 동일합니다. 공백, 탭, 양식 피드 등을 포함합니다. |
S | 과 동일합니다. 공백이 아닌 문자와 일치합니다. [^ fnrtv]와 동일합니다. |
t | 은 탭 문자와 일치합니다. x09 및 cI와 동일합니다. |
v | 은 세로 탭 문자와 일치합니다. x0b 및 cK와 동일합니다. |
w | 문자, 숫자, 밑줄을 일치시킵니다. '[A-Za-z0-9_]'와 동일합니다. |
W | 문자가 아닌 숫자, 밑줄과 일치합니다. ‘[^A-Za-z0-9_]’와 동일합니다. |
xn | 은 n과 일치합니다. 여기서 n은 16진수 이스케이프 값입니다. 16진수 이스케이프 값은 정확히 두 자리 길이여야 합니다. 예를 들어 ‘x41’은 "A"와 일치합니다. ‘x041’은 ‘x04’正则表达式中可以使用 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 匹配版权符号 (?)。 |
指定要匹配的特定字符集。 字符类元字符序列将匹配该类中包含的任何单个字符。
# 元字符序列[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='bar'> >>> re.search('ba[artz]', 'foobazqux') <_sre.SRE_Match object; span=(3, 6), match='baz'>
匹配和[a-z]之间的任何小写字母字符。
>>> re.search('[a-z]', 'FOObar') <_sre.SRE_Match object; span=(3, 4), match='b'>
匹配和[0-9]之间任何数字字符。
>>> re.search('[0-9][0-9]', 'foo123bar') <_sre.SRE_Match object; span=(3, 5), match='12'>
[0-9a-fA-F]匹配任何十六进制数字字符。
>>> re.search('[0-9a-fA-f]', '--- a0 ---') <_sre.SRE_Match object; span=(4, 5), match='a'>
[^0-9]匹配任何不是数字的字符开头的字符。
>>> re.search('[^0-9]', '12345foo') <_sre.SRE_Match object; span=(5, 6), match='f'>
如果一个^字符出现在字符类中但不是第一个字符则无结果。
>>> re.search('[#:^]', 'foo^bar:baz#qux') <_sre.SRE_Match object; span=(3, 4), match='^'>
可以通过用连字符分隔字符来指定字符类中的字符范围,可以将其作为第一个或最后一个字符放置,或者使用反斜杠 ( \ ) 对其进行转义。
# 直接查找符号 >>> 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='-'> # 查找转义符号 >>> 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=']'> # [ ] 内的元字符失去意义转义成字符处理 >>> re.search('[)*+|]', '123*456') <_sre.SRE_Match object; span=(3, 4), match='*'> >>> re.search('[)*+|]', '123+456') <_sre.SRE_Match object; span=(3, 4), match='+'>
匹配除换行符以外的任何单个字符。
>>> 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 等于 [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匹配任何十进制数字字符,等价于[0-9]。
>>> re.search('\d', 'abc4def') <_sre.SRE_Match object; span=(3, 4), match='4'>
\D匹配任何不是十进制数字的字符,等价于[^0-9]。
>>> re.search('\D', '234Q678') <_sre.SRE_Match object; span=(3, 4), match='Q'>
\s匹配任何空白字符,同时也匹配换行符。
>>> 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也可以出现在方括号字符类中。
# [\d\w\s]匹配任何数字、单词或空白字符 >>> 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=' '>
反斜杠会删除元字符的特殊含义。
>>> 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='\\'>
不匹配搜索字符串中的任何实际字符,并且在解析期间它们不使用任何搜索字符串。指示搜索字符串中必须发生匹配的特定位置。
^ 和 \A 字符串的开头匹配项
>>> 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
>>> 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 # 特殊$也在搜索字符串末尾的单个换行符之前匹配 >>> re.search('bar$', 'foobar\n') <_sre.SRE_Match object; span=(3, 6), match='bar'>
\b 必须在单词的开头或结尾。
# 单词开头 >>> 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 # 单词结尾 >>> 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 不能在单词的开头或结尾。
>>> 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'>
该部分必须出现多少次才能使匹配成功。
>>> 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个字符中全部的内容。
>>> re.search('foo.*bar', '# foo jklasajk#*(@ bar #') <_sre.SRE_Match object; span=(2, 22), match='foo jklasajk#*(@ bar'>
>>> 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'>
>>> 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
加问号则表示为最小长度匹配的懒惰模式。
### + 和 +? 代替了 * 和 *? # .*全匹配贪婪模式 >>> re.search('<.*>', '%<foo> <bar> <baz>%') <_sre.SRE_Match object; span=(1, 18), match='<foo> <bar> <baz>'> # *? 前一个字符0次或无限次扩展,最小匹配 >>> re.search('<.*?>', '%<foo> <bar> <baz>%') <_sre.SRE_Match object; span=(1, 6), match='<foo>'> # .+ 前一个字符1次或无限次扩展,最小匹配 >>> re.search('<.+>', '%<foo> <bar> <baz>%') <_sre.SRE_Match object; span=(1, 18), match='<foo> <bar> <baz>'> # .+? 前一个字符1次或无限次扩展,最小匹配 >>> 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'> # ?? 前一个字符0次或1次扩展,最小匹配 >>> re.search('ba??', 'baaaa') <_sre.SRE_Match object; span=(0, 1), match='b'>
>>> 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
>>> 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
正则表达式 | 匹配说明 | 相同语法 |
---|---|---|
< 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='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}。
>>> 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'>
分组构造将 Python 中的正则表达式分解为子表达式或组。
分组:一个组代表一个单一的句法实体。附加元字符作为一个单元应用于整个组。
捕获:一些分组结构还捕获与组中的子表达式匹配的搜索字符串部分。可以通过几种不同的机制检索捕获的匹配项。
(
# 括号中的正则表达式仅匹配括号的内容 >>> 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'>
组后面的量词元字符对组中指定的整个子表达式作为一个单元进行操作。
# 元字符+仅适用于字符'r','ba'随后出现一次或多次'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'>
正则表达式 | 解释 | 匹配说明 | 例子 |
---|---|---|---|
bar+ | 元字符+仅适用于字符’r’。 | ‘ba’随后出现一次或多次’r’ | bar、barr、barrr等 |
(bar)+ | 元字符+适用于整个字符串’bar’。 | 出现一次或多次’bar’ | bar、barbar、barbarbar |
返回一个元组,其中包含从正则表达式匹配中捕获的所有组。
>>> 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 = 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 = 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')
>>> 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
>>> 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')
>>> 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'
>>> 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='###foobar'> # 搜索字符串'###foobaz'确实以 开头'###',因此解析器创建了一个编号为 的组1。然后条件匹配是反对'bar',不匹配。 >>> print(re.search(regex, '###foobaz')) None # 搜索字符串'foobar'不以 开头'###',因此没有编号为 的组1。然后条件匹配是反对'baz',不匹配。 >>> print(re.search(regex, 'foobar')) None # 搜索字符串'foobaz'不以 开头'###',因此没有编号为 的组1。然后条件匹配是针对'baz'匹配的。 >>> re.search(regex, 'foobaz') <_sre.SRE_Match object; span=(0, 6), match='foobaz'>
根据解析器在搜索字符串中当前位置的后面(左侧)或前面(右侧)来确定 Python 中正则表达式匹配的成功或失败。积极前瞻断言可表示为:(?=lookahead_regex)
# 断言正则表达式解析器当前位置之后的内容必须匹配 # 前瞻断言(?=[a-z])指定后面的'foo'必须是小写字母字符。 >>> re.search('foo(?=[a-z])', 'foobar') <_sre.SRE_Match object; span=(0, 3), match='foo'> # 前瞻失败的例子,foo的下一个字符是'1' >>> print(re.search('foo(?=[a-z])', 'foo123')) None # 前瞻的独特之处<lookahead_regex>在于不消耗搜索字符串中匹配的部分,并且它不是返回的匹配对象的一部分。 >>> re.search('foo(?=[a-z])', 'foobar') <_sre.SRE_Match object; span=(0, 3), match='foo'> # 举例对比观察,?=断言的区别 >>> 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'
# 例子和之前的前瞻积极断言相反 >>> 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'>
# 断言正则表达式解析器当前位置之前的内容匹配 # 断言指定'foo'必须先于'bar' >>> re.search('(?<=foo)bar', 'foobar') <_sre.SRE_Match object; span=(3, 6), match='bar'> >>> print(re.search('(?<=qux)bar', 'foobar')) None
# 例子和之前的向后积极断言相反 >>> print(re.search('(?<!foo)bar', 'foobar')) None >>> re.search('(?<!qux)bar', 'foobar') <_sre.SRE_Match object; span=(3, 6), match='bar'>
# 正则表达式解析器忽略(?#...)序列中包含的任何内容 >>> re.search('bar(?#This is a comment) *baz', 'foo bar baz qux') <_sre.SRE_Match object; span=(4, 11), match='bar baz'>
# 形式的表达式最多匹配一个指定的表达式:<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 # 结合交替、分组和任何其他元字符来实现您需要的任何复杂程度。 # (foo|bar|baz)+表示一个或多个字符串 >>> 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]+)表示一个或多个十进制数字字符的序列或一个或多个'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'>
위 내용은 Python에서 re 모듈의 메타 문자를 사용하는 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!