Python ☞ day 11

Python学习笔记之 正则表达式

re模块概述：
Python自1.5以后增加了re的模块，提供了正则表达式模式
re模块使python语言拥有了全部的正则表达式功能

• 判断手机号

import re
'''
给你一串字符串，判断这是否是手机号码
'''
def checkPhone(str):
    if len(str) != 11:
        return False
    elif str[0] != "1":
        return False
    elif str[1:3] != "39" and str[1:3] != "30":
        return False
    for i in range(3,11):
        if str[i] < "0" or str[i] > "9":
            return False
    return True

def checkPhone2(str):
    #13915233241
    pat = r"^1(([3578]\d)|(47))\d{8}$"
    #pat = r"(1(([3578]\d)|(47))\d{8})"
    res = re.match(pat, str)
    return res

print(checkPhone2("13915233241"))
print(checkPhone2("12915233241"))
print(checkPhone2("14715233241"))

checkPhone2("jskdlfjk13859468556jsldfjlk18829552219sdfad")

'''
qq      6到10位，全是数字    
email   suncksunck@163.com
phone   010-55322623
user    6到12位
passwdd
ip
'''

re_QQ = re.compile(r"^[1-9]\d{5,9}$")
print(re_QQ.search("234567890092"))


#qq   381347268@qq.com
#163    sdfj@163.com
#126    dsf@126.com
# 邮箱正则
re_Mail = re.compile(r"((^[a-z])([a-z1-9]{3,4})(@)([a-z1-9]{3,4})(.com$)")

# print(re_Mail.search("38151325@qqaa.com"))
# #(.com$)
print(re.search("(.com$)|(.net$)","jskdlfj.net"))
print(re.search("([a-z0-9]{2,4})","1515aa3333"))
print(re.search("((^[a-zA-Z1-9][a-zA-Z1-9]{3,8})(@)([a-z0-9]{2,4})((.com)|(.net)))","381347@268.net"))

re.match函数

re.match函数
原型：match(pattern, string, flags=0)
参数：
patter：匹配的正则表达式
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").span())
# 打印结果：<_sre.SRE_Match object; span=(0, 3), match='www'>
# 打印结果：如果加了.span()    (0, 3)
print(re.match("www","ww.baidu.com"))
# 打印结果：None
print(re.match("www","baidu.wwwcom"))
# 打印结果：None
print(re.match("www","wwW.baidu.com"))
# 打印结果：None
print(re.match("www","wwW.baidu.com", flags=re.I))
# 打印结果：<_sre.SRE_Match object; span=(0, 3), match='www'>
#扫描整个字符串，返回从起始位置成功的匹配

re.search函数

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

print(re.search("sunck", "good man is sunck! sunck is nice"))
# 打印结果：<_sre.SRE_Match object; span=(12, 17), match='sunck'>

re.findall函数

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

print(re.findall("sunck", "good man is sunck! sunck is nice"))
# 打印结果：['sunck', 'sunck']
print(re.findall("sunck", "good man is sunck! SuNck is nice",flags=re.I))
# 打印结果：['sunck', 'SuNck']

元字符

• ----------匹配单个字符与数字----------

.               匹配除换行符以外的任意字符
[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(".", "sunck is a good man"))
# 打印结果：<_sre.SRE_Match object; span=(0, 1), match='s'>

print(re.search("[0123456789]", "sunck is a good man 9"))
# 打印结果：<_sre.SRE_Match object; span=(20, 21), match='9'>

print(re.search("[sunck]", "sunck is a good man 9"))
# 打印结果：<_sre.SRE_Match object; span=(0, 1), match='s'>

print(re.findall("[^0-9]", "sun9ck is a8 6 go2od man 9"))
# 打印结果：['s', 'u', 'n', 'c', 'k', ' ', 'i', 's', ' ', 'a', ' ', ' ', 'g', 'o', 'o', 'd', ' ', 'm', 'a', 'n', ' ']

print(re.findall("\d", "sun9ck is a8 6 go2od man 9"))
# 打印结果：['9', '8', '6', '2', '9']

print(re.findall("\w", "_sunck is a good man"))
# 打印结果：['_', 's', 'u', 'n', 'c', 'k', 'i', 's', 'a', 'g', 'o', 'o', 'd', 'm', 'a', 'n']

print(re.findall("\W", "_sunck is a good man"))
# 打印结果：[' ', ' ', ' ', ' ']

• ----------锚字符(边界字符)----------

^               行首匹配（以什么开头），和在[]里的^不是一个意思
$               行尾匹配（以什么结尾）
\A              匹配字符串开始，它和^的区别是：\A只匹配整个字符串的开头，即使在re.M模式下也不会匹配它行的行首
\Z              匹配字符串结尾，它和^的区别是：\Z只匹配整个字符串的结尾，即使在re.M模式下也不会匹配它行的结尾
\b              匹配一个单词的边界，也就是指单词和空格间的位置
                'er\b'可以匹配never，不能匹配evere
\B              匹配非单词边界



print(re.search("^sunck", "sunck is a good man"))
# 打印结果：<_sre.SRE_Match object; span=(0, 5), match='sunck'>
print(re.search("^sunck$", "sunck is a good man"))
# 打印结果：None
print(re.search("^man", "sunck is a good man"))
# 打印结果：None
print(re.search("man$", "sunck is a good man"))
# 打印结果：<_sre.SRE_Match object; span=(16, 19), match='man'>
print()

print(re.findall("\Asunck", "sunck is a good man\nsunck is a nice man", re.M))
# 打印结果：['sunck']
print(re.findall("^sunck", "sunck is a good man\nsunck is a nice man", re.M))
# 打印结果：['sunck', 'sunck']

print(re.findall("man\Z", "sunck is a good man\nsunck is a nice man", re.M))
# 打印结果：['man']
print(re.findall("man$", "sunck is a good man\nsunck is a nice man", re.M))
# 打印结果：['man', 'man']

print(re.search(r"er\b", "never "))
# 打印结果：<_sre.SRE_Match object; span=(3, 5), match='er'>
print(re.search(r"er\b", "nerve"))
# 打印结果：None
print(re.search(r"er\B", "never"))
# 打印结果：None
print(re.search(r"er\B", "nerve"))

• ----------匹配多个字符----------

说明：下方的x、y、z、均为假设的普通字符，n、m均为非负整数不是正则表达式的元字符
(xyz)       匹配小括号内的xyz(作为一个整体去匹配)
x?          匹配0个或者一个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("(sunck)", "sunckgood is a good man, sunck is a nice man"))
# 打印结果：['sunck', 'sunck']

print(re.findall("a?", "aaa"))  #非贪婪匹配(尽可能少的匹配)
# 打印结果：['a', 'a', 'a', '']
print(re.findall("a*", "aaabbaa"))  #贪婪匹配(尽可能多的匹配)
#  打印结果：['aaa', '', '', 'aa', '']
print(re.findall("a+", "aaabbaa"))  #贪婪匹配(尽可能多的匹配)
#  打印结果：['aaa', 'aa']
print(re.findall("a{3}", "aaaaaabbaaa"))
#  打印结果：['aaa', 'aaa', 'aaa']
print(re.findall("a{3,}", "aaaaaabbaaa"))   #贪婪匹配(尽可能多的匹配)
#  打印结果：['aaaaaa', 'aaa']
print(re.findall("a{3,6}", "aaaaabbaaa"))
#  打印结果：['aaaaa', 'aaa']
print(re.findall(r"((s|S)unck)", "sunck---Sunck"))
#  打印结果：[('sunck', 's'), ('Sunck', 'S')]

#需求，提取sunck……man
str = "sunck is a good man! sunck is a nice man! sunck is a handsome man"
print(re.findall("(sunck.*?man)", str))
# 打印结果：['sunck is a good man', 'sunck is a nice man', 'sunck is a handsome man']

• ----------特殊----------

*?      +?      x?      最小匹配  通常都是尽可能多的匹配，可以使用这种解决贪婪匹配

(?:x)                   类似(xyz),但不表示一个组


#列子：匹配注释：    /*  part1   */  /*  part2   */
print(re.findall(r"//*.*/*/",r"/*  part1   */  /*  part2   */"))
# 打印结果：['/*  part1   */  /*  part2   */']       只是找到了一部分
print(re.findall(r"//*.*?/*/",r"/*  part1   */  /*  part2   */"))
# 打印结果：['/*  part1   */', '/*  part2   */']         找到了两部分

re模块的深入

• 字符串切割

str1 = "sunck     is a good man"
print(str1.split(" "))
print(re.split(r" +", str1))

• re.finditer函数

re.finditer函数
原型：finditer(pattern, string, flags=0)
参数：
patter：匹配的正则表达式
string：要匹配的字符串
flags：标志位，用于控制正则表达式的匹配方式
功能：与findall类似，扫描整个字符串，返回的是一个迭代器


str2 = "sunck is a good man! sunck is a nice man! sunck is a handsome man!"
d = re.finditer(r"sunck", str2)
while True:
    try:
        l = next(d)
        print(d)
    except  StopIteration as e:
        break

• 字符串的替换和修改

sunck is a good man
字符串的替换和修改
sub(pattern, repl, string, count=0)
subn(pattern, repl, string, count=0)
参数：
pattern：    正则表达式(规则)
repl：       指定的用来替换的字符串
string：     目标字符串
count：      最多替换次数
功能：在目标字符串中以正则表达式的规则匹配字符串，再把它们替换成指定的字符串。可以指定的替换的次数，如果不指定，替换所有的字符串

区别：sub返回一个被替换的字符串；subn返回一个元组，第一个元素是被替换的字符串，第二个元素表示被替换的次数


str5 = "sunck is a good good good man"
print(re.sub(r"(good)","nice",str5))
# 打印结果：sunck is a nice nice nice man
print(re.sub(r"(good)","nice",str5, count=2))
# 打印结果：sunck is a nice nice good man
print(type(re.sub(r"(good)","nice",str5)))
# 打印结果：<class 'str'>

print(re.subn(r"(good)","nice",str5))
# 打印结果：('sunck is a nice nice nice man', 3)
print(type(re.subn(r"(good)","nice",str5)))
# 打印结果：<class 'tuple'>

• 分组

概念：除了简单的判断是否匹配之外，正则表达式还有提取子串的功能。用()表示的就是提取分组


str3 = "010-52365561"
m = re.match(r"(\d{3})-(\d{8})", str3)
c = re.match(r"(?P<first>\d{3})-(\d{8})", str3)     # ?P<>给组起名
print(m)
# 打印结果：<_sre.SRE_Match object; span=(0, 12), match='010-52365561'>
print(m.group(0))   #使用序号获取对应组的信息，group(0)--代表原始的字符串
# 打印结果：010-52365561
print(m.group(1))
# 打印结果：010
print(m.group(2))
# 打印结果：52365561
print(m.groups())   #查看匹配的各组的情况
# 打印结果：('010', '52365561')
print(c.group("first"))
# 打印结果：010

• 编译

编译：当我们使用正则表达式时，re模块会干两件事
1、编译正则表达式，如果正则表达式不合法，会报错
2、用编译后的正则表达式去匹配对象
compile(pattern, flags=0)
pattern：要编译的正则表达式

pat = r"^1(([3578]\d)|(47))\d{8}$"
print(re.match(pat, "13625656562"))
#编译正则表达式
re_telephon = re.compile(pat)
print(re_telephon.match("13626565656"))



# re模块调用
# re对象调用
# re.match(pattern, string, flags=0)
# re_telephon.match(string)

# re.search(pattern, string, flags=0)
# re_FlagsType.search(string)

# re.findall(pattern, string, flags=0)
# re_FlagsType.findall(string)

# re.finditer(pattern, string, flags=0)
# re_FlagsType.finditer(string)

# re.split(pattern, string, maxsplit=0, flags=0)
# re_telephon.split(string, maxsplit=0)

# re.sub(pattern, repl, string, count=0, flags=0)
# re_telephon.sub(repl, string, count=0)

# re.subn(pattern, repl, string, count=0, flags=0)
# re_telephon.subn(repl, string, count=0, flags=0)