一、正则概述
re 模块，提供了正则表达式模式
re模块使python可以使用所有的正则
re.match 函数
原型：match(pattern,string,flags=0)
参数：
pattern：匹配的正则表达式
string：要匹配的字符串
flags：标志位，用于控制正则表达式的匹配方式,
值如下：
re.I 忽略大小写
re.L 做本地用户识别
re.M 多行匹配，影响^和$
re.S 使.匹配包括换行符在内的所有字符
re.U 根据Unicode字符集解析字符，影响\w,\W,\b,\B
re.X 使我们以更灵活的格式理解正则表达式
功能：尝试从字符串的起始位置匹配一个模式，
如果不是起始位置匹配成功的话，返回None
代码：
import re
#www.baidu.com
r = re.match('www','www.baidu.com')
print(r)
print("---------------------")
r1 = re.match('www','www.baidu.www.com').span()
print(r1)
print("---------------------")
print(re.match('www','wwW.baidu.com',flags=re.I))
print("---------------------")
print(re.search('kris','good kris,kris is good'))
print("---------------------")
print(re.findall('kris','good kris,kris is good'))
结果显示：
<_sre.SRE_Match object; span=(0, 3), match='www'>
---------------------
(0, 3)
---------------------
<_sre.SRE_Match object; span=(0, 3), match='wwW'>
---------------------
<_sre.SRE_Match object; span=(5, 9), match='kris'>
---------------------
['kris', 'kris']
二、正则表达式的元字符
'''
------单个字符---------
.匹配除换行符以外的任意字符
[0123456789] []是字符集合，表示匹配方括号中所包含的任意一个字符
[sunck] 匹配‘s’,'u','n','c','k' 中任意一个字符
[A-Z] 匹配任意大写字母
[a-z] 匹配任意小写字母
[0-9] 匹配任意数字，类似[0123456789]
[0-9a-zA-Z_]匹配任意数字、字母和下划线
[^sunck] 匹配除了sunck以外的所有字符
[^0-9] 匹配除了数字以外的所有字符
\d 匹配数字，类似[0-9]
\D 匹配非数字，类似[^\d]
\w 匹配数字、字母、下划线，类似[0-9a-zA-Z]
\W 匹配非数字、字母、下划线，类似[^0-9a-zA-Z]
\s 匹配任意空白符（空格，换行，换页，制表），
效果同[ \f\n\r\t]
\S 匹配任意的非空白符,效果同[^ \f\n\r\t]
'''
栗子：
print(re.search('.','sunck is a good man'))
print(re.findall('\w','sunck is a good man7'))
print(re.findall('\d','sunck is 4a goo6d man7'))
'''
------------锚字符-------------
^ 行首匹配，和在[]里不是一个意思
$ 行尾匹配
\A 匹配字符串开始，和^的区别是：\A只匹配整个字符串的开头，
即使在re.M模式下也不会匹配其它行的行首
\Z 匹配字符串结尾，和$的区别是：\Z只匹配整个字符串的结尾，
即使在re.M模式下也不会匹配其它行的结尾
\b 匹配一个单词的边界，也就是指单词和空格间的位置
'er\b'可以匹配never,不能匹配nerve
\B 匹配非单词的边界，也就是指单词和空格间的位置
'''
print('********************************')
print(re.search("^sunck","sunck is a good man"))
print(re.search("man$","sunck is a good man"))
print(re.search("\Asunck","sunck is a good man"))
print('********************************')
print(re.findall("^sunck","sunck is a good man\nsunck is a nice man",re.M))
print(re.findall("\Asunck","sunck is a good man\nsunck is a nice man",re.M))
print('********************************')
print(re.findall("man$","sunck is a good man\nsunck is a nice man",re.M))
print(re.findall("man\Z","sunck is a good man\nsunck is a nice man",re.M))
print('********************************')
print(re.search(r"er\b",'never'))
print(re.search(r"er\b",'nerve'))
print(re.search("er\B",'never'))
print(re.search("er\B",'nerve'))
'''
------------匹配多个字符-------------
说明： 下方的x,y,z均为假设的普通字符，n,m(非负整数)不是正则表达式的元字符
(xyz) 匹配小括号内的xyz（作为一个整体）
x？ 匹配0个或1个x(非贪婪)
x* 匹配0个或者任意个x（.*表示匹配0个或者任意多个字符（换行符除外））
x+ 匹配至少一个x
x{n} 匹配确定个数n的x
x{n,} 匹配至少n个x
x{n,m}匹配至少n个至多m个x
x|y |表示或，匹配x或y
'''
print(re.findall(r"(xyz)",'fhajnxyzjnfkdxyz'))
print(re.findall(r"a?",'aaa'))
print(re.findall(r"a*",'aaababaa'))#贪婪匹配（尽可能多的匹配）
print(re.findall(r"a+",'aaabaaaaa'))
print(re.findall(r"a{2}",'aaabaa'))
print(re.findall(r"a{3,}",'aaabaaaaaaa'))
print(re.findall(r"a{3,6}",'aaaaaaaba'))
print(re.findall(r"((s|S)unck)",'sunck-Sunck'))
#需求，提取sunck……man
str = "sunck is a good man ! sunck is a nice man!sunck is a handsome man"
print(re.findall(r"sunck.*?man",str))
"""
------特殊------
*? +? x? 最小匹配，通常都是尽可能多的匹配，可以使这种方式解决
贪婪匹配
(?:x) 类似(xyz)，但不表示一个组
"""
#注释： /* part1 */ /* part2 */
print(re.findall(r"//*.*?/*/",r'/* part1 */ /* part2 */'))
三、re模块的深入
字符串切割
import re
str1 = "sunck is a good man"
print(str1.split( ))
print(re.split(r" +",str1))
finditer(pattern,string,flags=0)
pattern：匹配的正则表达式
string：要匹配的字符串
flags：标志位，用于控制正则表达式的匹配方式,
功能：与findall相似，扫描整个字符串，返回的是一个迭代器。
str ='sunck is a good man!sunck is a nice man!sunck is a handsme man'
d = re.finditer(r"sunck",str)
while True:
try:
l =next(d)
print(l)
except StopIteration as e:
break
字符串的替换和修改
sub(pattern,repl,string,count=0)
subn(pattern,repl,string,count=0)
pattern：正则表达式
repl： 指定用来替换的字符串
string：目标字符串
count： 最多替换次数
功能： 在目标字符串中，以正则表达式的规则匹配字符串，再把它们匹配成指定的字符串。可以指定替换次数，如果不指定替换所有的匹配字符串
区别：前者返回一个被替换的字符串，后者返回一个元组。
str2 ="sunck is a nice nice nice man "
print(re.sub(r"nice",'good',str2,count=1))
print(re.sub(r"nice",'good',str2))
print(type(re.sub(r"nice",'good',str2,count=1)))
print(re.subn(r"nice",'good',str2))
print(re.subn(r"nice",'good',str2,count=1))
print(type(re.subn(r"nice",'good',str2,count=1)))
分组：
概念： 除了简单的判断是否匹配之外，正则表达式还有提取子串的功能。用()表示的就是提取分组。
str3 ='029-873645697'
m = re.match(r"(?P<first>\d{3})-(?P<last>\d{8})",str3)
#使用序号获取对应组的信息，group(0)一直代表的原始字符串
print(m.group(0))#029-87364569
print(m.group(1))#029
print(m.group("first"))#029
print(m.group(2))#87364569
print(m.groups())#('029', '87364569')
编译：当我们使用正则表达式时会做两件事
1.编译正则表达式
2.用编译后的正则表达式去匹配对象
compile(pattern,flags=0)
代码示例：
pat =r"^1(([3578]\d)|(47))\d{8}$"
print(re.match(pat,'13774552736'))
#编译成正则对象
re_telphone = re.compile(pat)
print(re_telphone.match('13474552736'))
替换：
re.match()
re_telphone.match(string)
re.search()
re_telphone.search(string)
re.findall()
re_telphone.findall(string)
re.finditer()
re_telphone.finditer(string)
re.split()
re_telphone.split(string)
re.sub()
re_telphone.sub(repl,string,count=0)
re.subn()
re_telphone.subn(repl,string,count=0)
