python3_标准库_re模块（常用正则表达式处理函数）

1.定义
正则表达式是一个特殊的字符序列，能方便的检查一个字符串是否与某种模式匹配。re模块使得python拥有全部的正则表达式功能。
2.re.match(pattern, string, flags=0)函数

尝试从一个字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，则返回None。
pattern: 待匹配的正则表达式

string: 待查找的字符串

flags（可选参数）: 标志位，控制正则表达式的匹配方式。re.I(ignore) re.L(local) re.M(many lines) re.S(sum) re.U(unicode) re.X

返回值：匹配成功返回匹配对象（group(num=0) / groups() 返回的是一个元组），匹配失败返回None

import re

# print(re.match("www", "www.baidu.com").span())
# print(re.match("com", "www.baidu.com"))
# print("*" * 98)


line = "Cats are Smarter than dogs"
# re.M：多行匹配
# re.I:忽略大小写进行匹配
# match()以元组形式返回匹配成功的对象
match_obj = re.match(r"(.*) are (.*?) .*", line, re.M | re.I)
if match_obj:
    print("match_obj.group(): ", match_obj.group())
    print("match_obj.group(1): ", match_obj.group(1))
    print("match_obj.group(2): ", match_obj.group(2))
    print("match_obj.groups(): ", match_obj.groups())
else:
    print("None match!")
print("*" * 98

3.re.search(pattern, string, flags=0)函数
从左向右扫描整个字符串，并返回第一个成功的匹配。

函数参数含义同上

返回值：匹配成功时返回匹配的对象，匹配失败时返回空。（可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式）

import re

print(re.search("www", "www.baidu.com").span())
print(re.search("com", "www.baidu.com").span())
print(re.search("www", "www.baidu.com.www").span())
print(re.search("com", "www.baidu.com.com").span())
print("*" * 98)


line = "Cats are smarter than dogs"
search_obj = re.search(r"(.*) are (.*?) .*", line,  re.M | re.I)
if search_obj:
    print("search_obj.group():", search_obj.group())
    print("search_obj.group(1):", search_obj.group(1))
    print("search_obj.group(2):", search_obj.group(2))
    print("search_obj.groups():", search_obj.groups())
else:
    print("None match!")

4.re.match函数与re.search函数的区别

re.match仅匹配字符串的开始，若字符串开始不符合正则表达式，则匹配失败返回None。re.search函数从左向右匹配整个字符串，直到找到一个匹配。

import re

lines = "this is python3 program."

match_obj = re.match("python", lines, re.M | re.I)
if match_obj:
    print("match ---> match_obj.group(): ", match_obj.group())
else:
    print("match: None match!")

search_obj = re.search("python", lines, re.M | re.I)
if search_obj:
    print("search ---> search_obj.group(): ", search_obj.group())
else:
    print("search: None search!")

5.re.sub(pattern, rep1, string, count=0)函数
替换字符串中的匹配项。

pattern：正则中的模式字符串

rep1：替换的字符串。也有可能是一个函数

string : 要被替换成的字符串

count：模式匹配后替换的最大次数，默认0表示替换所有的匹配

import re

phone = "183-0929-9926 # this is a telephone number"

# 删除电话号码中的注释
num_non_space = re.sub(r"#.*$", "", phone)
print(num_non_space)
print(type(num_non_space))

# 删除电话号码中的"-"
num_new = re.sub(r"-", "", num_non_space)
print(num_new)
print("*" * 98)

function_sub = "A123B456C789D1"


def double(matched):
    value = int(matched.group("value"))
    return str(value*2)

# repl参数为函数形式
print("old_str --> ", function_sub)
print("new_str --> ", re.sub("(?P<value>\d+)", double, function_sub))

6.re.compile(pattern, flags)函数
用于编译正则表达式，生成一个正则表达式对象（Pattern），供match和search两个函数使用。

pattern：正则表达式

flags：可选参数。匹配模式

import re

des_str = "one12twothree34four"

# 匹配至少一个数字
pattern = re.compile(r"\d+", re.I | re.M)

# 从头部开始查找，没有匹配
match_obj = pattern.match(des_str)
print(match_obj)

# 从e位置开始查找，没有匹配
# def match(self, string: AnyStr, pos: int = ..., endpos: int = ...)
match_obj = pattern.match(des_str, 2, 10)
print(match_obj)

# 从1位置开始匹配，正好查找到
match_obj = pattern.match(des_str, 3, 20)
print(match_obj)
print("match-obj.group(): ", match_obj.group())
print("match-obj.group(0): ", match_obj.group(0))

# start()方法返回分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引）
# end()返回分组匹配子串在整个字符串中的结束为止（子串最后一个字符索引+1）
# span()返回 span(start, end)
print("*" * 98)
print("m.span(): ", match_obj.span())
print("m.start(): ", match_obj.start())
print("m.end(): ", match_obj.end())

7.re.compile(pattern, flags).findall(string, pos, endpos)函数

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

查找字符串中与正则表达式匹配的所有子串，返回一个列表（list）,查找失败返回空列表

同match\search的区别：match\search匹配一次，findall匹配所欲

import re

pattern = re.compile(r"\d+")

# compile对象.findall()
# def findall(self, string: AnyStr, pos: int = ..., endpos: int = ...)
result1 = pattern.findall("123one456three789")
result2 = pattern.findall("123one456three789", 3, 18)


print(result1)
print(result2)
print("*" * 100)


reg = "(.*?) are (.*)"

re.findall()
def findall(pattern, string, flags=0)
result3 = re.findall(reg, "they are boys", re.M | re.I)
print(result3)

8.re.compile(pattern, flags).finditer(string, pos, endpos)函数
re.finditer(pattern, string, flags=0)函数

与findall类似，查找字符串中与正则表达式匹配的所有子串，并把他们作为迭代器（

import re

des_str = "12a32bc43jf3"
pattern = re.compile(r"\d+", re.M | re.I)

# re.finditer()
# def finditer(pattern, string, flags=0)
it = re.finditer(r"\d+", des_str, re.M | re.I)
print(type(it))
print(it)
# 遍历迭代器，打印数据
for match in it:
    print(match.group(), end=" ")
print()


# re.compile().finditer()
# def finditer(self, string: AnyStr, pos: int = ..., endpos: int = ...)
it2 = pattern.finditer(des_str, 2, 20)
print(type(it2))
print(it2)
for match1 in it2:
    print(match1.group(), end=" ")
print()

9.re.compile(pattern, flags).split(string, maxsplit: int = …)函数
re.split(pattern, string, maxsplit: int = …)

按照能够匹配的子串将字符串分割

返回值：列表（list）

参数：maxsplit(分割次数，默认为0)。其他参数同上

注意：找不到匹配字符串，split不做分割，返回原始字符串

import re

des_str = " runoob, runoob, runoob. "
pattern1 = re.compile(r"\w+")
pattern2 = re.compile(r"(\w+)")

# def split(self, string: AnyStr, maxsplit: int = ...) -> list[AnyStr]: ...
# maxsplit为最大分隔次数（分隔块数 = 次数 + 1）
print("pattern1.split() --> ", pattern1.split(des_str))
print("pattern2.split() --> ", pattern2.split(des_str))
print("*" * 100)

# def split(pattern, string, maxsplit=0, flags=0):
print("re.split --> ", re.split(r"\w+", des_str))
print("re.split --> ", re.split(r"(\w+)", des_str))
print("re.split --> ", re.split(r"\w+", des_str, 1))
print("re.split --> ", re.split(r"\w+", des_str, 2))
print("*" * 100)

# 未匹配到字符串 不做分割 返回原始字符串
print(re.split("a*", des_str))