正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配，而re模块则提供了这种功能。

正则表达式原子

表示

\d

表示0~9之间任意一个字符

\D

表示除了0~9之外的任意一个字符

\s

表示任意一个空白字符（不可见字符）

\S

表示任意一个非空白字符（可见字符）

\w

表示0 ~ 9 a ~ z A ~ Z和l_中的任意一个字符

\W

表示除了0 ~ 9 a ~ z A ~ Z和 _ 之外的任意一个字符

.

表示任意一个字符(除‘\n’)

正则表达式

元字符（原子修饰符）

表示

[ ]

表示自定义原子列表中的任意一个字符,如果字符在ascii码中连续，则可简写，例如：[123456789]可写成[1-9]

[^ ]

排除自定义列表格式

\A

匹配内容必须在整个字符串开头位置才会匹配成功(注意出现 \n 不可以匹配)

\Z

匹配内容必须在整个字符串结束位置 才会匹配成功(注意出现 \n 不可以匹配)

$

匹配内容必须在整个字符串结束位置 才会匹配成功(注意出现 \n 可以匹配及多行匹配模式，需要加上re.M模式修正符号)

^

匹配内容必须在整个字符串开头位置才会匹配成功(注意出现 \n 可以匹配及多行匹配模式，需要加上re.M模式修正符号)

\b

表示能够当作英文单词分割的字符(词边界) ，除了字符，汉字和数字都是词边界

\B

表示不能够当作英文单词分割的字符

|

表示或

（）

改变优先级、将匹配的内容当作模式单元进行存储和多原子化为一个原子处理

\

转义字符

正则表达式

数量相关元字符

表示

+

表示1个以上的修饰的原子

？

表示0个或1个修饰的原子

*

表示任意一个修饰的原子

{m}

表示有m个修饰的原子

{m,n}

表示有m~n个修饰的原子

{m,}

表示有m~正无穷个修饰的原子

{ ,n}

表示有负无穷~n个修饰的原子

模式修正符

表示

re.A 、（re.ASCII）

在ASCII模式（数字、字母、下划线）下进行正则表达式

re.U 、（re.UNICODE）

默认修正符，在Unicode模式下进行正则表达式

re.S

使得原子 . 可以匹配任意字符，也就是\n也可以被识别

re.M 、（re.MULTILINE）

匹配时采用多行匹配模式，结合（^ 和 $）来使用

re.X 、（re.VERBOSE）

匹配时忽略正则表达式中的空格或注释

re.I、（re.IGNORECASE）

匹配过程中忽略大小写

正则扩展语法

表示

（?Limsux）

多种模式修正符号应用

（?: ）

取消单元存储功能（节约资源）

（?P< name >）

自定义模式单元的名称

（?P= name)

引用自定义模式单元

（?#）

正则注释内容

（?=）

正向先行断言

（?!）

负向先行断言

（?<=）

正向后行断言

（?<!）

负向后行断言

（?(id/name)Y |

正向：有
负向：没有
先行：向前、向右进行查找
后行：向后、向左进行查找

re模块

re.complie(pattern匹配的正则表达式, 模式修正符)

1.编译正则表达式获取正则表达式对象。
2.可以循环利用，提高程序效率

import re

ts=r'\d{3}'
print(ts,type(ts))

ts_oj=re.compile(ts)
print(type(ts_oj))

>>>

\d{3} <class 'str'>
<class '_sre.SRE_Pattern'>

返回值为正则对象

re.escape(str字符串)

对字符串进行转义处理

import re

strs='hello world!'
re_escape=re.escape(strs)
print(re_escape)

>>>
hello\ world\!

将字符串进行分割，方便操作

re.search（pattern匹配的正则表达式, str要匹配的字符串）

在字符串任意位置只能匹配一个第一个符合要求的字符就返回，没有就返回none

import re

ts=r'l'
strs='hello world!'
res=re.search(ts,strs)
print(res)

>>>
<_sre.SRE_Match object; span=(2, 3), match='l'>

re.match (pattern匹配的正则表达式, str要匹配的字符串)

**函数语法**：`re.match(pattern匹配的正则表达式, string要匹配的字符串, flags=0匹配方式)` 匹配成功re.match方法返回一个匹配的对象，否则返回None。

在字符串开头只能匹配一个第一个符合要求的字符就返回，没有就返回none

不在开头时

import re

ts=r'l'
strs='hello world!'
res=re.match(ts,strs)
print(res)

>>>
None

在开头时

import re

ts=r'l'
strs='llo world!'
res=re.match(ts,strs)
print(res)

>>>
<_sre.SRE_Match object; span=(0, 1), match='l'>

re.findall（pattern匹配的正则表达式, str要匹配的字符串,模式修正符）

对字符串进行正则匹配获取所有匹配的内容结果

import re

ts=r'l'
strs='hello world!'
print(re.findall(ts,strs))

>>>
['l', 'l', 'l']

re.finditer(pattern匹配的正则表达式, str要匹配的字符串,模式修正符)

对字符串进行正则匹配获取所有匹配的结果对象

import re

ts=r'l'
strs='hello world!'
res=re.finditer(ts,strs)
print(res)

for i in res:
    print(i)

>>>
<callable_iterator object at 0x000001D91C0E3CC0>
<_sre.SRE_Match object; span=(2, 3), match='l'>
<_sre.SRE_Match object; span=(3, 4), match='l'>
<_sre.SRE_Match object; span=(9, 10), match='l'>

re.split(pattern匹配的正则表达式, str要切割的字符串，切多少)

使用正则麦达式切割字符串

import re

ts=r'\d+'
strs='a1b2c3d4f5'
res=re.split(ts,strs)
print(res)

>>>
['a', 'b', 'c', 'd', 'f', '']

re.sub(正则表达式,替换的字符串,匹配的字符串,替换次数)

正则替换

import re

ts=r'爸爸的爸爸'
t='爷爷'
strs='爸爸的爸爸是爷爷'
res=re.sub(t,ts,strs)
print(res)

>>>
爸爸的爸爸是爸爸的爸爸

re.subn(正则表达式,替换的字符串,匹配的字符串,替换次数)

import re

ts=r'爸爸的爸爸'
t='爷爷'
strs='爸爸的爸爸是爷爷'
res=re.subn(t,ts,strs)
print(res)

>>>
('爸爸的爸爸是爸爸的爸爸', 1)

1为替换次数组成的元组

re.groups ()

打印结果对象中的模式单元,就是现实匹配内容中被括起来的不部分

import re
ts=r'AbC'   
strs='AbCdEfg'

result=re.search(ts,strs)
print(result.groups())

>>>
()
import re
ts=r'A(bC)'   
strs='AbCdEfg'

result=re.search(ts,strs)
print(result.groups())

>>>
('bC',)

正则对象

与re模块有异曲同工之妙,但是要与compile一起用

示范findall

import re
strs='爸爸的爸爸是爷爷'

ts=r'\w+'
res=re.findall(ts,strs)
print(res)

rx=re.compile(ts)
res=rx.findall(strs)
print(res)

>>>
['爸爸的爸爸是爷爷']
['爸爸的爸爸是爷爷']

应用示范


（）

1.存储字符的作用
例：假设我们要匹配到标题部分
加括号前
将标题和内容都匹配到了

import re
ts=r'<[a-z]+>.*</[a-z]+>'   
strs='<title>first</title><boby>Hello world</boby>'

result=re.search(ts,strs)
print(result)
print(result.groups())

>>>
<_sre.SRE_Match object; span=(0, 44), match='<title>first</title><boby>Hello world</boby>'>
()

加括号后
我们用<([a-z]+)>这种方式将title存储到模块单元中，并用</\1>（ \ [在存储模块中的编号]）将存储到模块单元的内容取出来，这样就把标题部分取出来

import re
ts=r'<([a-z]+)>.*</\1>'   
strs='<title>first</title><boby>Hello world</boby>'

result=re.search(ts,strs)
print(result)
print(result.groups())

>>>
<_sre.SRE_Match object; span=(0, 20), match='<title>first</title>'>
('title',)



（?Limsux）

当只有一种问题时，我们使用result=re.search(ts,strs,re.X)来去修正

import re

ts=r'A bC'   
strs='AbCdEfg'

result=re.search(ts,strs,re.X)
print(result)

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

当只有多种问题时，我们就可以使用(?ix)来去修正
例如下面既有大小写又有空格

import re

ts=r'(?ix)a bc'   
strs='AbCdEfg'

result=re.search(ts,strs)
print(result)

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



（?: ）

主要用来取消单元存储功能，节省内存的作用

取消前

import re
ts=r'A(bC)'   
strs='AbCdEfg'

result=re.search(ts,strs)
print(result.groups())

>>>
('bC',)

取消后

import re
ts=r'A(?:bC)'   
strs='AbCdEfg'

result=re.search(ts,strs)
print(result.groups())

>>>
()



（?P< name >）

因为用编号去取模式单元的内容容易搞乱，一个两是非常方便的但是成百上千就显得有些费劲，所以就引入了一个字典模式的模式单元的存储。将某个东西存储为字典模式{'biaoti': 'title'}，在进行运用，与（?P= name ）一起用效果更佳哦~

import re
ts=r'<(?P<biaoti>[a-z]+)>.*</\1>'   
strs='<title>first</title><boby>Hello world</boby>'

result=re.search(ts,strs)
print(result)
print(result.groupdict())

>>>
<_sre.SRE_Match object; span=(0, 20), match='<title>first</title>'>
{'biaoti': 'title'}



（?P= name ）

获取模式单元的内容（字典模式）,这个更上面的一起用才能展示出力量。

import re
ts=r'<(?P<biaoti>[a-z]+)>.*</(?P=biaoti)>'   
strs='<title>first</title><boby>Hello world</boby>'

result=re.search(ts,strs)
print(result)
print(result.groupdict())

>>>
<_sre.SRE_Match object; span=(0, 20), match='<title>first</title>'>
{'biaoti': 'title'}

注意：
print(result.groupdict())用这个去打印模块内容，是因为print(result.groups())已经不能满足需求了。



(?#)

正则注释,鸡肋

ts=r'(?ix)a (?#我还是个注释)bc(?#我就是个注释)'   
strs='AbCdEfg'

result=re.search(ts,strs)
print(result)

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



(?=)

当g后面有.com就匹配，所以就匹配了这个区间span=(8, 9)的g

import re

ts=r'g(?=\.com)'  #\  为转义字符
strs='g.co.du.g.com'

result=re.search(ts,strs)
print(result)
>>>
<_sre.SRE_Match object; span=(8, 9), match='g'>



(?!)

当g后面没有.com就匹配，所以就匹配了这个区间span=(0, 1)的g

import re

ts=r'g(?!\.com)'
strs='g2.co.du.g.com'

result=re.search(ts,strs)
print(result)

>>>
<_sre.SRE_Match object; span=(0, 1), match='g'>



(?<=)

当g前面有.就匹配，所以就匹配了这个区间span=(9, 10)的g

import re

ts=r'(?<=\.)g'
strs='g2.co.du.g.com'

result=re.search(ts,strs)
print(result)

>>>
<_sre.SRE_Match object; span=(9, 10), match='g'>



(?<!)

当g前面没有.就匹配，所以就匹配了这个区间span=(0, 1)的g

import re

ts=r'(?<!\.)g'
strs='g2.co.du.g.com'

result=re.search(ts,strs)
print(result)

>>>
<_sre.SRE_Match object; span=(0, 1), match='g'>

注意：
这（？=）系列指定内容必须是精确内容



（?(id/name)Y | N）

(www)?(?(1).*|\w)将www存入模块单元、？表示0个或1个修饰的原子、(?(1).*|\w) 中(1)取出模块单元中第一个单元，.*如果是就显示全部，\w不是就显示前面的字符

import re

ts=r'(www)?(?(1).*|\w)'
strs='abc.123214.com'
result=re.search(ts,strs)
print(result)

>>>
<_sre.SRE_Match object; span=(0, 14), match='www.123214.com'>


import re

ts=r'(www)?(?(1).*|\w)'
strs='abc.123214.com'
result=re.search(ts,strs)
print(result)

>>>
<_sre.SRE_Match object; span=(0, 1), match='a'>