Python3: 正则表达式 - re 模块

比眉伴天荒 2021-09-21 22:48 451阅读 0赞

本文链接: [https://blog.csdn.net/xietansheng/article/details/115557843][https_blog.csdn.net_xietansheng_article_details_115557843]

[Python3 学习笔记（目录）][Python3]

Python官网 **正则表达式**：[re — Regular expression operations][re _ Regular expression operations]

# 1. 正则表达式模块: re #

正则表达式简单使用示例:

import re
    
    pattern = re.compile("[0-9]+")          # 编译正则表达式, 返回 re.Pattern
    
    print(pattern.match("12cd"))            # 匹配字符串(匹配开头), 匹配, 返回 re.Match
    print(pattern.match("ab34"))            # 匹配字符串(匹配开头), 不匹配, 返回 None
    print(pattern.fullmatch("1234"))        # 匹配整个字符串
    print(pattern.findall("ab12cd34"))      # 搜索整个字符串, 返回所有匹配的子串列表: ["12", "34"]
    
    match = pattern.search("ab12cd")        # 从整个字符串中搜索("[0-9]+")第一个匹配的结果,
    if match:                               # 搜索到匹配结果, 返回 re.Match, 否则为 None,
        print(match.group())                # 获取搜索到的结果, 结果为 "12"
    
    print(re.match("[0-9]+", "12cd"))       # 也可以调用 re 模块的直接方法进行匹配,
    print(re.fullmatch("[0-9]+", "1234"))   # 内部也是先编译再匹配, 内部编译好的正则表达式对象会缓存, 
    print(re.findall("[0-9]+", "ab12cd34")) # 下次再使用该正则表达式(pattern与flags相同)时, 
    print(re.search("[0-9]+", "ab12cd"))    # 直接从缓存中获取正则表达式对象, re.purge() 清除缓存。

`re`模块中的函数与常量（Python官网 [re模块内容][re]）:

# 将正则表达式编译为正则表达式对象 re.Pattern
    #
    # 参数:
    # pattern: 正则表达式（字符串类型, 原始样式字符串）
    # flags: 标志常量（例如只匹配ASCII码, 忽略大小写等）, re.RegexFlag 类中的常量
    # 返回: 
    # 正则表达式对象 re.Pattern
    #
    # 得到编译好的正则表达式对象后, 可以用它的 match(), search() 等方法匹配字符串。
    re.compile(pattern, flags=0)
    
    
    # 搜索整个字符串, 找到匹配样式的第一个位置
    #
    # 参数:
    # pattern: 正则表达式（字符串类型）
    # string: 搜索的字符串
    # flags: 标志常量
    # 返回:
    # 搜索成功, 则返回 re.Match 对象, 否则返回 None。
    # 搜索成功后调用 match.group() 方法可以获取搜索到的内容。
    re.search(pattern, string, flags=0)
    
    
    # 匹配字符串的开头, 函数内部将会把 pattern字符串 编译为 re.Pattern对象, 再进行匹配。
    #
    # 参数:
    # pattern: 正则表达式（字符串类型）
    # string: 需要匹配的字符串
    # flags: 标志常量
    # 返回:
    # 匹配成功, 则返回 re.Match 对象, 否则返回 None。
    # 匹配成功后调用 match.group() 方法可以获取匹配的内容。
    re.match(pattern, string, flags=0)
    
    
    # 匹配整个字符串
    re.fullmatch(pattern, string, flags=0)
    
    
    # 用 pattern 分开 string, 返回一个由分开后子字符串组成的 列表
    re.split(pattern, string, maxsplit=0, flags=0)
    
    
    # 查找整个字符串, 返回一个不重复的与 pattern 匹配的子字符串列表
    re.findall(pattern, string, flags=0)
    
    
    # 查找整个字符串, 返回一个迭代器, 迭代元素为 re.Match
    re.finditer(pattern, string, flags=0)
    
    
    # string 中匹配 pattern 的子字符串用 repl 替换, count 表示最多替换次数
    # count=0表示全部替换, 返回被替换后的字符串。
    re.sub(pattern, repl, string, count=0, flags=0)
    
    
    # 与 re.sub(...) 相同, 返回的是一个元祖 (替换后的字符串, 替换次数)
    re.subn(pattern, repl, string, count=0, flags=0)
    
    
    # 转义 pattern 中的特殊字符。如果想匹配任何可能包含正则表达式元字符的 
    # 文本字符串, 可以用该方法先转义正则表达式。
    # 例如: re.escape(".+abc") 结果为 "\.\+abc"
    # 匹配字符串是否以 ".+abc" 开头: re.match(re.escape(".+abc"), ".+abc123")
    re.escape(pattern)
    
    
    # 清除正则表达式缓存
    re.purge()

> re.match() 与 re.search() 的区别：前者只匹配字符串开头，后者搜索整个字符串。

标记常量 flags 是 re.RegexFlag 类中的示例，该类继承自 enum.IntFlag，并有多个别名引用。flags 的部分常量:

# 让 \w, \W, \b, \B, \d, \D, \s, \S 只匹配ASCII, 而不是 Unicode
    re.A,   re.ASCII,       re.RegexFlag.A,     re.RegexFlag.ASCII
    
    # 匹配时忽略大小写
    re.I,   re.IGNORECASE,  re.RegexFlag.I,     re.RegexFlag.IGNORECASE
    
    # 由本地语言区域决定 \w, \W, \b, \B 和 大小写敏感匹配
    re.L,   re.LOCALE,      re.RegexFlag.L,     re.RegexFlag.LOCALE
    
    # 样式字符 '^' 和 '$' 除了匹配字符串的开始和结束外, 还匹配每一行的开始和结束
    re.M,   re.MULTILINE,   re.RegexFlag.M,     re.RegexFlag.MULTILINE
    
    # 使特殊字符 '.' 匹配换行符, 没有该标记, '.' 只匹配除了换行符以外的其他任意字符
    re.S,   re.DOTALL,      re.RegexFlag.S,     re.RegexFlag.DOTALL
    
    # 编译时忽略空白和注释, 设置了该标记后可以在正则表达式的原始样式字符串中添加注释
    re.X,   re.VERBOSE,     re.RegexFlag.X,     re.RegexFlag.VERBOSE

标记常量 flags 可以同时设置多个，例如: `flags=re.A|re.I`

# 2. 正则表达式对象: re.Pattern #

正则表达式对象`re.Pattern`中的属性和方法（Python官网 [Regular Expression Objects][]）:

Pattern.search(string[, pos[, endpos]])         # 参考 re.search()
    
    Pattern.match(string[, pos[, endpos]])          # 参考 re.match()
    Pattern.fullmatch(string[, pos[, endpos]])      # 参考 re.fullmatch()
    
    Pattern.split(string, maxsplit=0)               # 参考 re.split()
    
    Pattern.findall(string[, pos[, endpos]])        # 参考 re.findall()
    Pattern.finditer(string[, pos[, endpos]])       # 参考 re.finditer()
    
    Pattern.sub(repl, string, count=0)              # 参考 re.sub()
    Pattern.subn(repl, string, count=0)             # 参考 re.subn()
    
    Pattern.pattern                                 # 编译对象的原始样式字符串
    Pattern.flags                                   # 正则表达式对象的标志常量
    Pattern.groups                                  # 捕获组合的数量
    Pattern.groupindex                              # 映射由 (?P<id>) 定义的命名符号组合和数字组合的字典,
                                                    # 如果没有符号组, 则该字典为空字典 {}。

# 3. 匹配对象: re.Match #

匹配对象`re.Match`中的部分属性和方法（Python官网 [Match Objects][]）:

Match.group([group1, ...])  # 返回一个(str)或多个(tuple)匹配的子组, group 默认为 0 表示匹配的整个子串
    Match.groups(default=None)  # 返回一个元祖, 包含了所有匹配的子组
    
    Match.start([group])    # 返回 group 匹配到的子字符串的开始位置, group 默认为 0 表示匹配的整个子串
    Match.end([group])      # 返回 group 匹配到的子字符串的结束位置, group 默认为 0 表示匹配的整个子串
    
    Match.span([group])     # 返回一个元祖 (m.start(group), m.end(group))
    
    Match.re                # 产生该匹配对象 的 正则表达式对象
    Match.string            # 产生该匹配对象 的 中的原待匹配字符串

代码示例:

>>> import re
    >>> m = re.search("(\\w+)_(\\w+)", "xx aa_bb yy")
    >>> 
    >>> m.group()           # 匹配的整个子串
    'aa_bb'
    >>> m.group(0)          # 匹配的整个子串
    'aa_bb'
    >>> m.group(1)          # 第1个匹配组(带圆括号的组)匹配的子串
    'aa'
    >>> m.group(2)          # 第2个匹配组 匹配的子串
    'bb'
    >>> m.group(1, 2)       # 第1、2个匹配组 匹配的子串组成的元祖
    ('aa', 'bb')
    >>> m.groups()          # 所有匹配组 匹配的子串组成的元祖
    ('aa', 'bb')
    >>> 
    >>> m.start()           # 匹配的整个子串 在 原字符串中的 开始 位置
    3
    >>> m.start(0)          # 匹配的整个子串 在原字符串中的 开始 位置
    3
    >>> m.start(2)          # 第2个匹配组 匹配的子串 在原字符串中的 开始 位置
    6
    >>> m.end(1)            # 第1个匹配组 匹配的子串 在原字符串中的 结束 位置（下一个位置的索引）
    5
    >>> m.span()            # 匹配的整个子串 在原字符串中的 开始 和 结束 位置
    (3, 8)
    >>> m.span(0)           # 匹配的整个子串 在原字符串中的 开始 和 结束 位置
    (3, 8)
    >>> m.span(1)           # 第1个匹配组 匹配的子串 在原字符串中的 开始 和 结束 位置
    (3, 5)
    >>> 
    >>> m.re                        # 产生该匹配对象 的 正则表达式对象
    re.compile('(\\w+)_(\\w+)')
    >>> m.string                    # 产生该匹配对象 的 中的原待匹配字符串
    'xx aa_bb yy'

[https_blog.csdn.net_xietansheng_article_details_115557843]: https://blog.csdn.net/xietansheng/article/details/115557843
[Python3]: https://blog.csdn.net/xietansheng/article/details/109266600
[re _ Regular expression operations]: https://docs.python.org/zh-cn/3/library/re.html
[re]: https://docs.python.org/zh-cn/3/library/re.html#module-contents
[Regular Expression Objects]: https://docs.python.org/zh-cn/3/library/re.html#regular-expression-objects
[Match Objects]: https://docs.python.org/zh-cn/3/library/re.html#match-objects