【学习笔记之Python篇】正则表达式

正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配，而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 | N）

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

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'>