环视断言

  • 环视断言 = look around (assertion)
    • 包括
      • look ahead (assertion)=正向断言
        • positive lookahead assertion ：(?=xxx)
        • negative lookahead assertion ：(?!xxx)
      • look behind (assertion)=反向断言
        • positive lookbehind assertion：(?<=xxx)
        • negative lookbehind assertion：(?<!xxx)

如果觉得look ahead和look behind很费解的话，看这个图，就容易懂了：

python_look_ahead_and_look_behind

总体就2个逻辑：

  • 站在 当前所要匹配的内容
    • 往哪看
      • ahead：向前 向右 ➡️ 当前字符串继续往后的方向
        • 从左到右 叫做 向前，属于正向
      • behind：向左 ◀️ 向后 ⬅️ 当前字符串之前的方向
        • 所以会额外加上一个 <小于号 表示向后看的意思
          • (?<=xxx)
          • (?<!xxx)
    • positive/negative：
      • positive=正面的，肯定的，用 等于号=，意思是：=xxx
      • negative=负面的，否定的，用 不等于号!，意思是：!=xxx

==》因此推导出：

  • positive lookahead assertion：(?=xxx)
  • negative lookahead assertion：(?!xxx)
  • positive lookbehind assertion： (?<=xxx)
  • negative lookbehind assertion：(?<!xxx)

官网文档：

  1. (...)
  2.     Matches whatever regular expression is inside the parentheses, and indicates the start and end of a group;
  3.     the contents of a group can be retrieved after a match has been performed,
  4.     and can be matched later in the string with the \number special sequence, described below.
  5.     To match the literals '(' or ')', use \( or \), or enclose them inside a character class: [(], [)].
  8. (?=...)
  9.     Matches if ... matches next, but doesn’t consume any of the string.
  10.     This is called a lookahead assertion.
  11.     For example, Isaac (?=Asimov) will match 'Isaac ' only if it’s followed by 'Asimov'.
  14. (?!...)
  15.     Matches if ... doesn’t match next.
  16.     This is a negative lookahead assertion.
  17.     For example, Isaac (?!Asimov) will match 'Isaac ' only if it’s not followed by 'Asimov'.
  20. (?<=...)
  21.     Matches if the current position in the string is preceded by a match for ... that ends at the current position.
  22.     This is called a positive lookbehind assertion.
  23.     (?<=abc)def will find a match in 'abcdef', since the lookbehind will back up 3 characters and check if the contained pattern matches.
  24.     The contained pattern must only match strings of some fixed length, meaning that abc or a|b are allowed, but a* and a{3,4} are not.
  25.     Note that patterns which start with positive lookbehind assertions will not match at the beginning of the string being searched;
  28. (?<!...)
  29.     Matches if the current position in the string is not preceded by a match for ....
  30.     This is called a negative lookbehind assertion.
  31.     Similar to positive lookbehind assertions, the contained pattern must only match strings of some fixed length.
  32.     Patterns which start with negative lookbehind assertions may match at the beginning of the string being searched.

代码详细解释：

  1. #!/usr/bin/python
  2. # -*- coding: utf-8 -*-
  3. # Author: Crifan Li
  4. # Update: 20191224
  5. # Function: Demo python re lookahead and lookbehind group
  7. import re
  9. def demoReLookAheadBehind():
  10.     inputStrList = [
  11.         "date=20191224&name=CrifanLi&language=python",
  12.         "language=python&name=CrifanLi&date=20191224", # lookahead will NOT match
  13.         "language=python&name=CrifanLi date=20191224", # negative lookahead CAN match, the whole 'name=CrifanLi'
  14.         "language=go&name=CrifanLi date=20191224", # positive lookbehind CAN match
  15.         "language=go name=CrifanLi date=20191224", # negative lookbehind CAN match
  16.     ]
  18.     groupNormalPattern = "name=(\w+)" # 匹配任何 name=XXX 其中XXX是字母数字下划线均可
  19.     groupLookaheadPattern = "name=(\w+)(?=&language)" # 只匹配后面 是&language 的情况
  20.     groupNegativelookaheadPattern = "name=(\w+)(?!&)" # 只匹配后面 不是& 的情况
  21.     groupPositivelookbehindPattern = "(?<=go&)name=(\w+)" # 只匹配前面 是go& 的情况
  22.     groupNegativelookbehindPattern = "(?<!&)name=(\w+)" # 只匹配前面 不是& 的情况
  24.     for curIdx, eachInputStr in enumerate(inputStrList):
  25.         print("\n%s [%d] %s %s" % ("="*20, curIdx, eachInputStr, "="*20))
  27.         print("%s %s %s" % ("-"*10, "normal group", "-"*10))
  28.         foundGroupNormal = re.search(groupNormalPattern, eachInputStr)
  29.         print("foundGroupNormal=%s" % foundGroupNormal)
  30.         if foundGroupNormal:
  31.             wholeMatchStrNormal = foundGroupNormal.group(0)
  32.             print("wholeMatchStrNormal=%s" % wholeMatchStrNormal)
  33.             matchedGroupsNormal = foundGroupNormal.groups()
  34.             print("matchedGroupsNormal=%s" % (matchedGroupsNormal, ))
  35.             foundName = foundGroupNormal.group(1)
  36.             print("foundName=%s" % foundName)
  38.         print("%s %s %s" % ("-"*10, "lookahead group", "-"*10))
  39.         foundGroupLookahead = re.search(groupLookaheadPattern, eachInputStr)
  40.         print("foundGroupLookahead=%s" % foundGroupLookahead)
  41.         if foundGroupLookahead:
  42.             wholeMatchStrLookahead = foundGroupLookahead.group(0)
  43.             print("wholeMatchStrLookahead=%s" % wholeMatchStrLookahead)
  44.             matchedGroupsLookahead = foundGroupLookahead.groups()
  45.             print("matchedGroupsLookahead=%s" % (matchedGroupsLookahead, ))
  46.             foundName = foundGroupLookahead.group(1)
  47.             print("foundName=%s" % foundName)
  49.         print("%s %s %s" % ("-"*10, "negative lookahead group", "-"*10))
  50.         foundGroupNegativelookahead = re.search(groupNegativelookaheadPattern, eachInputStr)
  51.         print("foundGroupNegativelookahead=%s" % foundGroupNegativelookahead)
  52.         if foundGroupNegativelookahead:
  53.             wholeMatchStrNegativelookahead = foundGroupNegativelookahead.group(0)
  54.             print("wholeMatchStrNegativelookahead=%s" % wholeMatchStrNegativelookahead)
  55.             matchedGroupsNegativelookahead = foundGroupNegativelookahead.groups()
  56.             print("matchedGroupsNegativelookahead=%s" % (matchedGroupsNegativelookahead, ))
  57.             foundName = foundGroupNegativelookahead.group(1)
  58.             print("foundName=%s" % foundName)
  60.         print("%s %s %s" % ("-"*10, "positive lookahead group", "-"*10))
  61.         foundGroupPositivelookbehind = re.search(groupPositivelookbehindPattern, eachInputStr)
  62.         print("foundGroupPositivelookbehind=%s" % foundGroupPositivelookbehind)
  63.         if foundGroupPositivelookbehind:
  64.             wholeMatchStrPositivelookbehind = foundGroupPositivelookbehind.group(0)
  65.             print("wholeMatchStrPositivelookbehind=%s" % wholeMatchStrPositivelookbehind)
  66.             matchedGroupsPositivelookbehind = foundGroupPositivelookbehind.groups()
  67.             print("matchedGroupsPositivelookbehind=%s" % (matchedGroupsPositivelookbehind, ))
  68.             foundName = foundGroupPositivelookbehind.group(1)
  69.             print("foundName=%s" % foundName)
  71.         print("%s %s %s" % ("-"*10, "positive lookahead group", "-"*10))
  72.         foundGroupNegativelookbehind = re.search(groupNegativelookbehindPattern, eachInputStr)
  73.         print("foundGroupNegativelookbehind=%s" % foundGroupNegativelookbehind)
  74.         if foundGroupNegativelookbehind:
  75.             wholeMatchStrNegativelookbehind = foundGroupNegativelookbehind.group(0)
  76.             print("wholeMatchStrNegativelookbehind=%s" % wholeMatchStrNegativelookbehind)
  77.             matchedGroupsNegativelookbehind = foundGroupNegativelookbehind.groups()
  78.             print("matchedGroupsNegativelookbehind=%s" % (matchedGroupsNegativelookbehind, ))
  79.             foundName = foundGroupNegativelookbehind.group(1)
  80.             print("foundName=%s" % foundName)
  82.     # ==================== [0] date=20191224&name=CrifanLi&language=python ====================
  83.     # ---------- normal group ----------
  84.     # foundGroupNormal=<re.Match object; span=(14, 27), match='name=CrifanLi'>
  85.     # wholeMatchStrNormal=name=CrifanLi
  86.     # matchedGroupsNormal=('CrifanLi',)
  87.     # foundName=CrifanLi
  88.     # ---------- lookahead group ----------
  89.     # foundGroupLookahead=<re.Match object; span=(14, 27), match='name=CrifanLi'>
  90.     # wholeMatchStrLookahead=name=CrifanLi
  91.     # matchedGroupsLookahead=('CrifanLi',)
  92.     # foundName=CrifanLi
  93.     # ---------- negative lookahead group ----------
  94.     # foundGroupNegativelookahead=<re.Match object; span=(14, 26), match='name=CrifanL'>
  95.     # wholeMatchStrNegativelookahead=name=CrifanL
  96.     # matchedGroupsNegativelookahead=('CrifanL',)
  97.     # foundName=CrifanL
  98.     # ---------- positive lookahead group ----------
  99.     # foundGroupPositivelookbehind=None
  100.     # ---------- positive lookahead group ----------
  101.     # foundGroupNegativelookbehind=None
  103.     # ==================== [1] language=python&name=CrifanLi&date=20191224 ====================
  104.     # ---------- normal group ----------
  105.     # foundGroupNormal=<re.Match object; span=(16, 29), match='name=CrifanLi'>
  106.     # wholeMatchStrNormal=name=CrifanLi
  107.     # matchedGroupsNormal=('CrifanLi',)
  108.     # foundName=CrifanLi
  109.     # ---------- lookahead group ----------
  110.     # foundGroupLookahead=None
  111.     # ---------- negative lookahead group ----------
  112.     # foundGroupNegativelookahead=<re.Match object; span=(16, 28), match='name=CrifanL'>
  113.     # wholeMatchStrNegativelookahead=name=CrifanL
  114.     # matchedGroupsNegativelookahead=('CrifanL',)
  115.     # foundName=CrifanL
  116.     # ---------- positive lookahead group ----------
  117.     # foundGroupPositivelookbehind=None
  118.     # ---------- positive lookahead group ----------
  119.     # foundGroupNegativelookbehind=None
  121.     # ==================== [2] language=python&name=CrifanLi date=20191224 ====================
  122.     # ---------- normal group ----------
  123.     # foundGroupNormal=<re.Match object; span=(16, 29), match='name=CrifanLi'>
  124.     # wholeMatchStrNormal=name=CrifanLi
  125.     # matchedGroupsNormal=('CrifanLi',)
  126.     # foundName=CrifanLi
  127.     # ---------- lookahead group ----------
  128.     # foundGroupLookahead=None
  129.     # ---------- negative lookahead group ----------
  130.     # foundGroupNegativelookahead=<re.Match object; span=(16, 29), match='name=CrifanLi'>
  131.     # wholeMatchStrNegativelookahead=name=CrifanLi
  132.     # matchedGroupsNegativelookahead=('CrifanLi',)
  133.     # foundName=CrifanLi
  134.     # ---------- positive lookahead group ----------
  135.     # foundGroupPositivelookbehind=None
  136.     # ---------- positive lookahead group ----------
  137.     # foundGroupNegativelookbehind=None
  139.     # ==================== [3] language=go&name=CrifanLi date=20191224 ====================
  140.     # ---------- normal group ----------
  141.     # foundGroupNormal=<re.Match object; span=(12, 25), match='name=CrifanLi'>
  142.     # wholeMatchStrNormal=name=CrifanLi
  143.     # matchedGroupsNormal=('CrifanLi',)
  144.     # foundName=CrifanLi
  145.     # ---------- lookahead group ----------
  146.     # foundGroupLookahead=None
  147.     # ---------- negative lookahead group ----------
  148.     # foundGroupNegativelookahead=<re.Match object; span=(12, 25), match='name=CrifanLi'>
  149.     # wholeMatchStrNegativelookahead=name=CrifanLi
  150.     # matchedGroupsNegativelookahead=('CrifanLi',)
  151.     # foundName=CrifanLi
  152.     # ---------- positive lookahead group ----------
  153.     # foundGroupPositivelookbehind=<re.Match object; span=(12, 25), match='name=CrifanLi'>
  154.     # wholeMatchStrPositivelookbehind=name=CrifanLi
  155.     # matchedGroupsPositivelookbehind=('CrifanLi',)
  156.     # foundName=CrifanLi
  157.     # ---------- positive lookahead group ----------
  158.     # foundGroupNegativelookbehind=None
  160.     # ==================== [4] language=go name=CrifanLi date=20191224 ====================
  161.     # ---------- normal group ----------
  162.     # foundGroupNormal=<re.Match object; span=(12, 25), match='name=CrifanLi'>
  163.     # wholeMatchStrNormal=name=CrifanLi
  164.     # matchedGroupsNormal=('CrifanLi',)
  165.     # foundName=CrifanLi
  166.     # ---------- lookahead group ----------
  167.     # foundGroupLookahead=None
  168.     # ---------- negative lookahead group ----------
  169.     # foundGroupNegativelookahead=<re.Match object; span=(12, 25), match='name=CrifanLi'>
  170.     # wholeMatchStrNegativelookahead=name=CrifanLi
  171.     # matchedGroupsNegativelookahead=('CrifanLi',)
  172.     # foundName=CrifanLi
  173.     # ---------- positive lookahead group ----------
  174.     # foundGroupPositivelookbehind=None
  175.     # ---------- positive lookahead group ----------
  176.     # foundGroupNegativelookbehind=<re.Match object; span=(12, 25), match='name=CrifanLi'>
  177.     # wholeMatchStrNegativelookbehind=name=CrifanLi
  178.     # matchedGroupsNegativelookbehind=('CrifanLi',)
  179.     # foundName=CrifanLi
  181. if __name__ == "__main__":
  182.     demoReLookAheadBehind()

对于代码中的结果，总结起来就是：

  • name=(\w+)：普通的group
    • 匹配结果
      • 5个都匹配
        • date=20191224&name=CrifanLi&language=python
        • language=python&name=CrifanLi&date=20191224
        • language=python&name=CrifanLi date=20191224
        • language=go&name=CrifanLi date=20191224
        • language=go name=CrifanLi date=20191224
      • 匹配到内容都是：
        • name=CrifanLi
    • 解析：因为只是普通的(xxx)的组，没有限制，所以都能匹配到
  • name=(\w+)(?=&language)：lookahead=positive lookahead=正向先行断言
    • 匹配结果
      • 只匹配了1个：
        • date=20191224&name=CrifanLi&language=python
      • 其余4个都不匹配
        • language=python&name=CrifanLi&date=20191224
        • language=python&name=CrifanLi date=20191224
        • language=go&name=CrifanLi date=20191224
        • language=go name=CrifanLi date=20191224
    • 解析：
      • (?=&language) 表示 后面一定是 &language
        • 而上面4个的后面，分别是：
          • &date=
          • date=
          • date=
          • date=
        • 所以都不匹配
  • name=(\w+)(?!&)：negative look ahead=负向先行断言
    • 匹配结果
      • 5个都匹配到了，但是匹配的内容不一样
        • 2个匹配到了：name=CrifanL
          • date=20191224&name=CrifanLi&language=python
          • language=python&name=CrifanLi&date=20191224
        • 3个匹配到了：name=CrifanLi
          • language=python&name=CrifanLi date=20191224
          • language=go&name=CrifanLi date=20191224
          • language=go name=CrifanLi date=20191224
    • 解析
      • 注意 前2个匹配到的 最后没有i，是CrifanL，而不是CrifanLi
      • 因为(?!&)表示 后面不能是 &
        • 所以类似于
          • name=CrifanLi&language
          • name=CrifanLi&date
        • 这种，只能匹配到L，而不是i，因为i后面是&，此处要求后面不能是&
  • (?<=go&)name=(\w+)：positive look behind=正向后行断言
    • 匹配结果
      • 只匹配到1个
        • language=go&name=CrifanLi date=20191224
    • 解析
      • 因为此处(?<=go&)意思是，前面一定要是 go& 所以只有这个匹配
      • 其他的
        • 20191224&name=
        • python&name=
        • python&name=
        • go name=
      • 中name=的前面 都不符合条件
  • (?<!&)name=(\w+)：negative look behind=负向后行断言
    • 匹配结果
      • 只匹配到1个：
        • language=go name=CrifanLi date=20191224
    • 解析
      • 因为(?<!&)的意思是：前面不能是 &
        • 所以只有
          • go name=
        • 这个符合，而其余的
          • 20191224&name=
          • python&name=
          • python&name=
          • go&name=
        • name=前面都是&，所以不符合条件，不匹配

（positive) look behind

官网解释：

  1. (?<=...)
  2.     Matches if the current position in the string is preceded by a match for ... that ends at the current position.
  3.     This is called a positive lookbehind assertion.
  4.     (?<=abc)def will find a match in 'abcdef', since the lookbehind will back up 3 characters and check if the contained pattern matches.
  5.     The contained pattern must only match strings of some fixed length, meaning that abc or a|b are allowed, but a* and a{3,4} are not.
  6.     Note that patterns which start with positive lookbehind assertions will not match at the beginning of the string being searched;
  8. (?P<name>...)
  9.     Similar to regular parentheses, but the substring matched by the group is accessible via the symbolic group name name.
  10.     Group names must be valid Python identifiers, and each group name must be defined only once within a regular expression.
  11.     A symbolic group is also a numbered group, just as if the group were not named.

用代码详细解释：

  1. #!/usr/bin/python
  2. # -*- coding: utf-8 -*-
  3. # Author: Crifan Li
  4. # Update: 20191224
  5. # Function: Demo python re lookbehind group
  7. import re
  9. def demoReLookbehind():
  10.     namedGroupPattern = "(SID=)(?P<sidValue>[^&]+)"
  11.     lookBehindGroupPattern = "(?<=SID=)(?P<sidValue>[^&]+)"
  12.     """
  13.     正则含义的解释：
  14.         (?<=SID=)[^&]+
  15.             (?<=SID=) 属于(?<=XXX)，其中XXX是"SID="这个固定长度的4个字符的字符串 用于匹配你要的值的前面的部分 SID=YYY中的 SID=
  16.             [^&]+
  17.                 [] 中括号中是所允许出现的字符
  18.                 ^ 是取反，除了...之外的，所以^&就是除了&字符之外的，因为你要匹配的字符串是
  19.                     SID=8E3qOreRiOnbhkl84Uc&YYY 可以避免匹配到 最后的&和YYY
  20.                 + 表示1个或更多个 直到遇到 不允许出现的&字符，匹配此处的 即从8到c，即8E3qOreRiOnbhkl84Uc
  21.     """
  23.     inputStrList = [
  24.         "GeneralSearch&SID=8E3qOreRiOnbhkl84Uc&preferencesSaved",
  25.     ]
  26.     for eachInputStr in inputStrList:
  27.         print("="*60)
  28.         foundNamedGroup = re.search(namedGroupPattern, eachInputStr)
  29.         foundLookbehindGroup = re.search(lookBehindGroupPattern, eachInputStr)
  30.         if foundNamedGroup and foundLookbehindGroup:
  31.             print("foundNamedGroup=%s" % foundNamedGroup)
  32.             print("foundLookbehindGroup=%s" % foundLookbehindGroup)
  34.             groupsNamedGroup = foundNamedGroup.groups()
  35.             print("groupsNamedGroup=%s" % (groupsNamedGroup, ))
  36.             groupsLookbehindGroup = foundLookbehindGroup.groups()
  37.             print("groupsLookbehindGroup=%s" % (groupsLookbehindGroup, ))
  39.             wholeStrNamedGroup = foundNamedGroup.group(0)
  40.             print("wholeStrNamedGroup=%s" % wholeStrNamedGroup)
  41.             wholeStrLookbehindGroup = foundLookbehindGroup.group(0)
  42.             print("wholeStrLookbehindGroup=%s" % wholeStrLookbehindGroup)
  44.             sidValueNamedGroup = foundNamedGroup.group("sidValue")
  45.             print("sidValueNamedGroup=%s" % sidValueNamedGroup)
  46.             sidValueLookbehindGroup = foundLookbehindGroup.group("sidValue")
  47.             print("sidValueLookbehindGroup=%s" % sidValueLookbehindGroup)
  49.     # foundNamedGroup=<re.Match object; span=(14, 37), match='SID=8E3qOreRiOnbhkl84Uc'>
  50.     # foundLookbehindGroup=<re.Match object; span=(18, 37), match='8E3qOreRiOnbhkl84Uc'>
  51.     # groupsNamedGroup=('SID=', '8E3qOreRiOnbhkl84Uc')
  52.     # groupsLookbehindGroup=('8E3qOreRiOnbhkl84Uc',)
  53.     # wholeStrNamedGroup=SID=8E3qOreRiOnbhkl84Uc
  54.     # wholeStrLookbehindGroup=8E3qOreRiOnbhkl84Uc
  55.     # sidValueNamedGroup=8E3qOreRiOnbhkl84Uc
  56.     # sidValueLookbehindGroup=8E3qOreRiOnbhkl84Uc
  58. if __name__ == "__main__":
  59.     demoReLookbehind()