Python正则表达式（不）完全详解

解释

简单来说，正则表达式就是一种字符串的匹配模式，查找一个字符串中是否有我们所需要的的子串

在python中正则是在re库里面，故我们用正则需要导入这个内置库

import re

元字符：元字符使正则表达式具有处理能力。所谓元字符就是指那些在正则表达式中具有特殊意义的专用字符，比如这些: * + {} [] () | \ ^ $ 等等

`re. match`函数

原型: match(pattern, string, flags=0)
参数：

patter：匹配的正则表达式
string：要匹配的字符串
flags：标志位，用于控制正则表达式的匹配方式，值如下

匹配方式	含义
re.I	忽略大小写
re.L	做本地户识别
re.M	多行匹配，影响^和$
re.S	使.匹配包括换行符在内的所有字符，没有此标志，’.'将匹配除换行符以外的任何内容。
re.U	根据Unicode字符集解析字符，影响\w \W \b \B
re.X	使我们以更灵活的格式理解正则表达式

功能：尝试从字符串的起始位置匹配一个模式,如果不是起始位置匹配,成功的话,返回None

示例：

print(re.match("www", "www.baidu.com"))    # <_sre.SRE_Match object; span=(0, 3), match='www'>
print(re.match('www', ".bwwwaidu.com"))    # None

扫描整个字符串，返回从起始位置成功的匹配

re.I

含义：忽略大小写
示例：

print(re.match("www", "wwW.baidu.com", flags=re.I))  # <_sre.SRE_Match object; span=(0, 3), match='wwW'>

re.L

含义：忽略大小写
让\w，\W，\b，\B和区分大小写的匹配取决于当前的语言环境。该标志只能与字节模式一起使用。不建议使用此标志，因为语言环境机制非常不可靠，它一次只能处理一种“区域性”，并且仅适用于8位语言环境。默认情况下，Python 3中已为Unicode（str）模式启用了Unicode匹配，并且能够处理不同的语言环境/语言。
笔者也不知道该怎么示例，请见谅

re.M

含义：多行匹配，影响^和$
建议：findall()是扫描整个字符串，并返回结果列表
示例：
不使用re.M的效果

# 不使用re.M
s = """
www
.
baidu
.com
awww
"""
print(re.findall("^www", s))

运行结果：

[]

使用re.M的效果

# 使用re.M
s = """
www
.
baidu
.com
awww
"""
print(re.findall("^www", s, flags=re.M))

运行结果：

['www']

结果显而易见，re.M是每一行都匹配一下

re.S

含义：使.匹配包括换行符在内的所有字符，没有此标志，’.'将匹配除换行符以外的任何内容。
建议：search()是扫描整个字符串，并返回第一个成功的匹配
示例：

s = "\nwww.baidu.com"
print(re.search(r".", s))
print(re.search(r".", s, flags=re.S))

运行结果：

<_sre.SRE_Match object; span=(1, 2), match='w'>
<_sre.SRE_Match object; span=(0, 1), match='\n'>

re.U

含义：根据Unicode字符集解析字符，影响\w \W \b \B
笔者个人感觉没什么用,将\w \W \s \S等这些元字符按照 Unicode 的标准来考虑
re.U在 Python 3 中没有了, 只在 Python 2 中才有作用

re.X

含义：这个选项忽略规则表达式中的空白和注释，并允许使用 ’#’ 来引导一个注释。这样可以让你把规则写得更美观些。
示例：

rc = re.compile(r"""
# 开始第一个数字匹配
/d+
# 或者字母
|
# +的意思是匹配更多
[a-zA-Z]+
# 反正这个可以被允许写注释
""", re.X)
res = rc.match('abcd')
print(res.group())

运行结果：

abcd

匹配空白符

rc = re.compile(r"""
# 开始匹配规则
# 匹配一个或多个空格，也可以用"\s+"代替
\  +
""", re.X)
res = rc.match('   11')  # 字符串包含三个空格
print(res)
print('+%s+' % res.group())

运行结果：

<_sre.SRE_Match object; span=(0, 3), match='   '>
+   +

`re. findall`函数

原型: findall(pattern, string, flags=0)
参数：

patter：匹配的正则表达式
string：要匹配的字符串
flags：标志位，用于控制正则表达式的匹配方式，值如上

功能：扫描整个字符串，并返回结果列表

print(re.findall("ww", "fbeaskfww"))  # <_sre.SRE_Match object; span=(7, 9), match='ww'>

`re. search`函数

原型: search(pattern, string, flags=0)
参数：

patter：匹配的正则表达式
string：要匹配的字符串
flags：标志位，用于控制正则表达式的匹配方式，值如上

功能：扫描整个字符串，并返回第一个成功的匹配

print(re.search("ww", "wwhuhdiww"))  # ['ww', 'ww']

匹配单个字符与数字

匹配方式	含义
.<–（这是个点，颜色有点浅）	匹配除换行符以外的任意字符
[0123456789]	[]是字符集合，表示匹配方括号中所包含的任意一一个字符
[jack]	匹配’j’, ‘a’, ‘c’, 'k’中任意一个字符
[a-z]	匹配任意小写字母
[A-Z]	匹配任意大写字母
[0-9]	匹配任意数字，类似[0123456789]
[0-9a-zA- z]	匹配任意的数字和字母
[0-9a-zA-Z_]	匹配任意的数字、字母和下划线
[^jack]	匹配除了’j’, ‘a’, ‘c’, 'k’这几个字母以外的所有字符，中括号里的^称为脱字符，表示不匹配集合中的字符
[^0-9]	匹配所有的非数字字符
\d	匹配数字，效果同[0-9]
\D	匹配非数字字符，效果同[^ 0-9]
\w	匹配数字，字母和下划线,效果同[0-9a-zA-Z_]
\W	匹配非数字，字母和下划线，效果同[^0-9a-zA-Z]
\s	匹配任意的空白符(空格，换行，回车，换页，制表)，效果同[ \f\n\r\t]
\S	匹配任意的非空白符，效果同[^ \f\n\r\t]

举个例子（其他的都差不多，这个暂举4个例子）：

print(re.findall(".", "jack"))             # ['j', 'a', 'c', 'k']
print(re.findall("[a-z]", "jack"))         # ['j', 'a', 'c', 'k']
print(re.findall("[0-9]", "jack123"))      # ['1', '2', '3']
print(re.findall("[^jack]", "jack123"))    # ['1', '2', '3']

锚字符（边界字符）

匹配方式	含义
^	行首匹配，和在[]里的^不是一个意思
$	行尾匹配
\A	匹配字符串开始，它和^的区别是，\A只匹配整个字符串的开头，即使在re.M模式下也不会匹配它的行首
\Z	匹配字符串行尾，它和$的区别是，\A只匹配整个字符串的行尾，即使在re.M模式下也不会匹配它的行尾首
\b	匹配一个单词的边界，也就是指单词与空格间的位置（'boy’可以匹配Niceboy，但是不能匹配单词的中间）
\B	匹配一个非单词边界

举个例子（其他的都差不多，这个暂举3个例子）：

print(re.search("^jack", "jack is a good man"))     # <_sre.SRE_Match object; span=(0, 4), match='jack'>
print(re.search("jack$", "The cat is this jack"))   # <_sre.SRE_Match object; span=(16, 20), match='jack'>
print(re.search("\Ajack", "jack is a nice boy"))    # <_sre.SRE_Match object; span=(0, 4), match='jack'>

`\A`与`^`的区别

print(re.findall("^jack", "jack is good boy\njack is good boy", re.M))     # ['jack', 'jack']
print(re.findall("\Ajack", "jack is good boy\njack is good boy", re.M))    # ['jack']

`\Z`与`$`的区别

print(re.findall("boy$", "jack is good boy\njack is good boy", re.M))  # ['boy', 'boy']
print(re.findall("boy\Z", "jack is good boy\njack is good boy", re.M))  # ['boy']

`\b`与`\B`

print(re.search(r"boy\b", "Niceboy"))  # <_sre.SRE_Match object; span=(4, 7), match='boy'>
print(re.search(r"ce\b", "Niceboy"))  # None
print(re.search(r"boy\B", "Niceboy"))  # None
print(re.search(r"ce\B", "Niceboy"))  # <_sre.SRE_Match object; span=(2, 4), match='ce'>

匹配多个字符

说明:下方的x、 y、z均为假设的普通字符，不是正则表达式的元字符

匹配方式	含义	注
x?	匹配0个或者1个x	非贪婪匹配
x*	匹配0个或者任意多个x	贪婪匹配
x+	匹配至少一个x	贪婪匹配
x{n}	匹配确定的n个x (n是一个非负整数)
x{n,}	匹配至少n个x	贪婪匹配
x{n,m}	匹配至少n个x最多m个x 注意：n <= m
x\|y	\| 表示或，匹配的是x或y
(xyz)	匹配小括号内的xyz(作为一个整体去匹配)

a?

匹配0个或者1个a
非贪婪匹配（尽可能少的匹配）

print(re.findall(r"a?", "jack is a boy"))  # ['', 'a', '', '', '', '', '', '', 'a', '', '', '', '', '']

因为它可以匹配0个，所以会有’ '的存在

a*

匹配0个或者任意多个a
贪婪匹配（尽可能多的匹配）

print(re.findall(r"a*", "aaabaa"))  # ['aaa', '', 'aa', '']

因为它可以匹配0个，所以会有’ '的存在

a+

匹配至少一个a
贪婪匹配（尽可能多的匹配）

print(re.findall(r"a+", "aaabaaaa"))  # ['aaa', 'aaaa']

a{n}

匹配确定的n个a (a是一个非负整数)

print(re.findall(r"a{3}", "aaabaaaa"))  # ['aaa', 'aaa']

a{n,}

匹配至少n个a
贪婪匹配（尽可能多的匹配）

print(re.findall(r"a{3,}", "aaabaaaa"))  # ['aaa', 'aaaa']

a{n,m}

匹配至少n个x最多m个x 注意：n <= m

print(re.findall(r"a{3,6}", "aaaabaaaaaaaa"))  # ['aaaa', 'aaaaaa']

a|b

| 表示或，匹配的是a|b

print(re.findall(r"a|A", "aaabaAaa"))  # ['a', 'a', 'a', 'a', 'A', 'a', 'a']

(abc)

匹配小括号内的abc(作为一个整体去匹配)

print(re.findall(r"((j|J)ack)", "jack--Jack"))  # [('jack', 'j'), ('Jack', 'J')]

特殊

*? +? x?

最小匹配，通常都是尽可能多的匹配，可以使用这种解除贪婪匹配
(?:x)

类似(xyz)，但不表示一个组

例子：

# /* part1 */ /* part2 */
print(re.findall(r"//*.*/*/", r"/* part1 */ /* part2 */"))      # ['/* part1 */ /* part2 */']
print(re.findall(r"//*.*?/*/", r"/* part1 */ /* part2 */"))     # ['/* part1 */', '/* part2 */']

尽可能少的去匹配
这里解释一下：

//*中的第一个斜杠，实际上就是斜杠。第二个斜杠是转义的*
中间的.*，.代表除换行符以外的任意字符嘛，*是0个或者任意多个.嘛，相当于任意多个换行符以外的字符

re模块的深入

`re.split`函数 – -- – 优秀的`字符串切割`加工厂

这是普通的字符串切割

str1 = "jack   is  a  good   boy"
# 这是普通的字符串切割
print(str1.split(" "))                   # ['jack', '', '', 'is', '', 'a', '', 'good', '', '', 'boy']

如果要去除这些小空格的话，还有用循环之后判断来去除，挺麻烦的(好吧，其实也不是特别麻烦)

下面我们用re.split函数来切割一下

str1 = "jack   is   a   good   boy"
print(re.split(r" +", str1))             # ['jack', 'is', 'a', 'good', 'boy']

这里的+前面是有小空格的，小空格和+组合起来，就是匹配至少一个空格，然后直接去除

`re. finditer`函数

原型: finditer (pattern，string, flags=0)
参数:

patter:匹配的正则表达式
string:要匹配的字符串
flags:标志位，用于控制正则表达式的匹配方式

功能:与findall类似，扫描整个字符串，返回的是一个迭代器

str2 = "jack is a good boy! jack is a good boy! jack is a good boy!"
d = re.finditer(r"(jack)", str2)
while True:
    try:
        l = next(d)
        print(l)
    except StopIteration as e:
        break

运行结果：

<_sre.SRE_Match object; span=(0, 4), match='jack'>
<_sre.SRE_Match object; span=(20, 24), match='jack'>
<_sre.SRE_Match object; span=(40, 44), match='jack'>

因为是迭代器，所以它如果最后取不到值的话，会报错的，故我们要这里取到错误之后终止程序

`re.sub`与`re.subn`函数

字符串的替换和修改
原型：sub (pattern, repl, string, count=0)
原型：subn (pattern, repl, string, count=0)
参数：

pattern：正则表达式 (规则)
repl：指定的用来替换的字符串
string：目标字符串
count：最多替换次数

功能: 在目标字符串中以正则表达式的规则匹配字符串，再把他们替换成指定的字符串。可以指定替换的次数，如果不指定，替换所有的匹配字符串

区别：

sub返回一个被替换的字符串
subn返回一个元组，第一个元素被替换的字符串，第二个元素表示被替换的次数

str3 = "jack is a good good good boy"
print(re.sub(r"(good)", "nice", str3))                 # jack is a nice nice nice boy
print(type(re.sub(r"(good)", "nice", str3)))           # <class 'str'>
print(re.subn(r"(good)", "nice", str3))                # ('jack is a nice nice nice boy', 3)
print(type(re.subn(r"(good)", "nice", str3)))          # <class 'tuple'>

`分组`

概念：除了简单的判断是否匹配之外，正则表达式还有提取子串的功能。用()表示的就是提取分组

例子：

使用序号获取对应组的信息，group(0)一直代表的原始字符串

str4 = "110-123456"
m = re.match(r"(\d{3})-(\d{6})", str4)
print(m.group(0))                  # 110-123456
print(m.group(1))                  # 110
print(m.group(2))                  # 123456

查看匹配的各组的情况

print(m.groups())                  # ('110', '123456')

命名 (?P<名字>)

t = re.match(r"(?P<first>\d{3})-(?P<last>\d{6})", str4)
print(t.group("first"))            # 110

`re.compile`函数

原型: compile(pattern,flags=0)
参数：

patter：要编译的正则表达式
flags(一般我们不用)：标志位，用于控制正则表达式的匹配方式

编译:当我们使用正则表达式时，re模块会干两件事

编译正则表达式，如果正则表达式本身不合法，会报错
用编译后的正则表达式去匹配对象

我们普通的使用一个match函数

pat = r"^1(([3578]\d)|(47))\d{8}$"
print(re.match(pat, "13000000000"))                # <_sre.SRE_Match object; span=(0, 11), match='13000000000'>

编译成正则对象后

pat = r"^1(([3578]\d)|(47))\d{8}$"
re_telephone = re.compile(pat)
print(re_telephone.match("13000000000"))           # <_sre.SRE_Match object; span=(0, 11), match='13000000000'>

好吧，其实是一样的，但是帅的人都用编译的方式
因为，简单快捷，编译成对象之后我们可以直接使用对象就行了，这样方便一点

感谢观看，如有疑问或补充的，不胜感激！！

Python正则表达式（不）完全详解

解释

re. match函数

re.I

re.L

re.M

re.S

re.U

re.X

re. findall函数

re. search函数

匹配单个字符与数字

锚字符（边界字符）

\A与^的区别

\Z与$的区别

\b与\B

匹配多个字符

a?

a*

a+

a{n}

a{n,}

a{n,m}

a|b

(abc)

特殊

re模块的深入

re.split函数 – -- – 优秀的字符串切割加工厂

re. finditer函数

re.sub与re.subn函数

分组

re.compile函数

`re. match`函数

`re. findall`函数

`re. search`函数

`\A`与`^`的区别

`\Z`与`$`的区别

`\b`与`\B`

`re.split`函数 – -- – 优秀的`字符串切割`加工厂

`re. finditer`函数

`re.sub`与`re.subn`函数

`分组`

`re.compile`函数