正则匹配

正则表达式

：regular expression ，简称为 regex 。是一个描述字符串的文本模式，用于对其它字符串进行部分匹配。

• 不同软件采用的正则语法可能不同。常见的几种如下：
  • POSIX 风格：常用于类 Unix 系统上的老旧软件，又分为两种：
    • 基本正则（Basic Regular Expression ，BRE）
      • 速记字符集中，不支持 \d、\D 。
      • 限定符中，支持 * ，不支持 +、? 。
    • 扩展正则（Extended Regular Expression ，ERE）
      • 速记字符集中，不支持 \d、\D 。
      • GNU 支持的几种正则语法 (opens new window)
  • Perl 风格：更流行，语法较多，常用于 Perl、Python 等编程语言。
• 正则表达式包含的字符分为两大类：
  • 普通字符 ：指除元字符以外的其它字符。
    • 基本的正则引擎只支持 ASCII 字符，而 Python 的 re 模块支持 Unicode 字符。
  • 元字符：指在正则语法中具有特殊含义的字符。

普通字符

• 正则表达式中的普通字符包括字母、数字、下划线等，它们会与目标字符串中的字符直接匹配。
• 包括非打印字符，比如：

  \r      # 回车符
  \n      # 换行符
  \t      # 制表符
  \f      # 换页符
  

元字符

转义字符

• \ ：用于声明一个转义字符。
  • 如果将元字符声明为转义字符，则可以当作普通字符进行匹配。比如 \. 匹配普通字符 . ，\\ 匹配普通字符 \ 。
  • 在 Python 的 re 模块的正则表达式中，使用 \\\\ 才能匹配普通字符 \ 。如下：

    >>> re.findall('\t', '\t\\')
    ['\t']
    >>> re.findall('\\', '\t\\')
    re.error: bad escape (end of pattern) at position 0
    >>> re.findall('\\\\', '\t\\')
    ['\\']
    >>> re.findall(r'\\', '\t\\')   # 给字符串加上 r 前缀，将所有 \ 转义成 \\
    ['\\']
    

字符集

• [ ] ：用于声明字符集。

  • 一个字符集是任意个字符的无序集合，用于匹配目标字符串中，单个属于该字符集的字符。
  • 如果字符集开头为 ^ ，则表示反向匹配，即不匹配字符集中的字符。
  • 在字符集中，连字符 - 用于声明 ASCII 码连续的一串字符，比如 A-Z、0-9 。
    • 如果要匹配普通字符 - ，则要用转义字符 \- ，或者将 - 放在字符集开头或末尾，比如 [0-9-] 。
  • [ 和 ] 要转义之后才能当作普通字符进行匹配：

    >>> re.findall(r'\[hi\]', r'[hi]')
    ['[hi]']
    

    但是在字符集中，以下元字符不需要转义，就会当作普通字符进行匹配：

    >>> re.findall(r'[.|()^$*+?{}]', '[.|()[]^$*+?{}]')
    ['.', '|', '(', ')', '^', '$', '*', '+', '?', '{', '}']
    

  • 例：

    >>> re.findall(r'[0-9A-Za-z]', 'A1.')
    ['A', '1']
    >>> re.findall(r'[^0-9A-Za-z]', 'A1.')
    ['.']
    

• 正则表达式中， . 是一个通配符，可以匹配单个任意字符，默认不包括换行符 \n 。

• 正则表达式中，以下转义字符被定义为速记字符集：

  \d      # 匹配一个数字，相当于 [0-9]
  \D      # 匹配一个非数字，相当于 [^0-9]
  \w      # 匹配一个字母、数字、下划线，相当于 [0-9A-Za-z_]
  \W      # 匹配一个不匹配 \w 的字符
  \s      # 匹配一个空白字符，相当于 [ \t\n\r\f\v]
  \S      # 匹配一个非空白字符
  

  • 例：

    >>> re.findall(r'\d', 'ab12#你好》')
    ['1', '2']
    >>> re.findall(r'\D', 'ab12#你好》')
    ['a', 'b', '#', '你', '好', '》']
    >>> re.findall(r'\w', 'ab12#你好》')
    ['a', 'b', '1', '2', '你', '好']
    >>> re.findall(r'\W', 'ab12#你好》')  # 使用 Python 的 re 模块时，\w 匹配所有归类为字母的 Unicode 字符，包括单个汉字，但不包括中文的标点符号
    ['#', '》']
    

字符组

• ( ) ：用于在正则表达式中声明子表达式，又称为字符组。

  • 支持嵌套。
  • 字符组可以用于从正则匹配的结果中，提取子字符串。如下：

    >>> re.findall(r'(A)BC', 'ABC')     # 声明了字符组时，只返回该字符组的匹配结果，而不是整个正则表达式的匹配结果
    ['A']
    >>> re.findall(r'((A)B)C', 'ABC')   # 声明了多个字符组时，依次返回其匹配结果
    [('AB', 'A')]
    

• (? ) ：字符组的扩展语法，常见的几种如下：

  • (?P<name> ) ：给该字符组命名。

    >>> re.findall(r'(?P<id>(A)B)C', 'ABC')
    [('AB', 'A')]
    

    正则匹配时，没必要定义组名。而正则替换时，可以通过字符组的名称或编号，引用其提取的子字符串。编号从 1 开始递增。如下：

    >>> re.sub(r'(?P<id>(A)B)C', r'\g<ID>', 'ABC')  # 组名区分大小写，如果引用不存在的组名则会报错
    IndexError: unknown group name 'ID'
    >>> re.sub(r'(?P<id>(A)B)C', r'\g<id>', 'ABC')
    'AB'
    >>> re.sub(r'(?P<id>(A)B)C', r'\g<1>', 'ABC')
    'AB'
    >>> re.sub(r'(?P<id>(A)B)C', r'\1', 'ABC')
    'AB'
    

  • (?# ) ：将该字符组视作注释，可以忽略。

    >>> re.findall(r'(?#test)ABC', 'ABC')
    ['ABC']
    

  • (?: ) ：让括号表达式生效，但不捕获字符组。

    >>> re.sub(r'((A)B)C', r'\1', 'ABC')    # 匹配结果中，第一个组是 AB
    'AB'
    >>> re.sub(r'(?:(A)B)C', r'\1', 'ABC')  # 匹配结果中，第一个组是 A
    'A'
    

  • (?= ) ：前置断言。如果该字符组匹配当前位置之后的目标字符串，才继续匹配后续的正则表达式。匹配结果中不会包含断言的字符组。

    >>> re.findall(r'^(?=A)\w+', 'ABC')
    ['ABC']
    >>> re.findall(r'^(?=AA)\w+', 'ABC')
    []
    

  • (?! ) ：否定的前置断言。如果该字符组匹配当前位置之后的目标字符串，则不继续匹配后续的正则表达式。

    >>> re.findall(r'^(?!A)\w+', 'ABC')
    []
    >>> re.findall(r'^(?!AA)\w+', 'ABC')
    ['ABC']
    

  • (?<= ) ：后置断言。如果该字符组匹配当前位置之前的目标字符串，才继续匹配后续的正则表达式。

    >>> re.findall(r'A(?<=A)\w+', 'ABC')
    ['ABC']
    >>>
    >>> re.findall(r'A(?<=AB)\w+', 'ABC')
    []
    

  • (?<! ) ：否定的后置断言。

    >>> re.findall(r'A(?<!A)\w+', 'ABC')
    []
    >>> re.findall(r'A(?<!AB)\w+', 'ABC')
    ['ABC']
    

或匹配

• | ：用于同时使用两个正则表达式，如果前一个不匹配，则尝试匹配后一个。
  • 例：

    >>> re.findall(r'B|b', 'ABC')
    ['B']
    >>> re.findall(r'abc|ABC', 'ABC')
    ['ABC']
    >>> re.findall(r'(ab|AB)C', 'ABC')
    ['AB']
    

定位符

• 定位符 ：用于匹配字符串的边界位置。如下：
  • 分为以下几种：

    ^     # 匹配字符串的开始边界，即第一个字符的之前
    $     # 匹配字符串的结束边界，即最后一个字符之后
    \b    # 匹配单词的开始或结束边界
    \B    # 匹配除 \b 以外的其它边界
    

    • 定位符并不匹配一个实际存在的字符，而是匹配字符之间的边界位置。
    • 如果连续的两个字符，一个匹配 \w ，一个不匹配 \w 或者为 ^ 、$ ，则认为这两个字符之间为单词边界，匹配 \b 。
  • 例：

    >>> re.findall(r'^', 'Hi!')     # 正则表达式只包含定界符时，匹配结果为空字符串
    ['']
    >>> re.findall(r'^Hi', 'Hi!')
    ['Hi']
    >>> re.findall(r'^Hi$', 'Hi!')
    []
    >>> re.findall(r'Hi\b!', 'Hi!')
    ['Hi!']
    >>> re.findall(r'H\Bi!\B', 'Hi!')
    ['Hi!']
    >>> re.findall(r'Hi\b\b\b\b!\B\B$', 'Hi!')  # 可以连续使用多个定位符，匹配同一个边界位置
    ['Hi!']
    

限定符

• 限定符 ：用于限制前面一个字符（或字符组）的连续匹配次数。

  • 分为以下几种：

    *   # 连续匹配任意次，包括 0 次
    +   # 连续匹配至少一次
    ?   # 连续匹配至多一次，即匹配 0 次或 1 次
    

  • 例：

    >>> re.findall(r'.*3','123123123')          # 限定符默认采用贪心模式，会尽量匹配最多次
    ['123123123']
    >>> re.findall(r'.*?3','123123123')         # 在限定符之后加上 ? ，比如 *? ，就采用非贪心模式，会尽量匹配最少次
    ['123', '123', '123']
    >>> re.findall(r'(?:\w{2}3)+','123123123')  # 限定符支持修饰字符组，字符组内也支持使用限定符
    ['123123123']
    

• { } ：用于声明限定符表达式，从而比限定符指定更准确的连续匹配次数。

  • 格式如下：

    {m}     # 连续匹配刚好 m 次
    {m,}    # 连续匹配至少 m 次
    {,n}    # 连续匹配至多 n 次
    {m,n}   # 连续匹配至少 m 次且至多 n 次
    

    • m、n 必须都是非负整数，且 m<=n 。
    • 逗号前后不能加空格。
  • 例：

    >>> re.findall(r'e{2}', 'be')
    []
    >>> re.findall(r'e{2}', 'bee')
    ['ee']
    >>> re.findall(r'e{2}', 'beee')
    ['ee']
    >>> re.findall(r'e{2}', 'beeee')
    ['ee', 'ee']
    

示例

• 匹配月份：

  >>> re.findall(r'^0?[1-9]$|^1[0-2]$', '09')
  ['09']
  

• 匹配一个符合 C 语言命名规范的字符串：

  >>> re.findall(r'^[A-Za-z_]\w*$', 'my_var')
  ['my_var']
  

• 匹配一个中文姓名：

  >>> re.findall(r'^[\u4e00-\u9fa5]{1,5}$', '张三')
  ['张三']
  

import re

：Python 的标准库，提供了一些使用正则表达式的方法。

• 官方文档 (opens new window)

compile()

re.compile(pattern, flags=0)

• 作用：创建一个正则表达式对象并返回。
• 参数：
  • pattern ：输入一个 str 或 bytes 类型的正则表达式。
  • flags ：标志位，用于控制正则匹配的模式。如下：

    re.ASCII        # 当 pattern 为 str 类型时，使 \b、\d、\w、\s 及其大写形式，只匹配 ASCII 字符。默认不启用该模式，会匹配 Unicode 字符
    re.IGNORECASE   # 不区分大小写
    re.MULTILINE    # 使 ^ 额外匹配换行符的右边界、 $ 额外匹配换行符的左边界，从而对字符串中的每行分别进行正则匹配
    re.DOTALL       # 使 . 匹配任何字符，即增加匹配换行符 \n
    
    re.ASCII|re.IGNORECASE # 可通过或运算符 | 组合启用多个模式
    

• 使用 re 模块时，可以直接调用 re.findall() 等函数。也可以先用 re.compile() 创建正则表达式对象，再调用其方法，这样便于复用正则表达式。如下：

  >>> import re
  >>> r = re.compile('a+', re.ASCII|re.IGNORECASE)
  >>> r.findall('abAB')
  ['a', 'A']
  >>> re.findall(r, 'abAB')
  ['a', 'A']
  

findall()

re.findall(pattern, string, flags=0)

• 作用：找出所有正则匹配的子字符串（没有字符重叠），组成一个 list 返回。
• 参数：
  • pattern ：一个 str、bytes 或 对象类型的正则表达式。
  • string ：要进行正则匹配的目标字符串。
• 例：

  >>> re.findall(r'aa', 'abAB')       # 匹配失败时，返回一个空 list
  []
  >>> re.findall(r'.', 'abAB')        # 匹配多个子字符串时，依次返回
  ['a', 'b', 'A', 'B']
  >>> re.findall(r'(ab)A(B)', 'abAB') # 如果声明了字符组，则只返回字符组的匹配结果，不返回整个正则表达式的匹配结果
  [('ab', 'B')]
  

  >>> re.findall(r'.*', 'abAB\n')     # . 默认不匹配换行符，因此这里会匹配 \n 左侧、右侧的空字符串
  ['abAB', '', '']
  >>> re.findall(r'.+', 'abAB\n')
  ['abAB']
  

search()

re.search(pattern, string, flags=0)

• 作用：找出第一个正则匹配的子字符串，返回一个 re.Match 对象。匹配失败时，返回 None 。
• 例：

  >>> re.search(r'ab', 'abAB')
  <re.Match object; span=(0, 2), match='ab'>
  

• 关于 re.Match 对象。
  • 用法示例：

    >>> match = re.search(r'(ab)A(B)', 'abAB\n')
    >>> if not match:     # 检查匹配是否成功，再进行后续操作
    ...     exit()
    ...
    >>> match
    <re.Match object; span=(0, 4), match='abAB'>  # 这里 match 表示与整个正则表达式匹配的子字符串，而 span 表示该子串的切片范围
    >>> match.span()      # 返回子串的切片范围
    (0, 4)
    

  • 调用 groups() 方法，会将各个字符组的匹配结果组成一个 tuple 返回：

    >>> re.search(r'abAB', 'abAB\n').groups()     # 如果没有声明字符组，则返回一个空 tuple
    ()
    >>> re.search(r'(ab)AB', 'abAB\n').groups()
    ('ab',)
    >>> re.search(r'(ab)A(B)', 'abAB\n').groups()
    ('ab', 'B')
    

  • 调用 groupdict() 方法，会将各个已命名的字符组的匹配结果组成一个 dict 返回：

    >>> re.search(r'(?P<id>ab)A(B)', 'abAB\n').groupdict()
    {'id': 'ab'}
    

sub()

re.sub(pattern, replace, string, count=0, flags=0)

• 作用：找出 string 中正则匹配的子字符串，替换成 replace 字符串。
• 参数：
  • count ：替换的最大次数。默认为 0 ，表示不限制。
• 例：

  >>> re.sub(r'aa', '_', 'abAB\n')        # 如果没有正则匹配的子字符串，则返回原字符串
  'abAB\n'
  >>> re.sub(r'(ab)A(B)', '_', 'abAB\n')  # sub() 会替换与整个正则表达式匹配的子字符串，而不只是字符组
  '_\n'
  >>> re.sub(r'(?P<id>ab)A(B)', r'\g<id>_\2', 'abAB\n')   # 替换时可以引用字符组
  'ab_B\n'
  

split()

re.split(pattern, string, maxsplit=0, flags=0)

• 作用：找出 string 中正则匹配的子字符串，用它们将 string 分割成多个字符串，组成一个 list 返回。
• 参数：
  • maxsplit ：分割的最大次数。默认为 0 ，表示不限制。
• 例：

  >>> re.split(r'\W+', 'www.baidu.com')
  ['www', 'baidu', 'com']