Python 内置模块之 re - 正则表达式

在 Python 中需要通过正则表达式对字符串进⾏匹配的时候，可以使⽤⼀个 Python 自带的模块，名字为 re。

常用方法：

• match()：从头匹配
• search()：从整个文本搜索
• findall()：找到所有符合的
• split()：分割
• sub()：替换
• group()：结果转化为内容
• groupdict()：结果转化为字典

re.match

尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match() 返回 none。匹配成功 match() 返回一个匹配的对象。如果上⼀步匹配到数据的话，可以使⽤ group() 来提取数据。

语法：

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

参数：
    pattern：匹配的正则表达式
    string： 要匹配的字符串
    flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
        re.I 忽略大小写
        re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
        re.M 多行模式
        re.S 即为 . 并且包括换行符在内的任意字符（. 不包括换行符）
        re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
        re.X 为了增加可读性，忽略空格和 # 后面的注释

示例：

import re


result = re.match("abcd","abcd.cn")
result.group()  # 'abcd'

从 string 头开始匹配 pattern 完全可以匹配，pattern 匹配结束，同时匹配终止，后面的 .cn 不再匹配，返回匹配成功的信息。

re.compile

compile 函数用于编译正则表达式，生成一个正则表达式（Pattern）对象，它单独使用就没有任何意义，需要和 findall(), search()， match()搭配使用。

re.compile(pattern,flag=0)

参数：
    pattern： 正则模型
    falgs ： 匹配模式,比如忽略大小写，多行模式等

返回值: Pattern 对象

示例1

prog = re.compile(pattern)
result = prog.match(string)

# 等价于
result = re.match(pattern, string)

示例2：

import re


pattern = re.compile(r'\d+')   
m = pattern.match('one12twothree34four', 3, 10) # 从'1'的位置开始匹配，正好匹配
print(m)                                        # 返回一个 Match 对象 <_sre.SRE_Match object at 0x23a42abd0>
print(m.group(0))                               # 可省略 0, 结果 '12'
print(m.start(0))                               # 可省略 0，结果 3
print(m.end(0))                                 # 可省略 0，结果 5
print(m.span(0))                                # 可省略 0，结果 (3, 5)

re.group 和 re.groups

group 和 groups 用于处理匹配结果的分组信息。

• group([group1, …]) 方法用于获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用 group() 或 group(0)；

  • group() 同 group(0) 就是匹配正则表达式整体结果，group(1) 列出第一个括号匹配部分，group(2) 列出第二个括号匹配部分，group(3) 列出第三个括号匹配部分。
  • 当正则表达式没有匹配到字符串中的任何内容时，调用 group() 方法将会抛出 AttributeError 异常。

• groups 它返回的是所有分组匹配结果组成的元组。该方法不接受任何参数。

• start([group]) 方法用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为 0；

• end([group]) 方法用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1），参数默认值为 0；

• span([group]) 方法返回 (start(group), end(group))

re.search

re.search 扫描整个字符串并返回第一个成功的匹配，如果没有匹配，就返回一个 None。

语法：

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

参数
    pattern:正则表达式的字符串或原生字符串表示
    string:待匹配字符串
    flags:正则表达式使用时的控制标记

re.match 与 re.search 的区别：

• re.match 只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回 None；
• re.search 匹配整个字符串，直到找到一个匹配

举例：

import re

ret = re.search(r"\d+", "阅读次数为9999")
print(ret.group())      # 9999

re.findall

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。注意：match 和 search 是匹配一次， findall 匹配所有。

语法：

re.findall(pattern, string, [flags])

参数
    pattern：表示模式字符串，由要匹配的正则表达式转换而来。
    string：表示要匹配的字符串。
    flags：可选参数，表示标志位，用于控制匹配方式，如是否区分字母大小写、是否包括换行等等。

举例：

import re
ret = re.findall(r"\d+", "python = 9999, c = 7890, c++ = 12345")
print(ret)  # ['9999', '7890', '12345']

re.finditer

和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。

import re
it = re.finditer(r"\d+", "12a32bc43jf3")
for match in it:
    print(match.group())

结果：

12
32
43
3

re.sub

sub 是 substitute 的所写，表示替换，将匹配到的数据进⾏替换。

语法：

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

参数：
    pattern：必选，表示正则中的模式字符串
    repl：   必选，就是replacement，要替换的字符串，也可为一个函数
    string： 必选，被替换的那个string字符串
    count：  可选参数，count 是要替换的最大次数，必须是非负整数。如果省略这个参数或设为 0，所有的匹配都会被替换
    flag：   可选参数，标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等

举例：将匹配到的阅读次数加1

方法一：

import re
ret = re.sub(r"\d+", '998', "python = 997")
print(ret)  # python = 998

方法二：

import re
def add(temp):
    #int（）参数必须是字符串，类似字节的对象或数字，而不是“re.Match”
    strNum = temp.group()
    num = int(strNum) + 1
    return str(num)
ret = re.sub(r"\d+", add, "python = 997")
print(ret)  # python = 998  
ret = re.sub(r"\d+", add, "python = 99")
print(ret)  # python = 100

re.subn

作用与 sub() 相同，但是返回一个元组 (字符串, 替换次数)。

re.subn(pattern, repl, string[, count])

返回：(sub(repl, string[, count]), 替换次数)

import re
pattern = re.compile(r'(\w+) (\w+)')
s = 'i say, hello world!'
print(re.subn(pattern, r'\2 \1', s))
def func(m):
    return m.group(1).title() + ' ' + m.group(2).title()
print(re.subn(pattern, func, s))
### output ###
# ('say i, world hello!', 2)
# ('I Say, Hello World!', 2)

re.split

根据匹配进⾏切割字符串，并返回⼀个列表。

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

参数
    pattern：匹配的正则表达式
    string： 要匹配的字符串
    maxsplit：分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数
    flags：可选参数，表示标志位，用于控制匹配方式，如是否区分字母大小写、是否包括换行等等。

举例：

import re
ret = re.split(r":| ","info:xiaoZhang 33 shandong")
print(ret)  # ['info', 'xiaoZhang', '33', 'shandong']

r 的作用

与大多数编程语言相同，正则表达式里使用 ”\” 作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符”\”，那么使用编程语言表示的正则表达式里将需要4个反斜杠”\\\\”：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。Python 里的原生字符串很好地解决了这个问题，Python 中字符串前⾯加上 r 表示原⽣字符串。

import re
mm = "c:\\a\\b\\c"
print(mm)#c:\a\b\c
ret = re.match("c:\\\\",mm).group()
print(ret)#c:\
ret = re.match("c:\\\\a",mm).group()
print(ret)#c:\a
ret = re.match(r"c:\\a",mm).group()
print(ret)#c:\a
ret = re.match(r"c:\a",mm).group()
print(ret)#AttributeError: 'NoneType' object has no attribute 'group'

Reference

• https://blog.csdn.net/guo_qingxia/article/details/113979135
• https://blog.csdn.net/m0_43609475/article/details/119924047