正则表达式
正则的组成：原子，元字符，模式修正符【其他语言中可能存在定界符】
基础知识
原子
组成正则表达式的最小单位，一个正则表达式至少需要一个原子
1所有可见字符都是原子：a，b，c，d...A,B,C,D...你，我，他...+-*/##@
2所有不可见字符也是原子：\t \n \r ...
3正则专用转义字符：
\d 表示0~9之间任意【一个】字符 ->[0123456789]自定义原子列表格式
\D 表示除了0~9之外的任意【一个】字符 ->[^0123456789]自定义排除列表
\s 表示任意【一个】空白字符（不可见） \t \n都算 -> [\n\r\t\v\f]自定义原子列表格式
\S 表示任意【一个】非空白字符（可见字符） ->[^ \n\r\t\v\f]自定义排除列表
\w 表示0~9 a~z A~Z和_中的任意【一个】字符 ->[a-zA-Z0-9_]自定义原子列表格式
\W 表示除了0~9 a~z A~Z之外的任意【一个】字符 ->[^a-zA-Z0-9_]自定义排除列表
. 表示任意一个字符【除了\n】
正则表达式本质是字符串，单独使用没有意义，正则表达式需要配合相关的函数和方法
search方法
import re
#准备正则表达式
pattern = r'baidu'#python 中要使用r模式的字符串表示
#正则查找的字符串
url = 'http://www/baidu.com'
#匹配操作
result = re.search(pattern,url)
#search(pattern: Pattern[AnyStr]【字符串】,string: AnyStr【要查找的字符串】,flags: Union[int, RegexFlag] = ...) -> Optional[Match[AnyStr]]
print(result)
#<_sre.SRE_Match object; span=(11, 16), match='baidu'>原子测试
#准备正则表达式
pattern = r'\d'
#正则查找的字符串
url = 'http://www/bai1du.c9om'
#匹配操作
result = re.search(pattern,url)
#search(pattern: Pattern[AnyStr]【字符串】,string: AnyStr【要查找的字符串】,flags: Union[int, RegexFlag] = ...) -> Optional[Match[AnyStr]]
print(result)
#<_sre.SRE_Match object; span=(14, 15), match='1'> 只能匹配到第一个内容元字符（一）：【原子修饰符】
1 []自定义原子列表 #表示自定义原子列表中的任意一个字符,如果多个字符在asscii码中连续，可以进行缩写，例如[0123456789] 可改写成-> [0-9]
2 [^]自定义排除列表 #表示原子列表之外的任意一个字符,如果多个字符在asscii码中连续，可以进行缩写，例如[0123456789] 可改写成-> [0-9]
3 与数量相关的元字符
以下只修饰前面的一个原子
+ 表示一个以上的修饰原子[1~正无穷] -> {1,}
？ 表示0个或1个修饰的原子 [0或者1] -> {0,1}
* 表示任意个修饰的原子 [0~正无穷] -> {0,}
{m} 表示必须是m个修饰原子
{m,n} 表示修饰的原子数量是m到n之间的数量（包含m也包含n）
{m,} 表示修饰的原子是m个到正无穷（包含m）
{,n} 表示0-n个修饰的原子（包含0页包含n）
import re
#准备正则表达式
pattern1 = r'[13579]'#1或者3或者5或者7或者9
url1 = 'dfbv2dv1fdfv4'
result1 = re.search(pattern1,url1)
print(result1)
#<_sre.SRE_Match object; span=(7, 8), match='1'>
pattern2 = r'[^0123456789]'
url2 = 'asd123'
result2 = re.search(pattern2,url2)
print(result2)
#<_sre.SRE_Match object; span=(0, 1), match='a'>
pattern3 = r'go?gle'#问号？修饰o
url3 = 'www.gogle.com'
result3 = re.search(pattern3,url3)
print(result3)
#<_sre.SRE_Match object; span=(0, 1), match='a'>
pattern4 = r'go+gle'
url4 = 'www.goooooooogle.com'
result4 = re.search(pattern4,url4)
print(result4)
#<_sre.SRE_Match object; span=(4, 16), match='goooooooogle'>
pattern5 = r'go*gle'
url5 = 'www.ggle.com'
result5 = re.search(pattern5,url5)
print(result5)
#<_sre.SRE_Match object; span=(4, 8), match='ggle'>
pattern6 = r'go{3,}gle'
url6 = 'www.goooooooogle.com'
result6 = re.search(pattern6,url6)
print(result6)
元字符（二）
1 \A 表示限定内容必须在整个字符串的开头部位
2 \Z 表示限定内容必须在整个字符串的结束部位
3 ^ 相当于\A，并且支持多行匹配模式，记得在后面加上：'re.M'-模式修正符号
4 $ 相当于\Z，并且支持多行匹配模式
额外补充：
多行模式：如果字符串中包含\n,则可以在匹配时使用多行匹配模式，多行匹配模式
就是将每一行当做独立的字符串进行匹配。
注意：多行模式需要使用模式修正符
5 \b 表示能够当做英文单词分割的字符，（除了字母和数字，都是词边界 汉子作为字母处理）
6 \B 表示不能够当做英文单词分割的字符，（非词边界，就是字母和数字）代表一个字符
7 | 表示选择关系，左右的内容二选一 非常重要，是运算规则
8 () 1.改变正则表达式中的优先级关系
2.将多个原子视为一个原子处理，方便使用元字符，【可以叫做组 或者模式单元】
3.将匹配的内容当做模式单元进行存储
import re
pattern1 = r'\Ahttp'
url1 = 'http://www.google.com'
result1 = re.search(pattern1,url1)
print(result1)
#<_sre.SRE_Match object; span=(0, 4), match='http'>
pattern2 = r'm\Z'
url2 = 'http://www.google.coma'
result2 = re.search(pattern2,url2)
print(result2)
#None
pattern3 = r'^http'
url3 = '谷歌的地址是\nhttp://www.google.coma'
result3 = re.search(pattern3,url3,re.M)#'re.M'-模式修正符号
print(result3)
#<_sre.SRE_Match object; span=(7, 11), match='http'>
pattern4 = r'\bmy' #\b的作用是my前必须是可以作为分隔符号的东西
url4 = 'if you lose myself' #如果是if you lose123myself，则输出none
result4 = re.search(pattern4,url4)
print(result4)
#<_sre.SRE_Match object; span=(12, 14), match='my'>
pattern5 = r'\bmy\b' #my必须是个单词才能被匹配
url5 = 'if you lose my self'
result5 = re.search(pattern5,url5)
print(result5)
#<_sre.SRE_Match object; span=(12, 14), match='my'>
pattern6 = r'\bmy'
url6 = 'if you lose myself，if you feel my love'
result6 = re.findall(pattern6,url6) #findall是多次匹配
print(result6)
#['my', 'my']
pattern7 = r'\bmy\B' #my的左边是词边界，my的右边不能是词边界
url7 = 'if you lose myself，if you feel my love'
result7 = re.findall(pattern7,url7) #findall是多次匹配
print(result7)
#['my']
pattern8 = r'ab|cd' #ab或者cd
url8 = '我喜欢的字母是abcd'
result8 = re.search(pattern8,url8) #findall是多次匹配
print(result8)
#<_sre.SRE_Match object; span=(7, 9), match='ab'>
pattern9 = r'a(b|c)d' #acd或者abd
url9 = '我喜欢的字母是acd'
result9 = re.search(pattern9,url9) #findall是多次匹配
print(result9)
#<_sre.SRE_Match object; span=(7, 10), match='acd'>
pattern10 = r'(go)+gle'
url10 = 'http://www.gogogogle.com'
result10 = re.search(pattern10,url10) #findall是多次匹配
print(result10)
#<_sre.SRE_Match object; span=(11, 20), match='gogogogle'>
模式修正符
设定匹配的一些额外的规则。
re.A 或者re.ASCII 在ASCII模式下进行正则匹配操作 ASCII码只有数字字母下划线
re.U 或者re.UNICODE 在UNICODE模式下进行正则匹配操作 默认情况下
re.S 使得原子.可以匹配任意字符，包含\n
re.M 或者re.MULTILINE 匹配操作在多行模式下进行 都是与^和$相关
#以下暂缺
re.X 或者re.VERBOSE 匹配的时候忽略正则表达式中的空格或者注释
re.I 或者re.IGNORECASE 匹配过程中忽略大大小写
import re
pattern1 = r'\w+' #w是字母数字下划线
url1 = '我love你他love我我也love大家'
result1 = re.search(pattern1,url1,re.U)
print(result1)
#<_sre.SRE_Match object; span=(0, 20), match='我love你他love我我也love大家'>
pattern2 = r'\w+'
url2 = '我love你他love我我也love大家'
result2 = re.findall(pattern2,url2,re.A)
print(result2)
#['love', 'love', 'love']
pattern3 = r'e.b'
url3 = 'google\nbaidu'
result3 = re.findall(pattern3,url3,re.A)
print(result3)
#[] 因为.可以匹配除了\n以外的任意字符（基础知识）
pattern4 = r'e.b'
url4 = 'google\nbaidu'
result4 = re.findall(pattern4,url4,re.S)
print(result4)
#['e\nb']
pattern5 = r'^www'
url5 = 'www.baidu.com\nwww.google.com'
result5 = re.findall(pattern5,url5,re.MULTILINE)
print(result5)
#['www', 'www']
转义字符的应用
字符串：\n \r \t \\ ... 因为在正则的元字符和原子当中，使用了部分的符号作为语法，为了匹配这些符号的单纯字符格式，在正则表达式中添加\即可去掉意义，获取字符
import re
pattern1 = r'www.baidu.com' #.可以代替任何字符,除了\n
str1 = 'http://www1baidu1com'
result1 = re.search(pattern1,str1)
print(result1)
#<_sre.SRE_Match object; span=(0, 13), match='www1baidu1com'>
pattern2 = r'www\.baidu\.com' #去掉.在正则表达式中的功能
str2 = 'http://www.baidu.com' #如果改成http://www1baidu1com就匹配不到了
result2 = re.search(pattern2,str2)
print(result2)
#<_sre.SRE_Match object; span=(7, 20), match='www.baidu.com'>
pattern3 = r'[百度]' #[]的作用是在“百”中“度”任选其一
str3 = 'www.baidu.com[百度]'
result3 = re.search(pattern3,str3)
print(result3)
#<_sre.SRE_Match object; span=(14, 15), match='百'>
pattern4 = r'\[百度\]' #去掉[]在正则表达式中的功能
str4 = 'www.baidu.com[百度]'
result4 = re.search(pattern4,str4)
print(result4)
#<_sre.SRE_Match object; span=(13, 17), match='[百度]'>
扩展之后正则语法
1 (?Limsux) 多种模式修正符的应用 L不常用 2 (?:) 取消单元存储功能 节省资源 3 (?P) 自定义模式单元的名称 4 (?P=name) 获取自定义模式单元的内容 5 (?#) 正则注释内容，解析器不会处理该内容(用的不多) 6 (?=) 正向先行断言 （零宽断言） 有的话就匹配，没有就不匹配 #正向 -> 有 负向 -> 相当于没有 #先行 -> 向前/向右进行查找 后行 ->向后/向左进行查找 7 (?!) 负向先行断言 （零宽断言） #正向 -> 有 负向 -> 相当于没有 #先行 -> 向前/向右进行查找 后行 ->向后/向左进行查找 8 (?<=) 正向后行断言（零宽断言） # 正向 -> 有 负向 -> 相当于没有 # 先行 -> 向前/向右进行查找 后行 ->向后/向左进行查找 9 (? 有 负向 -> 相当于没有 # 先行 -> 向前/向右进行查找 后行 ->向后/向左进行查找 #零宽断言注意事项 #1.可以同时存在前行和后行 #2.后行注意事项，宽度必须指定，不能是可变宽度 10 (?(id/name)Y|N) 根据模式单元是否存在决定使用Y的规则（模式单元存在）或者是N的规则
import re
#正则表达式
#1 (?Limsux) 多种模式修正符的应用 L不常用
pattern1 = r'baidu'
pattern2 = r'(?imx)bai du' #i是不区分大小写，x是去除正则的空白
str1 = 'www.BaiDu.com[百度]'
str2 = 'www.BaiDu.com[百度]'
result1 = re.search(pattern1,str1,re.I)
print(result1)
#<_sre.SRE_Match object; span=(4, 9), match='BaiDu'>
result2 = re.search(pattern2,str2)
print(result2)
#<_sre.SRE_Match object; span=(4, 9), match='BaiDu'>
#2 (?:) 取消单元存储功能
pattern3 = r'bai(du)' #将()中的内容作为模式单元处理(这是自带的功能)
pattern4 = r'(bai)(du)'
pattern5 = r'bai(?:du)+' #“?:”取消了()单元存储功能
str3 = 'www.baidu.com'
str4 = 'www.baidu.com'
str5 = 'www.baidudududududu.com'
result3 = re.search(pattern3,str3)
print(result3)
print(result3.groups())
#<_sre.SRE_Match object; span=(4, 9), match='baidu'>
#('du',)
result4 = re.search(pattern4,str4)
print(result4.groups())
#('bai', 'du')
result5 = re.search(pattern5,str5)
print(result5)
print(result5.groups())
#<_sre.SRE_Match object; span=(4, 19), match='baidudududududu'>
# 3 (?P) 自定义模式单元的名称
pattern6 = r'<([a-z]+)>.*' #\1是想取出整个模式单元中第一个内容
#索引模式单元的应用
pattern7 = r'<(?P[a-z]+)>.*'
str6 = '百度 www.baidu.com'
str7 = '百度 www.baidu.com'
result6 = re.search(pattern6,str6)
print(result6)
print(result6.groups())
#<_sre.SRE_Match object; span=(0, 17), match='百度 '>
#('title',)
result7 = re.search(pattern7,str7)
print(result7)
print(result7.groupdict())
#<_sre.SRE_Match object; span=(0, 43), match='百度 www.baidu.com'>
#{'biaoti': 'title'}
# 4 (?P=name) 获取自定义模式单元的内容
pattern8 = r'<(?P[a-z]+)>.*' #字典模式单元的存储
str8 = '百度 www.baidu.com'
result8 = re.search(pattern8,str8)
print(result8)
print(result8.groupdict())
#<_sre.SRE_Match object; span=(0, 17), match='百度 '>
#{'biaoti': 'title'}
# 5 (?#) 正则注释内容
pattern9 = r'(?i)bai(?#我就是个注释)du'
str9 = 'www.baidu.com'
result9 = re.search(pattern9,str9)
print(result9)
#<_sre.SRE_Match object; span=(4, 9), match='baidu'>
# 6 (?=) 正向先行断言 （零宽断言）
pattern10 = r'lmonkey(?=\.com)' #lmonkey后有没有.com，有的话就匹配，没有的话就不匹配
str10 = 'www.lmonkey.cn-www.lmonkey.com-www.lmonkey.net-www.lmonkey.org'
result10 = re.search(pattern10,str10)
print(result10)
#<_sre.SRE_Match object; span=(19, 26), match='lmonkey'>
# 7 (?!) 负向先行断言 （零宽断言）
pattern11 = r'lmonkey(?!\.com)' #lmonkey后没有.com的都要
pattern12 = r'lmonkey\d(?!\.com)'
str11 = 'www.lmonkey.cn-www.lmonkey.com-www.lmonkey.net-www.lmonkey.org'
str12 = 'www.lmonkey1.cn-www.lmonkey2.com-www.lmonkey3.net-www.lmonkey4.org'
result11 = re.search(pattern11,str11)
print(result11)
#<_sre.SRE_Match object; span=(4, 11), match='lmonkey'>
result12 = re.findall(pattern12,str12)
print(result12)
#['lmonkey1', 'lmonkey3', 'lmonkey4']
# 8 (?<=) 正向后行断言（零宽断言）
pattern13 = r'(?<=xxyd\.)lmonkey\d' #前面有xxyd的才要
str13 = 'www.lmonkey1.cn-bbs.lmonkey2.com-xxyd.lmonkey3.net-aaa.lmonkey4.org'
result13 = re.search(pattern13,str13)
print(result13)
#<_sre.SRE_Match object; span=(38, 46), match='lmonkey3'>
# 9 (?
result16 = re.search(pattern16,str16)
print(result16)
#<_sre.SRE_Match object; span=(0, 4), match='bbs.'>
正则表达式的书写
1.用户名（简单的正则）
a.设定规则（有字符，必须3个字符以上，可以使用数字，不能使用特殊符号，可以使用_）
b.书写以下符合规则的实例
#congha
#congha666
#cong_ha
#cong_666
c.正则书写
d.验证正则（正确/错误）
2.ip地址
a.设定规则（四个数字段，每个数字段用.分割，数字范围0~255）
b.书写以下符合规则的实例
#192.168.0.1
#127.0.0.1
#0.0.0.0
#255.255.255.255
c.正则书写
d.验证正则（正确/错误）
3.电话号码
a.设定规则(纯数字：11位数字，第2,3个号码有限制)
b.书写以下符合规则的实例
# 13012345678
# 13112345678
# ...
# 13912345678
# 147...
# 15112345678
# ...
# 15912345678
# 170...
# ...
# 179...
# 180...
# ...
# 189...
c.正则书写
d.验证正则（正确/错误）
4.身份证
a.设定规则(18位内容，数字和字母X组成，X只能在最后一位，部分内容需要年月日的需求)
b.书写以下符合规则的实例
#110345(地址) 19991224(出生日期) 123(顺序码) 9(校验码)
#120234 20000509 123 x
c.正则书写
d.验证正则（正确/错误）
import re
#正则表达式
#1.用户名
pattern1 = r'^\w{3,}$' #
pattern2 = r'^\w{3,}$'
#2.ip地址
#pattern3 = r'\d(?#1位数)|\d[1-9]\d(?#2位数) | 1\d{2}(?#3位数100-199) | 2[0-4]\d (?#3位数200-249) | 25[0-5] \.'
#pattern3 = r'^((?:\d)|(?:[1-9]\d)|(?:1\d{2})|(?:2[0-4]\d)|(?:25[0-5]))\.$'
pattern3 = r'^((?:[1-9]?|1\d|2[0-4]\d)|(?:25[0-5]))\.$' #简化合并 ”提取公因式“
pattern4 = r'^(((?:([1-9]?|1\d|2[0-4])\d)|(?:25[0-5]))\.){3}((?:([1-9]?|1\d|2[0-4])\d)|(?:25[0-5]))$'
#3.电话号码
#pattern5 = r'130|131|147|15\d|17\d|18\d\d{8}'
pattern5 = r'1(47|[3578]\d) \d{8}' # 合并 这里有个空格，可以在re.search中用re.X去掉空格
#4.身份证
pattern6 = r'\d{6} (18|19|[2-9]\d)\d{2} (0[1-9]|1[0-2]) (0[1-9]|[12]\d|3[01]) \d{3}(\d|x)'
#检测字符串
# 1.用户名
str1 = 'congha'
str2 = 'ch' #错误的用户名
#2.ip地址
str3 = '00.'
str3_1 = '199.'
str4 = '192.168.0.1'
# 3.电话号码
str5 = '17012345678'
#4.身份证
str6 = '11034519930502123x'
#匹配操作
# 1.用户名
result1 = re.search(pattern1,str1)
print(result1) #<_sre.SRE_Match object; span=(0, 6), match='congha'>
result2 = re.search(pattern2,str2)
print(result2) #None
#2.ip地址
result3 = re.search(pattern3,str3)
print(result3) #None
result3_1 = re.search(pattern3,str3_1)
print(result3_1) #<_sre.SRE_Match object; span=(0, 4), match='199.'>
result4 = re.search(pattern4,str4)
print(result4) #<_sre.SRE_Match object; span=(0, 11), match='192.168.0.1'>
# 3.电话号码
result5 = re.search(pattern5,str5,re.X)
print(result5) #<_sre.SRE_Match object; span=(0, 11), match='17012345678'>
#4.身份证
result6 = re.search(pattern6,str6,re.X)
print(result6) #<_sre.SRE_Match object; span=(0, 18), match='11034519930502123x'>
print(result6.groups())re模块：正则表达式的专用模块，提供正则相关的操作方法
re模块的方法
complie() 1.编译正则表达式，获取正则表达式对象 2.可以循环利用，提高程序效率
#格式：re.compile（正则字符串，模式修正符）
#返回值：正则对象
escape() 对字符串进行转义处理(仅处理非数字和字母的字符串)
#格式：re.escape(字符串)
#结果：字符串
findall() 对字符串进行正则匹配，获取所有匹配的内容结果
#格式：re.findall(正则表达式，匹配字符串，模式修正符)
#结果：列表
finditer() 对字符串进行正则匹配，获取所有匹配的结果对象
# 格式：re.finditer(正则表达式，匹配字符串，模式修正符)
# 结果：包含所有匹配结果的迭代器
match() 对字符串的开头对字符串进行正则匹配,当匹配到第一个结果时就停止匹配，返回结果对象
#格式：re.match(正则表达式,匹配的字符串,模式修正符)
#结果：匹配结果对象
search() 是在任意位置对字符串进行正则匹配,当匹配到第一个结果时就停止匹配，返回结果对象
# 格式：re.match(正则表达式,匹配的字符串,模式修正符)
# 结果：匹配结果对象
split() 使用正则表达式切割字符串
#格式：re.split(正则表达式,匹配的字符串,最大切割次数)
#结果：切割后的字符串组成的列表
sub() 正则替换
#格式：re.sub(正则表达式，替换的字符串，匹配的字符串,替换次数)
#结果：匹配字符串被替换后的字符串
subn() 正则替换
#格式：re.subn(正则表达式，替换的字符串，匹配的字符串,替换次数)
#结果：由替换之后的字符串和替换次数组成的元组！
import re
#compile() 1.编译正则表达式，获取正则表达式对象 2.可以循环利用，提高程序效率
pattern1 = r'\d{13}'
print(pattern1,type(pattern1)) #\d{13}
pattern1_obj = re.compile(pattern1,re.I)
print(pattern1_obj,type(pattern1_obj)) #re.compile('\\d{13}', re.IGNORECASE)
# escape() 对字符串进行转义处理
s1= 'how old are you? i am 25'
result1 = re.escape(s1)
print(result1) #how\ old\ are\ you\?\ i\ am\ 25
# findall() 对字符串进行正则匹配，获取所有匹配的内容结果
pattern2 = r'baidu'
s2 = 'www.baidu.com-www.BAIDU.com-www.BaiDu.com'
result2 = re.findall(pattern2,s2,re.I)
print(result2) #['baidu', 'BAIDU', 'BaiDu']
# finditer()
pattern3 = r'baidu'
s3 = 'www.baidu.com-www.BAIDU.com-www.BaiDu.com'
result3 = re.finditer(pattern3,s3,re.I)
print(result3) #
for i in result3:
print(i) #
# <_sre.SRE_Match object; span=(4, 9), match='baidu'>
# <_sre.SRE_Match object; span=(18, 23), match='BAIDU'>
# <_sre.SRE_Match object; span=(32, 37), match='BaiDu'>
#search()
pattern4 = r'lmonkey'
str4 = 'www.lmonkey.com;mp4.lmonkey.com;bbs.lmonkey.com'
result4 = re.search(pattern4,str4)
print(result4) #<_sre.SRE_Match object; span=(4, 11), match='lmonkey'>
print(type(result4)) #
#match()
pattern5 = r'lmonkey'
str5 = 'lmonkey.com;mp4.lmonkey.com;bbs.lmonkey.com'
result5 = re.match(pattern5,str5)
print(result5) #<_sre.SRE_Match object; span=(0, 7), match='lmonkey'>
print(type(result5)) #
#split() 使用正则表达式切割字符串
s6 = '10世9贫，凑得8两7钱6分5毫4厘，况且3心2意，1等下流'
pattern6 = r'\d+' #按照数字分割
result6 = re.split(pattern6,s6)
result6_2 = re.split(pattern6,s6,3) #切割3次
print(result6) #['', '世', '贫，凑得', '两', '钱', '分', '毫', '厘，况且', '心', '意，', '等下流']
print(result6_2) #['', '世', '贫，凑得', '两7钱6分5毫4厘，况且3心2意，1等下流']
#sub() 正则替换
s7 = '蜡笔小新的爸爸是野原广志，蜡笔小新的妈妈是野原美伢，蜡笔小新的妹妹是野原葵'
pattern7 = r'蜡笔小新'
replace_s = '野原新之助'
result7 = re.sub(pattern7,replace_s,s7,2) #替换两次
print(result7) #野原新之助的爸爸是野原广志，野原新之助的妈妈是野原美伢，蜡笔小新的妹妹是野原葵
#subn() 正则替换
s8 = '蜡笔小新的爸爸是野原广志，蜡笔小新的妈妈是野原美伢，蜡笔小新的妹妹是野原葵'
pattern8 = r'蜡笔小新'
replace_s = '野原新之助'
result8 = re.subn(pattern8,replace_s,s8,2) #替换两次
print(result8) #('野原新之助的爸爸是野原广志，野原新之助的妈妈是野原美伢，蜡笔小新的妹妹是野原葵', 2) 正则对象的方法(借助compile方法获取) rx代表正则对象
findall() 使用正则表达式对指定的字符串进行匹配，获取所有匹配结果组成的列表
#格式：rx.findall(要匹配的字符串)
#结果：所有匹配结果组成的列表
finditer() 使用正则表达式对象对指定的字符串进行匹配，获取所有匹配结果对象组成的迭代器
#格式：rx.finditer(要匹配的字符串)
#结果：迭代器
match() 使用正则表达式对象对指定的字符串开头进行匹配，返回第一次匹配到的结果对象
#格式：rx.match(要匹配的字符串)
#结果：匹配结果对象
search() 使用正则表达式对象对指定的字符串进行匹配，返回第一次匹配到的结果对象
#格式：rx.search(要匹配的字符串)
#结果：匹配结果对象
split() 正则切割字符串
# 格式：rx.split(s)
# 结果：切割之后的字符组成的列表
sub() 正则替换
#格式：rx.sub(要替换承成的内容，被替换的字符串，替换次数)
#结果：替换之后的字符串
subn() 正则替换
#格式：rx.subn(要替换承成的内容，被替换的字符串，替换次数)
#结果：替换之后的字符串和次数组成的元组
flags 获取当前正则对象的模式修正符
pattern 获取正则表达式的字符串格式
groups 模式单元的个数
groupindex
import re
#正则对象
#匹配操作1 re模块 （正则表达式，字符串） => 结果对象
#匹配操作2 正则表达式对象 （字符串） => 结果对象
#findall() 使用正则表达式对指定的字符串进行匹配，获取所有匹配结果组成的列表
s1 = 'www.baidu.com;mp4.BAIDU.com;image.BaiDu.com'
rx1 = re.compile(r'baidu',re.I)
print(rx1,type(rx1)) #re.compile('baidu', re.IGNORECASE)
result1 = rx1.findall(s1)
print(result1) #['baidu', 'BAIDU', 'BaiDu']
#finditer() 使用正则表达式对指定的字符串进行匹配，获取所有匹配结果组成的列表
s2 = 'www.baidu.com;mp4.BAIDU.com;image.BaiDu.com'
rx2 = re.compile(r'baidu',re.I)
print(rx2,type(rx2)) #re.compile('baidu', re.IGNORECASE)
result2 = rx2.finditer(s2)
print(result2) #
for i in result2:
print(i)
# <_sre.SRE_Match object; span=(4, 9), match='baidu'>
# <_sre.SRE_Match object; span=(18, 23), match='BAIDU'>
# <_sre.SRE_Match object; span=(34, 39), match='BaiDu'>
#match() 使用正则表达式对象对指定的字符串开头进行匹配，返回结果对象
s3 = 'baidu.com;mp4.BAIDU.com;image.BaiDu.com'
rx3 = re.compile(r'baidu',re.I)
print(rx3,type(rx3))
result3 = rx3.match(s3)
print(result3) #<_sre.SRE_Match object; span=(0, 5), match='baidu'>
#search()
s4 = 'tieba.baidu.com;mp4.BAIDU.com;image.BaiDu.com'
rx4 = re.compile(r'baidu',re.I)
print(rx4,type(rx4))
result4 = rx4.search(s4)
print(result4) #<_sre.SRE_Match object; span=(6, 11), match='baidu'>
#split() 正则切割字符串
s5 = '10世9贫，凑得8两7钱6分5毫4厘，况且3心2意，1等下流'
rx5 = re.compile(r'\d+')
print(rx5,type(rx5))
result5 = rx5.split(s5)
print(result5) #['', '世', '贫，凑得', '两', '钱', '分', '毫', '厘，况且', '心', '意，', '等下流']
#sub() 正则替换
s6 = '蜡笔小新的爸爸是野原广志，蜡笔小新的妈妈是野原美伢，蜡笔小新的妹妹是野原葵'
rx6 = re.compile(r'的')
print(rx6,type(rx6))
result6 = rx6.sub('の',s6,2)
print(result6) #蜡笔小新の爸爸是野原广志，蜡笔小新の妈妈是野原美伢，蜡笔小新的妹妹是野原葵
#subn() 正则替换
s7 = '蜡笔小新的爸爸是野原广志，蜡笔小新的妈妈是野原美伢，蜡笔小新的妹妹是野原葵'
rx7 = re.compile(r'的')
print(rx7,type(rx7))
result7 = rx7.subn('の',s7,2)
print(result7) #('蜡笔小新の爸爸是野原广志，蜡笔小新の妈妈是野原美伢，蜡笔小新的妹妹是野原葵', 2)
# flags 获取当前正则对象的模式修正符
rx8 = re.compile(r'\w+',re.I)
print(rx8.flags) #34 34是模式修正符的编号
# pattern 获取正则表达式的字符串格式
rx9 = re.compile(r'(?sx)\w+',re.I)
print(rx9.pattern) #(?sx)\w+
# groups
rx10 = re.compile(r'(?sx)\w+(\d)\S')
print(rx10.groups) #1 说明有1个模式单元(\d)
# groupindex
rx11 = re.compile(r'(?sx)(?P\w+)(\d)(?P\S)')
print(rx11.groupindex) #{'a': 1, 'b': 3} 正则对象的扩展用法(re下不可以这么用)
findall(s,开始位置,介绍位置) finditer(s,开始位置,介绍位置) match(s,开始位置,介绍位置) search(s,开始位置,介绍位置)
import re
s = 'https://www.lmonkey.com'
pattern = r'lmonkey' #正则表达式
rx = re.compile(pattern)
result = rx.findall(s)
print(result) #['lmonkey']
s2 = 'https://www.lmonkey.com'
pattern2 = r'lmonkey' #正则表达式
rx2 = re.compile(pattern2)
result2 = rx2.findall(s2,0,10) #匹配0-10的字符
print(result2) #[]
s3 = 'https://www.lmonkey.com'
pattern3 = r'lmonkey' #正则表达式
rx3 = re.compile(pattern2)
result3 = rx3.findall(s3,10) #匹配10以后的字符
print(result3) #['lmonkey']