python正则表达式
正则表达式
关注公众号“轻松学编程”了解更多。
1.常用需求
1.1判断qq号
需求：设计一个方法，传入一个qq号，判断这个qq号是否合法
""" 分析 1.全数字 2.位数：5~12 3.第一位不能为0 """ def checkQQ(str): #不管传入的str是否合法，我们假设合法 result = True #寻找条件推翻最初的假设 try: #判断是否是全数字 num = int(str) #判断位数 if len(str) >= 4 and len(str) <= 11: #判断是否以数字0开头 if str[0] == '0': result = False else: result = False except BaseException: result = False return result print(checkQQ("1490980463434"))考虑：如果要用正则表达式实现上述需求，该怎么做？
1.2判断手机号码
需求：设计一个方法，传入一个手机号码，判断这个手机号码是否合法
""" 分析： 1.全数字 2.位数：11位 3.开头只能是1 4.第二位可以为3，4，5，6，7，8 """ def checkPhone(str): result = True try: #判断是否是全数字 int(str) #判断位数 if len(str) == 11: #判断开头是否为1 if str[0] == '1': #判断第二位的数字 if str[1] != '3' and str[1] != '4' and str[1] != '5' and str[1] != '6' and str[1] != '7' and str[1] != '8': result = False else: result = False else: result = False except BaseException: result = False return result print(checkPhone("18501970795"))考虑：如果要用正则表达式实现上述需求，该怎么做？
2.正则概述
正则表达式（英语：Regular Expression，在代码中常简写为regex、regexp或RE）使用单个字符串来描述、匹配一系列符合某个句法规则的字符串搜索模式。
搜索模式可用于文本搜索和文本替换。
正则表达式是由一个字符序列形成的搜索模式。
当你在文本中搜索数据时，你可以用搜索模式来描述你要查询的内容。
正则表达式可以是一个简单的字符，或一个更复杂的模式。
正则表达式可用于所有文本搜索和文本替换的操作
而在python中，通过内嵌集成的re模块，程序员们可以直接调用来实现正则匹配。正则表达式模式被编译成一系列的字节码，然后由用C编写的匹配引擎执行。
3.re模块简介
Python 自1.5版本起增加了re 模块，它提供 Perl 风格的正则表达式模式。
re 模块使 Python 语言拥有全部的正则表达式功能。
re 模块也提供了与这些方法功能完全一致的函数，这些函数使用一个模式字符串做为它们的第一个参数。
4.正则表达式的元字符
4.1 匹配单个字符与数字
. 匹配除换行符以外的任意字符
[0123456789] []是字符集合，表示匹配方括号中所包含的任意一个字符
[good] 匹配good中任意一个字符
[a-z] 匹配任意小写字母
[A-Z] 匹配任意大写字母
[0-9] 匹配任意数字，类似[0123456789]
[0-9a-zA-Z] 匹配任意的数字和字母
[0-9a-zA-Z_] 匹配任意的数字、字母和下划线
[^good] 匹配除了good这几个字母以外的所有字符，中括号里的^称为脱字符，表示不匹配集合中的字符
[^0-9] 匹配所有的非数字字符
\d 匹配数字，效果同[0-9]
\D 匹配非数字字符，效果同[^0-9]
\w 匹配数字，字母和下划线,效果同[0-9a-zA-Z_]
\W 匹配非数字，字母和下划线，效果同[^0-9a-zA-Z_]
\s 匹配任意的空白符(空格，回车，换行，制表，换页)，效果同[ \r\n\t\f]
\S 匹配任意的非空白符，效果同[^ \f\n\r\t]
print(re.findall("\d", "_sunck is 66a go8od man 3"))
print(re.findall("[A-Z]","_sunck is 66a go8oD man 3"))
print(re.findall("[a-z]","_sunck is 66a go8od man 3"))
print(re.findall("[\S]","_sunck is 66a go8od man 3"))
print(re.findall("[\W]","_sunck is 66a go8od man 3"))
输出：
['6', '6', '8', '3']
['D']
['s', 'u', 'n', 'c', 'k', 'i', 's', 'a', 'g', 'o', 'o', 'd', 'm', 'a', 'n']
['_', 's', 'u', 'n', 'c', 'k', 'i', 's', '6', '6', 'a', 'g', 'o', '8', 'o', 'd', 'm', 'a', 'n', '3']
[' ', ' ', ' ', ' ', ' ']
4.2 锚字符(边界字符)
^ 行首匹配，和在[]里的^不是一个意思,"^"要写到字符串的前面
$ 行尾匹配,"$"要写到匹配的字符串后面
\A 匹配字符串的开始，它和^的区别是,\A只匹配整个字符串的开头，即使在re.M模式下也不会匹配其它行的行首
\Z 匹配字符串的结束，它和$的区别是,\Z只匹配整个字符串的结束，即使在re.M模式下也不会匹配它行的行尾
\b 匹配一个单词的边界，也就是值单词和空格间的位置
'er\b'可以匹配never,不能匹配nerve
\B 匹配非单词边界
print(re.search("^sunck", "sunck is a good man"))
print(re.search("man$", "sunck is a good man"))
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(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(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"))
输出：
<_sre.SRE_Match object; span=(0, 5), match='sunck'>
<_sre.SRE_Match object; span=(16, 19), match='man'>
['sunck', 'sunck']
['sunck']
['man', 'man']
['man']
<_sre.SRE_Match object; span=(3, 5), match='er'>
None
None
<_sre.SRE_Match object; span=(1, 3), match='er'>
#匹配qq邮箱，5~12位，第一位不为0
#匹配所有邮箱：r"[a-z0-9_]+@[a-z0-9]+\.[a-z]{2,4}"
import re
print(re.findall(r"^[1-9]\d{4,11}@qq\.com$","123456@qq.com"))
print(re.findall(r"^[1-9]\d{4,11}@qq\.com$","0123456@qq.com"))
print(re.findall(r"^[1-9]\d{4,11}@qq\.com$","123456@qq.co"))
4.3匹配多个字符
说明：下方的x、y、z均为假设的普通字符,n、m（非负整数），不是正则表达式的元字符
(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
import re
print(re.findall(r"a?", "aaa"))#非贪婪匹配(尽可能少的匹配)
print(re.findall(r"a*", "aaabaa"))#贪婪匹配(尽可能多的匹配)
print(re.findall(r"a+", "aaabaaaaaa"))#贪婪匹配(尽可能多的匹配)
print(re.findall(r"a{3}", "aaabaa"))
print(re.findall(r"a{3,}", "aaaaabaaa"))#贪婪匹配(尽可能多的匹配)
print(re.findall(r"a{3,6}", "aaaabaaa"))
print(re.findall(r"((s|S)unck)", "sunck--SuNck--Sunck"))
#需求，提取sunck……man,
str = "sunck is a good man!sunck is a nice man!sunck is a very handsome man"
print(re.findall(r"sunck.*?man", str))
输出：
['a', 'a', 'a', '']
['aaa', '', 'aa', '']
['aaa', 'aaaaaa']
['aaa']
['aaaaa', 'aaa']
['aaaa', 'aaa']
[('sunck', 's'), ('Sunck', 'S')]
['sunck is a good man', 'sunck is a nice man', 'sunck is a very handsome man']
4.4特殊
*? +? x? 最小匹配.* +通常都是尽可能多的匹配，可以使用这种解决贪婪匹配(?:x) 类似(xyz),但不表示一个组
# /* part1 */ /* part2 */
print(re.findall(r"/\*.*?\*/","/* part1 */ /* part2 */"))
输出：
['/* part1 */', '/* part2 */']
re模块中常用功能函数
1 compile()
编译正则表达式模式，返回一个对象的模式。（可以把那些常用的正则表达式编译成正则表达式对象，这样做的目的是为了可以提高一点效率
格式：
re.compile(pattern,flags=0)
pattern: 编译时用的表达式字符串。
flags 编译标志位，用于修改正则表达式的匹配方式，如：是否区分大小写，多行匹配等
flags定义包括：
re.I：使匹配对大小写不敏感
re.L：表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
re.M：多行模式
re.S：’ . ’并且包括换行符在内的任意字符（注意：’ . ’不包括换行符）
re.U： 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库re.X VERBOSE 详细模式。该模式下正则表达式可以是多行，忽略空白字符，并可以加入注释。
代码演示：
import re tt = "Tina is a good girl, she is cool, clever, and so on..." rr = re.compile(r'\w*oo\w*') print(rr.findall(tt)) #查找所有包含'oo'的单词 #执行结果如下： #['good', 'cool']
2 match()
决定RE是否在字符串刚开始的位置匹配。//注：这个方法并不是完全匹配。当pattern结束时若string还有剩余字符，仍然视为成功。想要完全匹配，可以在表达式末尾加上边界匹配符’$’。检测不成功则返回None。
格式：
re.match(pattern, string, flags=0)
代码演示：
import re print(re.match('com','comwww.runcomoob').group()) print(re.match('com','Comwww.runcomoob',re.I).group()) print(re.match("com$","com122@qq.com")) print(re.match(r"^[1-9]\d{4,11}@qq\.com$","23344555@qq.com")) 输出： com Com None <_sre.SRE_Match object; span=(0, 15), match='23344555@qq.com'>
3 search()
格式：
re.search(pattern, string, flags=0)
re.search函数会在字符串内查找模式匹配,只要找到第一个匹配然后返回一个对象，如果字符串没有匹配，则返回None。
代码演示：
import re print(re.search('\dcom','www.4comrunoob.5com').group()) print(re.search("a+","aabaaaa")) print(re.findall("a+","aabaaaa")) 输出： 4com <_sre.SRE_Match object; span=(0, 2), match='aa'> ['aa', 'aaaa']
4 findall()
re.findall遍历匹配，可以获取字符串中所有匹配的字符串，返回一个列表。
格式：
re.findall(pattern, string, flags=0)
代码演示：
import re p = re.compile(r'\d+') print(p.findall('o1n2m3k4')) 输出： ['1', '2', '3', '4']import re tt = "Tina is a good girl, she is cool, clever, and so on..." rr = re.compile(r'\w*oo\w*') print(rr.findall(tt)) 输出： ['good', 'cool']
5 finditer()
搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器。找到 RE 匹配的所有子串，并把它们作为一个迭代器返回。
格式：
re.finditer(pattern, string, flags=0)
代码分配：
import re iter = re.finditer(r'\d+','12 drumm44ers drumming, 11 ... 10 ...') for i in iter: print(i) print(i.group()) print(i.span()) 输出： <_sre.SRE_Match object; span=(0, 2), match='12'> 12 (0, 2) <_sre.SRE_Match object; span=(8, 10), match='44'> 44 (8, 10) <_sre.SRE_Match object; span=(24, 26), match='11'> 11 (24, 26) <_sre.SRE_Match object; span=(31, 33), match='10'> 10 (31, 33)
6 split()
按照能够匹配的子串将string分割后返回列表。
可以使用re.split来分割字符串，如：re.split(r’\s+’, text)；将字符串按空格分割成一个单词列表。
格式：
re.split(pattern, string[, maxsplit])
maxsplit用于指定最大分割次数，不指定将全部分割
代码演示：
import re print(re.split('\d+','one1two2three3four4five5')) 输出： ['one', 'two', 'three', 'four', 'five', '']
import re
string3 = '[12:23:90][12:90:87][23233][dsnernrev]'
print(re.split(r"\[|\]",string3))
print(re.findall(r"\[(.*?)\]",string3))
输出：
['', '12:23:90', '', '12:90:87', '', '23233', '', 'dsnernrev', '']
['12:23:90', '12:90:87', 'fdsff']
import re
# 包含分隔符
print(re.split('(\d)','2we3re4'))
输出：
['', '2', 'we', '3', 're', '4', '']
7 sub()
使用re替换string中每一个匹配的子串后返回替换后的字符串。
格式：
re.sub(pattern, repl, string, count)
代码演示：
import re text = "Bob is a handsome boy, he is cool, clever, and so on..." print(re.sub(r'\s+', '-', text)) 输出： Bob-is-a-handsome-boy,-he-is-cool,-clever,-and-so-on... #其中第二个参数是替换后的字符串；本例中为'-' #第四个参数指替换个数。默认为0，表示每个匹配项都替换。re.sub还允许使用函数对匹配项的替换进行复杂的处理。
如：re.sub(r’\s’, lambda m: ‘[’ + m.group(0) + ‘]’, text, 0)；将字符串中的空格’ ‘替换为’[ ]’。
代码演示：
import re text = "JGood is a handsome boy, he is cool, clever, and so on..." print(re.sub(r'\s+', lambda m:'['+m.group(0)+']', text,0)) 输出： JGood[ ]is[ ]a[ ]handsome[ ]boy,[ ]he[ ]is[ ]cool,[ ]clever,[ ]and[ ]so[ ]on...
8 subn()
返回替换次数
格式：
subn(pattern, repl, string, count=0, flags=0)
代码演示：
import re print(re.subn('[1-2]','A','123456abcdef')) print(re.sub("g.t","have",'I get A, I got B ,I gut C')) print(re.subn("g.t","have",'I get A, I got B ,I gut C')) 输出： ('AA3456abcdef', 2) I have A, I have B ,I have C ('I have A, I have B ,I have C', 3)
9. 一些注意点
1、re.match与re.search与re.findall的区别：
re.match() 只匹配字符串的开始，若开始匹配不成功则返回None
re.search() 匹配整个字符串，直到找到一个匹配成功的，就返回，不再继续进行匹配，
若整个字符串都没匹配成功，则返回None
re.findall() 遍历整个字符串进行匹配，返回所有匹配成功的字符串，若没有匹配成功，则返回[]（空列表）。
代码演示：
import re
a=re.search('[\d]',"abc3").group()
print(a)
p=re.match('[\d]',"abc3")
print(p)
b=re.findall('[\d]',"abc3")
print(b)
#执行结果：
#3
#None
#['3', '3']
2、贪婪匹配与非贪婪匹配
?,+?,??,{m,n}? 前面的,+,?等都是贪婪匹配，也就是尽可能匹配，后面加?号使其变成惰性匹配
代码演示：
import re
a = re.findall(r"a(\d+?)",'a23b')
print(a)
b = re.findall(r"a(\d+)",'a23b')
print(b)
#执行结果：
#['2']
#['23']
#这里需要注意的是如果前后均有限定条件的时候，就不存在什么贪婪模式了，非匹配模式失效。
a = re.findall(r"a(\d+)b",'a3333b')
print(a)
b = re.findall(r"a(\d+?)b",'a3333b')
print(b)
#执行结果如下：
#['3333']
#['3333']
3、用flags时遇到的小坑
print(re.split('a','1A1a2A3',re.I))#输出结果并未能区分大小写
#这是因为re.split(pattern，string，maxsplit,flags)默认是四个参数，当我们传入的三个参数的时候，系统会默认re.I是第三个参数，所以就没起作用。如果想让这里的re.I起作用，写成flags=re.I即可
10.使用
#1、匹配电话号码[座机] p = re.compile(r'\d{3}-\d{6}') print(p.findall('010-628888'))#2、匹配IP re.search(r"(([01]?\d?\d|2[0-4]\d|25[0-5])\.){3}([01]?\d?
11、匹配中文
import re
words = 'where are you come from?中国?美国？英国？'
regex_str = "([\u4E00-\u9FA5]+)"
print(re.findall(regex_str,words))
输出：
['中国', '美国', '英国']
12、邮箱正则
import re
def re_Email(str):
print(re.findall('[A-Za-z0-9_-]+@[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+$',str))
re_Email('1257@qq.com')
re_Email('lm_is@163.com')
输出：
['1257@qq.com']
['lm_is@163.com']
后记
【后记】为了让大家能够轻松学编程，我创建了一个公众号【轻松学编程】，里面有让你快速学会编程的文章，当然也有一些干货提高你的编程水平，也有一些编程项目适合做一些课程设计等课题。
也可加我微信【1257309054】，拉你进群，大家一起交流学习。
如果文章对您有帮助，请我喝杯咖啡吧！
公众号
关注我，我们一起成长~~
