Lookahead 和 Lookbehind 断言

Lookahead 和 lookbehind 断言根据解析器在搜索字符串中的当前位置的后面（左侧）或前面（右侧）的内容来确定 Python 中正则表达式匹配的成功或失败。

lookahead 和 lookbehind 断言是零宽度断言，因此它们不会占用任何搜索字符串。此外，即使它们包含括号并执行分组，它们也不会捕获它们匹配的内容

(?=<lookahead_regex>)

• 创建积极的前瞻断言。
• (?=<lookahead_regex>)断言正则表达式解析器当前位置后面的内容必须匹配：<lookahead_regex>

下面的例子

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

lookahead 断言指定后面的内容必须是小写字母字符。在本例中，它是字符 ，因此找到了匹配项。(?=[a-z])'foo''b'

调整一下要查找的字符串foo123中foo后面的是数字。

不是字母因此不符合表达式的匹配规则。

>>> print(re.search('foo(?=[a-z])', 'foo123'))
None

加减再看一下这种匹配，你会发现，他只是告诉你这个字符串满足这个要求，但是并没有真正的实现匹配分组

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

使用之前我们学过的知识，可以看到下面这种传统的写法可以把数据匹配成功

>>> re.search('foo([a-z])', 'foobar')
<_sre.SRE_Match object; span=(0, 4), match='foob'>

分析一下断言与传统正则表达式的差异

>>> m = re.search('foo(?=[a-z])(?P<ch>.)', 'foobar')
>>> m.group('ch')
 

>>> m = re.search('foo([a-z])(?P<ch>.)', 'foobar')
>>> m.group('ch')
 

1. 正则表达式的第一部分 ，与搜索字符串 匹配并使用。foo'foo''foobar'
2. 下一部分 ， 是匹配的 lookahead，但解析器不会前进到 。(?=[a-z])'b''b'
3. 最后，匹配下一个可用的单个字符，即 ，并在名为 的组中捕获它。(?P<ch>.)'b'ch

m.group('ch')

(?P<ch>.)它表明最后的分组匹配中可以通过 m.group('ch')这个key取到对应的值，之前使用group时通常是用的索引如 m.group('0)，这样其实就是给匹配的分组取了一个名字

Lookahead 和 Lookbehind 断言

Lookahead 和 lookbehind 断言根据解析器在搜索字符串中的当前位置的后面（左侧）或前面（右侧）的内容来确定 Python 中正则表达式匹配的成功或失败。

与锚点一样，lookahead 和 lookbehind 断言是零宽度断言，因此它们不会占用任何搜索字符串。此外，即使它们包含括号并执行分组，它们也不会捕获它们匹配的内容。

(?=<lookahead_regex>)

创建积极的前瞻断言。

(?=<lookahead_regex>)断言正则表达式解析器当前位置后面的内容必须匹配：<lookahead_regex>

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

lookahead 断言指定后面的内容必须是小写字母字符。在本例中，它是字符 ，因此找到了匹配项。(?=[a-z])'foo''b'

后面的下一个字符是 数字，所以没有匹配项：

>>> print(re.search('foo(?=[a-z])', 'foo123'))
None

lookahead 的独特之处在于，搜索字符串中匹配的部分不会被使用，并且它不是返回的 match 对象的一部分。<lookahead_regex>

再看第一个例子：

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

正则表达式解析器只向前看后面的内容，但尚未传递它。您可以判断这不被视为匹配的一部分，因为匹配对象显示 。'b''foo''b'match='foo'

将其与使用分组括号而不进行展望的类似示例进行比较：

>>> re.search('foo([a-z])', 'foobar')
<_sre.SRE_Match object; span=(0, 4), match='foob'>

这次则表达式使用 ，它成为最终匹配的一部分。'b'

下面是另一个示例，说明了断言与 Python 中的传统正则表达式有何不同：

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

在第一次搜索中，在第 1 行，解析器按如下方式进行：

1. 正则表达式的第一部分 ，与搜索字符串 匹配并使用。foo'foo''foobar'
2. 下一部分 ， 是匹配的 lookahead，但解析器不会前进到 。(?=[a-z])'b''b'
3. 最后，匹配下一个可用的单个字符，即 ，并在名为 的组中捕获它。(?P<ch>.)'b'ch

调用确认名为 的组包含 。m.group('ch')ch'b'

上面的匹配规则如下：

1. 与第一个示例一样，正则表达式的第一部分 ， 匹配并使用搜索字符串 。foo'foo''foobar'
2. 下一部分 ， 匹配并消耗 ，解析器前进到 。([a-z])'b''b'
3. 最后，匹配下一个可用的单个字符，即现在的 .(?P<ch>.)'a'

• m.group('ch')确认在本例中，名为 的组包含 。ch'a'
• (?!<lookahead_regex>)

(?!<lookahead_regex>)

当前位置后面的内容不得匹配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

foo(?=[a-z])当前位置后面是字母

foo(?![a-z])当前位置后面不是字母

(?<=<lookbehind_regex>) 当前位置之前的内容必须匹配

(?<=<lookbehind_regex>)断言正则表达式 当前位置之前的内容必须匹配。

在以下示例中，lookbehind 断言指定必须在 ：'foo''bar'

>>> re.search('(?<=foo)bar', 'foobar')
<_sre.SRE_Match object; span=(3, 6), match='bar'>

下面这种情况则不符合断言条件，所以没有匹配成功

quxbar这种字符串才满足要求

>>> print(re.search('(?<=qux)bar', 'foobar'))
None

但是要注意这种断言不能出现长度不确定的情况 a+是表示至少一个或者多个长度不定

>>> re.search('(?<=a+)def', 'aaadef')

  File "C:\Python36\lib\sre_compile.py", line 160, in _compile
    raise error("look-behind requires fixed-width pattern")
sre_constants.error: look-behind requires fixed-width patter

指定长度是能满足的{m}

>>> re.search('(?<=a{3})def', 'aaadef')
<_sre.SRE_Match object; span=(3, 6), match='def'>

向前匹配断言的反操作 (?<!<lookbehind_regex>)

(?<!<lookbehind_regex>)断言正则表达式 当前位置之前的内容必须不匹配

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

有点像Pythont程序中的条件表达式 a or b or c 只要其中一个满眼匹配规则 即可

将匹配 任何一个。您可以使用 分隔任意数量的正则表达式。foo|bar|baz'foo''bar''baz'|

>>> re.search('foo', 'foograult')
<_sre.SRE_Match object; span=(0, 3), match='foo'>
  
>>> re.search('grault', 'foograult')
<_sre.SRE_Match object; span=(3, 9), match='grault'>

>>> re.search('foo|grault', 'foograult')
<_sre.SRE_Match object; span=(0, 3), match='foo'>

管理也可以与题词结合

表示一个或多个字符串 、 或 的序列：(foo|bar|baz)+'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'>

正则表达式的标志位

支持的正则表达式标志

除短的单字母名称和较长的全字名称外，所有标志都具有：re.DEBUG

未完待续

标志如何影响匹配行为？