正则表达式

import re
# pip 包管理工具
'''
12345678901

'''
'''
re.match函数
原型：def 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。（从头匹配）

'''
# www.baidu.com

print(re.match('www','www.baidu.com'))  #从起始位置匹配，其余的不行
print(re.match('www','ww.baidu.com'))
print(re.match('www','baidu.wwwcom'))
print(re.match('www','wwW.baidu.com'))
print(re.match('www','wwW.baidu.com',flags=re.I).span) #re.I大小写不敏感

# 扫描整个字符串，返回从起始位置成功的匹配（从头匹配）

print("______________________")

'''
re.search函数
原型：search(pattern, string, flags=0)
参数：
pattern：匹配的正则表达式
string：要匹配的字符串
flags：标志位，用于控制正则表达式的匹配的方式
功能:扫描整个字符串，并返回第一个成功匹配的（不需要从头开始匹配）

'''
print(re.search('sunck','good man is sunck!sunck is niece'))

'''
re.findall函数
原型：findall(pattern, string, flags=0)
参数：
pattern：匹配的正则表达式
string：要匹配的字符串
flags：标志位，用于控制正则表达式的匹配的方式
功能：扫描整个字符串，并返回结果列表
'''
print(re.findall('sunck','good man is sunck!Sunck is niece',flags=re.I))

import re
print('——————匹配单个字符与数字————————')

r'''
.：匹配除换行符意外的任意字符
[0123456789]:[]是字符集合，表示匹配[]中所包含的任意一个字符
[sunck]:匹配's','u','n','c','k'中任意一个字符
[a-z]:匹配任意小写字母
[A-Z]:匹配任意大写字母
[0-9]:匹配任意数字，类似于[0123456789]
[0-9a-zA-Z]：匹配任意的数字和字母
[0-9a-zA-Z_]:匹配任意的数字、字母和下划线
[^sunck]:匹配除了sunck这几个字母以外的所有字符，[]里的^称为脱字符，表示不匹配集合中的字符
[^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(".",'sunck is a good man'))
print(re.search("[0123456789]",'sunck5 is a good man6'))
print(re.search("[sunck]",'sunck is a good man'))
print(re.findall('\d','sunck is a good man2'))
print(re.findall('[^\d]','sunck is a good man2'))
print(re.findall('.','sunck is a good\n man2',flags=re.S))

print('------------锚字符（边界字符）------------')
'''
^:行首匹配，和在[]里的^不是一个意思
$:行尾匹配
\A：匹配字符串开始，它和^的区别是，\A只匹配整个字符串的开头，即使在re.M模式下不会匹配它行的行首
\Z:匹配字符串结束，它和$的区别是，\Z只匹配整个字符串的结束，即使在re.M模式下不会匹配它行的行尾

sunck is a good man
\b:匹配一个单词的边界，也就是指单词和空格间的位置,注意用r进行转义
    'er\b'可以匹配never,不能匹配nerve
\B：匹配非单词边界，
    'er\B'
'''
# 行首和行尾
print(re.search('^sunck','sunck is a good man'))
print(re.search('man$','sunck is a good man'))
# \A和^的区别
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\n sunck is a nice man',re.M))

# b和\B
print(re.search(r'er\b','never'))
print(re.search(r'er\b','nerve'))
print(re.search(r'er\B','never'))
print(re.search(r'er\B','nerve'))

print('-------------------匹配多个字符--------------------')
'''
说明：下方的x、y、z均为假设的普通字符，n、m是非负整数，不是正则表达式的元字符
(xyz):匹配小括号内的xyz(作为一个整体去匹配）,()是整体的意思
x?匹配0个或者1个x（非贪婪匹配：尽可能少的匹配）
x*匹配0个或者任意多个x(贪婪匹配：尽可能多的匹配）
.*:表示匹配任意多个字符（换行符除外）
x+:匹配至少一个x（不包含0个，且是贪婪匹配）
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)','sunckgood sunck is a good man'))
print(re.findall(r'o?','oooboo'))
print(re.findall(r'o*','oooboo'))
print(re.findall(r'o+','oooboo'))
print(re.findall(r'o{3}','oooboo'))
print(re.findall(r'o{2,}','oooboo'))
print(re.findall(r'o{2,5}','ooooooo'))
print(re.findall(r'o{2,}|b','oooboo'))
print(re.findall(r'((s|S)unck)','sunck--Sunck'))

# 需求，提取sunck……man这样的字符串
print(re.findall(r'sunck.*?man','sunck is a good man!sunck is a nice man!sunck is a handsome man',re.M))

print('--------------------特殊---------------------')
'''
*? +? x?最小匹配，通常都是尽可能多的匹配，可以使用这种带方式解决贪婪匹配
(?:x):类似（xyz)，但不表示一个组
'''
# 注释：/* part1 */  /* part1 */
print(re.findall(r'//*.*?/*/',r'/* part1 */ /* part2 */'))

def checkPhone(str):
    pat=r'(1([34578]\d|(47))\d{8})'
    res=re.findall(pat,str)
    return res
print(checkPhone('dfghjko18983052777sdfghj'))

import re
'''
字符串切割
'''
str1='sunck is a good man'
print(str1.split(" "))
print(re.split(r' +',str1))

'''
re.finditer函数
原型：finditer(pattern, string, flags=0
string:要匹配的字符串
flags：标志位，用于控制正则表达式的匹配的方式
功能：与findall类似，扫描整个字符串，返回的是一个迭代器,需要用next访问。
'''
str3='sunck is a good man!sunck is a niece man!sunck is a handsome man'
d=re.finditer(r'(sunck)',str3)
while True:
    try:
        l=next(d)
        print(d)
    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:最多替换次数
flags:标志位，用于控制正则表达式的匹配的方式
功能：在目标字符串中，以正则表达式的规则匹配字符串，再把他们替换成指定的字符串。可以指定替换的次数，如果不指定，替换所有的匹配字符串。
区别：前者返回一个被替换的字符串，后者返回一个元组，第一个元素被替换的字符串，第一个元素表示被替换的次数。
'''
str5='sunck is a good good good man'
print(re.sub(r'(good)','nice',str5,2))
print(type(re.sub(r'(good)','nice',str5,2)))
print(re.subn(r'(good)','nice',str5,2))
print(type(re.subn(r'(good)','nice',str5,2)))

'''
分组：
概念：除了简单的判断是否匹配之外，正则表达式还有提取字符串的功能。用()表示的就是提取分组
'''
str6='010-53247654'
m=re.match(r'(?P<first>(\d{3})-(?P<last>\d{8}))',str6)
# 使用序号获取对应组的信息，group(0)一直代表的原始字符串
print(m.group(0))
print(m.group(1))
print(m.group(2))
print(m.group(3))
print(m.group('first'))
# 查看匹配各组的情况
print(m.groups())

'''
编译：当我们使用正则表达式时，re模块会干两件事
1.编译正则表达式，如果正则表达式本身不合法，会报错
2.用编译后的正则表达式去匹配对象
compile(pattern, flags=0)
pattern:要编译的正则表达式
flags:
'''
pat=r'(1([34578]\d|(47))\d{8})'
re_telephone=re.compile(pat)
print(re.match(pat,'13600000000')) #原来的写法
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, flags=0)
# re.subn(pattern, repl, string, count=0, flags=0)
# re_telephone.subn(repl, string, count=0, flags=0)