import re
print("------------------匹配单个字符与数字---------------------------")'''
. 匹配除换行符以外的任意字符
[0123456789] []是字符集合，表示匹配中括号包含在内的任意一个字符
[sunck] 匹配"s", "u", "n", "c", "k"中的任意一个字符
[a-z] 匹配任意小写字母
[A-Z] 匹配任意小写字母
[0-9] 匹配任意数字，类似[0123456789]
[0-9a-zA-Z] 匹配任意的数字和字母
[0-9a-zA-Z_] 匹配任意的数字和字母和下划线
[^sunck] 匹配除了 "s", "u", "n", "c", "k"这几个字母以外的所有字符，中括号内的^称为脱字符，表示不匹配集合中的字符
[^0-9] 匹配所有的非数字字符
\d 匹配数字，效果同[0-9]
\D 匹配非数字字符，效果同[^0-9]
\w 匹配数字字母和下划线，效果同[0-9a-zA-Z_]
\W 匹配非数字字母下划线，效果同[^0-9a-zA-Z_]
\s 匹配任意的空白符（空号、换行、回车、换页、制表），效果同[ \f\n\r\t]
\S 匹配任意的非空白符，效果同[^ \f\n\r\t]
'''print(re.search("../练习","fanfan is a good man 6"))print(re.search("[0123456789]","fanfan is a good man 6"))print(re.search("[sunck]","fanfan is a good man 6"))print(re.findall("[^0-9]","fanfan is a good man 6"))print(re.findall("\d","fanfan is a good man 6"))print(re.findall("\D","fanfan is a good man 6"))print(re.findall("\w","fanfan is a good man 6"))print(re.findall("\W","_fanfan is a good man 6!"))print("------------------锚字符（边界字符）---------------------------")'''
^ 行首匹配，和在[]里的^不是一个意思
$ 行尾匹配
\A 匹配字符串开始，和^区别是\A只匹配字符串的开头，即使在re.M模式下也不会匹配其他行的行首
\Z 匹配字符串结束，和$区别是\Z只匹配字符串的结束，即使在re.M模式下也不会匹配其他行的行尾
\b 匹配一个单词的边界，也就是指单词和空格间的位置,
"er\b"可以匹配never, 不能匹配nerver
\B 匹配非单词边界
'''print(re.search("^fanfan ","fanfan is a good man"))#<re.Match object; span=(0, 5), match='sunck'>print(re.search("^fanfan$","fanfan is a good man"))#Noneprint(re.search("fanfan$","fanfan is a good man"))#Noneprint(re.search("man$","fanfan is a good man"))#<re.Match object; span=(16, 19), match='man'>print(re.findall("\fanfan","fanfan is a good man"))#['sunck']print(re.findall("^fanfan","fanfan is a good man\nfanfan is a nice man", re.M))#['fanfan ', 'fanfan ']print(re.findall("\Asfanfan","fanfan is a good man\nsunck is a nice man", re.M))#['fanfan ']print(re.findall("man$","fanfan is a good man\nfanfan is a nice man", re.M))#['man', 'man']print(re.findall("man\Z","fanfan is a good man\nfanfan is a nice man", re.M))#['man']print(re.search(r"er\b","never"))#<re.Match object; span=(3, 5), match='er'>print(re.search(r"er\b","nerve"))#Noneprint(re.search(r"er\b","never"))#Noneprint(re.search(r"er\B","nerve"))#<re.Match object; span=(1, 3), match='er'>print("------------------匹配多个字符---------------------------")'''
说明：下方的x,y,z均为假设的普通字符，m、n是一个非负整数，不是正则表达式的元字符
(xyz) 匹配小括号内的xyz（作为一个整体去匹配）
x? 匹配0个或者1个x
x* 匹配0个或者任意多个x（.*表示匹配0个或者任意多个字符（换行符除外））
x+ 匹配至少一个x
x{n} 匹配确定的n个x(n是一个非负整数)
x{n,} 匹配至少n个x
x{n, m} 匹配至少n个最多m个x, 注意：n<=m
x|y | 表示或，匹配的是x或y
'''print(re.findall(r"(sunck)","fanfangood is a good man.fanfan is a nice man"))#['fanfan', 'fanfan']print(re.findall(r"a?","aaa"))#['a', 'a', 'a', '']非贪婪匹配（尽可能少的匹配）print(re.findall(r"a*","aaa"))#['aaa', '']print(re.findall(r"a*","aaabaa"))#['aaa', '', 'aa', '']贪婪匹配（尽可能多的匹配）print(re.findall(r".*","aaabaa"))#['aaabaa', '']print(re.findall(r"a+","aaabaa"))#['aaa', 'aa']贪婪匹配（尽可能多的匹配）print(re.findall(r"a{3}","aaa"))#['aaa']print(re.findall(r"a{3}","aa"))#[]print(re.findall(r"a{3}","aaaaaa"))#['aaa', 'aaa']print(re.findall(r"a{3}","aaabaaa"))#['aaa', 'aaa']print(re.findall(r"a{3,}","aaaaa"))#['aaaaa']贪婪匹配（尽可能多的匹配）print(re.findall(r"a{3,}","aa"))#[]print(re.findall(r"a{3,6}","aaaaaaa"))#['aaaaaa']print(re.findall(r"((s|S)unck)","fanfan ----Fanfan "))#[('fanfan', 's'), ('fanfan', 's')]#需求：提取sunck-----manstr="fanfan is a good man!fanfan is a nice man!fanfan is a very handsome man"print(re.findall(r"^fanfan.*man$",str))#['fanfan is a good man!fanfan is a nice man!fanfan is a very handsome man']print("--------------特殊------------------")"""
*? +? ??
表示最小匹配 通常尽可能多的匹配，可以使用这种方式解决贪婪匹配
(?:x)类似（xyz），但是不表示一个组
"""print(re.findall(r"^fanfan.*?man$",str))#注释： /* part1 */ /* part2 */print(re.findall(r"//*.*?/*/",r"/* part1 */ /* part2 */"))
re模块深入
import re
'''
字符串切割
'''
str1 ="fanfan is a good man"print(str1.split(" "))print(re.split(r" +", str1))'''
re.finditer函数
原型：finditer(pattern, string, flags=0)
参数：
patter：匹配的正则表达式
string：要匹配的字符串
flag：标识位，用于控制正则表达式的匹配方式
re.I 忽略大小写
re.L 做本地化识别
re.M 多行匹配，影响^和$
re.S 使.匹配包括换行符在内的所有字符
# re.U 根据Unicode字符集解析字符，影响\W \w \B \b
re.X 使我们更灵活的格式理解正则表达式
功能：与findall类似，扫描整个字符串，返回是一个迭代器
'''
str3 ="fanfan is a good man! fanfan is a nice man! fanfan is a handsome man"
d = re.finditer(r"fanfan", str3)whileTrue:try:
l =next(d)print(l)except StopIteration as e:break'''
字符串的替换和修改
sub(pattern, repl, string, count=0, flags=0):
subn(pattern, repl, string, count=0, flags=0):
参数：
pattern:正则表达式
repl：指定狮王用来替换的字符串
string：目标字符串
count：最多替换次数
功能：在目标字符串中以正则表达式的规则匹配字符串，再把他们替换成指定的字符串，可以指定替换的次数，如果不指定，替换所有的匹配字符串
区别：前者返回一个被替换的字符串，后者返回一个元组，第一个元素被替换的字符串，第二个元素表示被替换的次数
'''
str5 ="fanfan is a good good good man"print(re.sub(r"(good)","nice", str5, count=2))print(type(re.sub(r"(good)","nice", str5)))
str6 ="fanfan is a good good good man"print(re.subn(r"(good)","nice", str6))print(type(re.subn(r"(good)","nice", str6)))# re.subn()'''
分组：
概念：除了简单的判断是否匹配之外，正则表达式还有提取子串的功能，用（）表示的就是提取分组
'''
str7 ="010-53247654"
m = re.match(r"(?P<first>(?P<second>\d{3})-(\d{8}))", str7)#使用序号获取对应组的信息，group（0）只代表的原始字符串print(m.group("first"))print(m.group(1))#查看匹配各组的情况print(m.groups())'''
编译：
当我们使用正则表达式时，re模块会干两件事
1、编译正则表达式，如果正则表达式本身不合法，会报错
2、用编译后的正则表达式去匹配对象
compile(pattern, flags=0):
参数：
pattern：要编译的正则表达式
'''
pat =r"^1(([3578]\d)|(47))\d{8}$"print(re.match(pat,"13600000000"))
re_telephone = re.compile(pat)print(re_telephone.match("13600000000"))#re模块调用#re对象调用# re.match(pattern, string, flags=0)# re_telephone.match(string)# re.search(pattern, string, flags=0)# re_telephone.search(string)# re.findall(pattern, string, flags=0)# re_telephone.findall(string)# re.finditer(pattern, string, flags=0)# re_telephone.finditer(string)# re.split(pattern, string, maxsplit=0, flags=0)# re_telephone.split(string, maxsplit=0)# re.sub(pattern, repl, string, count=0, flags=0)# re_telephone.sub(repl,string,count=0)# re.subn(pattern, repl, string, count=0, flags=0)# re_telephone.subn(repl, string, count=0, flags=0)
449
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
