regular expression regex RE 正则表达式
定义：用来简洁表达一组字符串的表达式
"PN"
"PYN""PYTN" 正则表达式表达这则数据:
"PYTHN" P(Y|YT|YTH|YTHO)?N
"PYTHON"
正则表达式的优势：简洁 （非常简单的表达字符串的特征，一行胜千言）
"PY"
"PYY"
"PYYY" 正则表达式表示：（表示无穷多个）"PYYYY" PY+
......"PYYYYYY......"
某种特点的字符串
"PY"开头：
后续存在不多于10个字符串， 正则表达式表示：
后续字符不能是"P"或"Y" PY[^PY]{0,10}"PYABC" √ "PYKXYZ" ×
正则表达式是通用的字符串表达框架
简洁表达一组字符串的表达式
针对字符串表达“简洁”和“特征”思想的工具
判断某字符串的特征归属
在文本处理中十分常用（主要应用于字符串匹配中）
表达文本类型的特征（病毒，入侵等）
同时查找或替换一组字符串
正则表达式的使用： 编译：将符合正则表达式语法的字符串转换成正则表达式特征
"PN"
"PYN""PYTN" 正则表达式表达这则数据:
"PYTHN" regex= P(Y|YT|YTH|YTHO)?N"PYTHON" 编译（特征）：p = re.compile(regex)
语法：正则表达式语法由字符和操作符构成
常见操作符
.
表示任何单个字符
[ ]
字符集，对单个字符给出取值范围
[abc]表示a,b,c,
[a-z]表示a到z的单个字符[^ ]
非字符集，对单个字符 给出排除范围
[^abc]表示非a或b或c的单个字符
*
前一个字符0次或无限次扩展
abc*表示ab，abc，abcc，abccc等
+
前一个字符1次或无限次扩展
abc+表示abc，abcc，abccc等
？
前一个字符0次或1次扩展（匹配）
abc？表示ab，abc
|
左右表达式任意一个
abc|def表示abc，def
{m}
扩展前一个字符m次（仅一个字符）
ab{2}c表示abbc
{m,n}
扩展前一个字符m至n次（含n）
ab{1,2}c表示abc，abbc
^匹配字符串开头
^abc表示abc且在一个字符串的开头
$
匹配字符串结尾
abc$表示abc且在一个字符串的结尾
( )
分组标记，内部只能使用 | 操作符
(abc)表示abc,(abc|def)表示abc,def
\d
数字等价于|0-9|
\D
匹配任意非数字
\w
单词字符，等价于|A-Za-z0-9_|
匹配字母数字下划线
\W
匹配非字母数字下划线
\s
匹配任意空白字符，等价于[\t\n\r\f]
\S
匹配任意非空字符
\A
匹配字符串开始
\Z
匹配字符串结束，如果存在换行，只匹配到换行前的结束字符串
\z
匹配字符串结束
正则表达式实例： 对应字符串
PY[TH]ON "PYTON","PYHON"
PY[^TH]?ON "PYON","PYaON","PYbON","PYcON"...
PY{:3}N (对大括号签的字符重复0-3次） "PN","PYN","PYYN""PYYYN"
经典正则表达式实例
^[A_Za-z]+$
由26个字母组成的字符串
^[A-Za-z0-9]+$
由26个字母和数字组成的字符串
^-?\d+$
整数形式的字符串
^[0-9]*[1-9][0-9]*$
正整数形式的字符串
[1-9]\d{5}
中国境内邮政编码，6位
[\u4e00-\u9fa5]
匹配中文字符
\d{3}-\d{8}|\d{4}-\d{7}
国内电话号码，010-68913536
匹配IP地址的正则表达式
IP地址字符串形式的正则表达式
（IP地址分四段，每段0-255）
\d+.\d+.\d+.\d+
\d{1,3}.\d{1.3}.\d{1,3}.\d{1,3}
精确表示：
0-99 ： [1-9]?\d 100-199:1\d{2}
200-249 :2[0-4]\d 250-255: 25[0-5]
(([1-9]?\d|1\d{2}|2[0-4]\d|25[0-5].){3}(1-9]?\d|1\d{2}|2[0-4]\d|25[0-5])
RE库的基本使用
Re库是Python的标准库
import re
正则表达式的表示类型：
raw string 类型（原生字符串类型：不包含转义符的字符串）（原生字符串与字符串
的不同是在字符串前面+小写的r）
re库采用raw string类型表示正则表达式，表示为：r"text"
例如：邮编：r "[1-9]\d{5}"
注意：当正则表达式包含转义符时：使用raw string
re.search()
在一个字符串中搜索匹配正则表达式的第一位置，返回match对象
re.match()
从一个字符串的开始位置起匹配正则表达式，返回match对象
re.findall()
搜索字符串，以列表类型返回全部能匹配的子串
re.split()
讲一个字符串按照正则表达式匹配结果进行分割，返回列表类型
re.finditer()
搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象
re.sub()
在一个字符串中替换所有匹配正则表达式的子串，返回替代后的字符串
re.search(pattern,string,flags=0)在一个字符串中搜索匹配正则表达式的 第一个位置，返回match对象pattern：正则表达式的字符串或原生字符串表示
string：待匹配字符串
flags：正则表达式使用时的控制标记
常用标记
说明
re.l
忽略正则表达式的大小写，[A-Z]能够匹配小写字符，
又叫：re.IGNORECASE
re.M
正则表达式中^操作符能够将给定的每行当作匹配开始
又叫：re.MULTILINE
re.s
正则表达式中的 . 操作符能够匹配所有字符，默认匹配除换行外的所有字符
又叫：re.DOTALL
import re
match = re.search(r"[1-9]\d{5}","BIT 100081")
if match:
print(match.group(0)) #打印出匹配的结果
# 输出：
100081
re.match(pattern,string,flags=0)
从一个字符串的的开始位置起匹配正则表达式，返回match对象（参数与search相同）
import re
#match = re.match(r"[1-9]\d{5}","BIT 100081")
#print(match.group(0)) #从开始匹配并不是我们所要求的的，单单输出，会报错
match = re.match(r"[1-9]\d{5}","100081 BIT")
if match:
print(match.group(0))
re.findall (pattern,string,flags=0)
搜索字符串，以列表类型返回全部能匹配的子串 # 类型与上面一样
import re
Is =re.findall(r"[1-9]\d{5}","BIT100081 YSU100084")
print(Is)
# 输出：
['100081', '100084']
re.split(pattern,string,maxsplit=0,flags=0)
将一个字符串按照正则表达式匹配结果进行分割，返回列表类型
其中三项与其它相同（匹配的部分去掉）
maxsplit ：最大分割数，剩余部分作为最后一个元素输出
import re
Is = re.split(r"[1-9]\d{5}","BIT100081 TSU100084")
print(Is)
# 输出：
['BIT', ' TSU', '']
# 对上式子加入maxsplit
import re
Is = re.split(r"[1-9]\d{5}","BIT100081 TSU100084",maxsplit=1)
print(Is) #当maxsplit等于，只是将第一个给分割了
#输出：
['BIT', ' TSU100084']
re.finditer(pattern,string,flags=0)
搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象
（参数和第一个一样）
import re
for m in re.finditer(r"[1-9]\d{5}","BIT100081 TSU100084"):
if m:
print(m.group(0))
# 输出：
100081
100084
re.sub(pattern.repl,string,count=0,flags=0)
在一个字符串中替换所有匹配正则表达式的子串，返回替代换后的字符串（用一个新的字符串取代正则表达式匹配的字符串，并与原来的字符串相组合，返回一个新的字符串组合）
repl: 替换匹配字符串的字符串
count：匹配的最大替换次数
import re
Is =re.sub(r"[1-9]\d{5}",":zipcode","BIT100081 TSU100084")
print(Is)
# 输出：
BIT:zipcode TSU:zipcode
re库的另一种等价用法
rst = re.search(r"[1-9]\d{5}","BIT 100081")
函数式用法：一次性操作
面向对象用法：编译后的多次操做
pat = re.compite(r"[1-9]\d{5}")
rst = pat.search("BIT 100081")
(通过一次编译，当多次使用时，加快运行速度）
regex = re.compile(pattern,flags=0)
将正则表达式的字符串形式编译成正则表达式对象
（regex才是正则表达式的表示）
regex.search (）# 这样引用时，将参数去去掉
match对象
属性
说明
.string
待匹配的文本
.re
匹配时使用pattern对象
.pos
正则表达式搜索文本的开始位置
.endpos
正则表达式搜索文本的结束位置
import re
match = re.search(r"[1-9]\d{5}","BIT 100081")
if match:
print(match.group(0))
# 使用type来检查type的类型
print(type(match))
# 输出：
100081
<class 're.Match'>
match对象的方法：
方法
说明.group(0)
获得匹配后的字符串
.start()
匹配字符串在原始字符串的开始位置
.end()
匹配字符串在原始字符串的结束位置
.span()
返回（.start(), .end()）元组类型，包含两个元素
import re
m= re.search(r"[1-9]\d{5}","BIT 100081 TSU100084")
print(m.string)
print(m.re)
#输出：
BIT 100081 TSU100084
re.compile('[1-9]\\d{5}') # 这代表在内部只有经过compile之后的表达式才是正则表达式
#
import re
m= re.search(r"[1-9]\d{5}","BIT 100081 TSU100084")
print(m.string)
print(m.re)
print(m.pos)
print(m.endpos) #最开始的位置到最后的位置
print(m.group(0)) # match对象只包含一次对象的结果，返回的是第一次匹配的结果
print(m.start()) # 一个对象的起始位置
print(m.end())
# 输出：
BIT 100081 TSU100084
re.compile('[1-9]\\d{5}')
0
21
100081
4
10
Re库的贪婪匹配和最小匹配
import re
m= re.search(r"PY.*N","PYANBNCNDN")
print(m.group()) # 根据不同长度，会有4种结果
# 输出
PYANBNCNDN # 默认贪婪匹配
贪婪匹配：
Re库默认采用贪婪匹配，即输出匹配最长的子串
最小匹配：生成最小匹配
import re
m= re.search(r"PY.*？N","PYANBNCNDN")
print(m.group()) # 根据不同长度，会有4种结果
# 输出
PYAN
操作符
说明
*？
前一个字符0次或无限次扩展，最小匹配
+？
前一个字符1次或无限次扩展，最小匹配
？？
前一个字符0次或1次扩展，最小匹配
{m,n}?
扩展前一个字符m至n次（含n），最小匹配
想要了解更多：您可以关注微信公众号：foryouos
