正则表达式的基础
正则表达式并不是Python的一部分。
正则表达式是用于处理字符串的强大工具,拥有自己独特的语法以及一个独立的处理引擎,效率上可能不如str自带的方法,但功能十分强大。
得益于这一点,在提供了正则表达式的语言里,正则表达式的语法都是一样的,区别只在于不同的编程语言实现支持的语法数量不同。
就其本质而言,正则表达式(或 RE)是一种小型的、高度专业化的编程语言,(在Python中)它内嵌在Python中,并通过 re 模块实现。
元字符
元字符: . ^ $ * + ? { [ ] | ( )
. 匹配除了换行符外所有字符 (通配符)
content = 'Abcdefghijklmnopq' test = re.findall(r"b.d",content) print(test) ['bcd']
^ 以....开头
content = 'Abcdefghijklmnopq' test = re.findall(r"^Abcd",content) print(test) ['Abcd']
$ 以....结尾
content = 'Abcdefghijklmnopq' test = re.findall(r"nopq$",content) print(test) ['nopq']
* 匹配0到多次 {0, } 控制它前面的字符
content = 'Abcdefghijklmnopq' test = re.findall(r"A.*e",content) print(test) ['Abcde']
+ 匹配1到多次 {1, }
content = 'abcdefab111111' test = re.findall(r"ab1+",content) print(test) ['ab111111']
? 匹配0到1次 {0,1}
content = 'abcdefab111111' test = re.findall(r"ab1?",content) print(test) ['ab', 'ab1']
* + 都是按照贪婪模式进行匹配 非贪婪模式 需要在后面加个?
content = 'abcdefab111111' test = re.findall(r"ab1+?",content) print(test) ['ab1'] re.search(r"a(d+?)","a2345").group() => a2 re.search(r"a(d*?)","a2345").group() => a #如果前后均有限定条件 ?不起作用 re.search(r"a(d*?)b","a2345b").group() => a2345b
( ) 组 作为一个整体
content = 'abcdefab111111' test = re.findall(r"(ab1)",content) print(test) ['ab1']
{ } 重复次数自定义
content = 'abcdefab111111' test = re.findall(r"ab1{3,9}",content) print(test) ['ab111111']
[ ] 字符集 表示或
字符集里面元字符会失去意义 除了 - ^ 3个元字符外
content1 = 'wwwwwabdxxxxx' test1 = re.findall(r"a[bc]d",content1) print(test1) #['abd'] content2 = 'wwwwwacdxxxxx' test2 = re.findall(r"a[bc]d",content2) print(test2) #['acd'] *********************************************************************** content = 'wwwwwa.xxxxx' test = re.findall(r"a[.]x",content) print(test) #['a.x'] content = 'wwwww1234xxxxx' test = re.findall(r"[1-9]",content) #1~9的数字 print(test) #['1', '2', '3', '4'] content = 'wwwww1234xxxxx' test = re.findall(r"[^1-9]",content) #非1~9的数字 print(test) #['w', 'w', 'w', 'w', 'w', 'x', 'x', 'x', 'x', 'x']
作用:
- 后面跟元字符去除特殊功能
- 后面跟普通字符实现特殊功能
- 引用序号对应的字组所匹配的字符串
test = re.search(r"(alex)(eric)com2","alexericcomeric") print(test.group()) #alexericcomeric
d 匹配任何十进制数, [0-9]
D 匹配任何非数字字符 [^0-9]
s 匹配任何空白字符 [ fv ]
S 匹配任何非空白字符 [^ fv ]
w 匹配任何字母数字字符 [a-zA-Z0-9_]
W 匹配任何非字母数字字符 [^a-zA-Z0-9]
匹配一个单词边界,单词和空格间的位置 匹配特殊字符(不单止空格)
content = 'wwwww1234xxxxx' test = re.findall(r"d",content) print(test) # ['1', '2', '3', '4'] content = 'ww&*#$%ww1234xx' test = re.findall(r"D",content) print(test) # ['w', 'w', '&', '*', '#', '$', '%', 'w', 'w', 'x', 'x'] content = 'asdasd ' test = re.findall(r"s",content) print(test) # [' ', ' ', ' '] content = ' asdasd ' test = re.findall(r"S",content) print(test) # ['a', 's', 'd', 'a', 's', 'd'] content = 'abc123^&*lm-\_' test = re.findall(r"w",content) print(test) # ['a', 'b', 'c', '1', '2', '3', 'l', 'm', '_'] content = 'abc123^&*lm-\_' test = re.findall(r"W",content) print(test) # ['^', '&', '*', '-', '\'] content = 'I like Sooooo' test = re.findall(r"like",content) print(test) # ['like'] ******************************************* test = re.findall(r"abc","asdasd abc ") test = re.findall(r"abc","asdasd abc*") print(test) # ['abc']
match()
match()
# match,从起始位置开始匹配,匹配成功返回一个对象,未匹配成功返回None match(pattern, string, flags=0) # pattern: 正则模型 # string : 要匹配的字符串 # falgs : 匹配模式 # re.I(re.IGNORECASE): 忽略大小写(括号内是完整写法,下同) # M(MULTILINE): 多行模式,改变'^'和'$'的行为 # S(DOTALL): 点任意匹配模式,改变'.'的行为 使 . 匹配包括换行在内的所有字符 # L(LOCALE): 使预定字符类 w W B s S 取决于当前区域设定 # U(UNICODE): 使预定字符类 w W B s S d D 取决于unicode定义的字符属性 # X(VERBOSE): 详细模式。这个模式下正则表达式可以是多行,忽略空白字符,并可以加入注释。以下两个正则表达式是等价的: ************************************* # match对象的方法 .group() 获取匹配到的所有结果 .groups() 获取模型中匹配到的分组结果 .groupdict() 获取模型中匹配到的分组中所有执行了key的组 .group() 返回被RE匹配的字符串 可以加参数group(1) 组号 .start() 返回匹配开始的位置 .end() 返回匹配结束的位置 .span() 返回一个元组包含的匹配的位置
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
# 无分组 r = re.match("hw+", origin) print(r.group()) # 获取匹配到的所有结果 print(r.groups()) # 获取模型中匹配到的分组结果 print(r.groupdict()) # 获取模型中匹配到的分组结果 # 有分组 # 为何要有分组?提取匹配成功的指定内容(先匹配成功全部正则,再匹配成功的局部内容提取出来) r = re.match("h(w+).*(?P<name>d)$", origin) print(r.group()) # 获取匹配到的所有结果 print(r.groups()) # 获取模型中匹配到的分组结果 print(r.groupdict()) # 获取模型中匹配到的分组中所有执行了key的组
search()
search()
# search 匹配成功有结果,返回match对象 # 查看返回结果用.group() # search,浏览整个字符串去匹配第一个,未匹配成功返回None # search(pattern, string, flags=0)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
# 无分组 r = re.search("aw+", origin) print(r.group()) # 获取匹配到的所有结果 print(r.groups()) # 获取模型中匹配到的分组结果 print(r.groupdict()) # 获取模型中匹配到的分组结果 # 有分组 r = re.search("a(w+).*(?P<name>d)$", origin) print(r.group()) # 获取匹配到的所有结果 print(r.groups()) # 获取模型中匹配到的分组结果 print(r.groupdict()) # 获取模型中匹配到的分组中所有执行了key的组
findall()
findall()
# 优先取组里内容返回! # findall,获取非重复的匹配列表;如果有一个组则以列表形式返回,且每一个匹配均是字符串;如果模型中有多个组,则以列表形式返回,且每一个匹配均是元祖; # 空的匹配也会包含在结果中 # findall(pattern, string, flags=0) data = re.findall("d+wd+",'a2b3c4d5') # ['2b3', '4d5'] # re.findall() 匹配成功一个后,从匹配成功最后位置开始下一次查找 # 空的匹配也会包含在结果中 data = re.findall("",'a2') print(data) # ['', '', ''] *********************************** #有几个括号就取几次 data = re.findall(r'(dasd)*','1asd2asdp3asd3434') print(data) # ['2asd', '', '3asd', '', '', '', '', ''] # 贪婪匹配 第一段取到1asd2asd 但最后返回 2asd 取最后一个! 如下: a= "alex" data = re.findall(r'(w)(w)(w)(w)',a) print(data) # [('a', 'l', 'e', 'x')] data = re.findall(r'(w){4}',a) print(data) # ['x'] => 只是执行了4次,返回还是按一个括号算,取最后匹配的一项 *********************************** test = re.findall("www.(baidu|laonanhai).com","asdsa www.baidu.com") print(test) # ['baidu'] 添加 ?: 去掉优先权 test = re.findall("www.(?:baidu|laonanhai).com","asdsa www.baidu.com") print(test) # ['www.baidu.com']
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
# 无分组 r = re.findall("aw+",origin) print(r) # 有分组 origin = "hello alex bcd abcd lge acd 19" r = re.findall("a((w*)c)(d)", origin) print(r) # [('bc', 'b', 'd'), ('c', '', 'd')]
sub()
sub()
# sub,替换匹配成功的指定位置字符串 sub(pattern, repl, string, count=0, flags=0) # pattern: 正则模型 # repl : 要替换的字符串或可执行对象 # string : 要匹配的字符串 # count : 指定匹配个数 # flags : 匹配模式 test = re.sub("g.t","have","I get A, I got B , I gut C") print(test) #I have A, I have B , I have C ******************************************** #subn 最后还返回一个替换次数 origin = "ale4 xc 19" data,counts = re.subn("d+","KKK",origin) print(data,counts) # aleKKK xc KKK 2
compile()
compile()
regex = re.compile(r"w*oow*") text = " JGood is ,he is cool" data = regex.findall(text) print(data) #['JGood', 'cool']
split()
split()
# split,根据正则匹配分割字符串 split(pattern, string, maxsplit=0, flags=0) # pattern: 正则模型 # string : 要匹配的字符串 # maxsplit:指定分割个数 # flags : 匹配模式 ***************************************** # 有分组情况下, 把分割的项也添加进去 origin = "hello alex bcd alex lge alex acd 19" r1 = re.split("(alex)", origin, 1) print(r1) # ['hello ', 'alex', ' bcd alex lge alex acd 19'] r2 = re.split("(al(ex))", origin, 1) print(r2) # ['hello ', 'alex', 'ex', ' bcd alex lge alex acd 19'] ***************************************** p = re.compile(r"d+") test = p.split("one1two2three3four4") print(test) # ['one', 'two', 'three', 'four', ''] # 末尾有空字符串 => one,two2three3four4 => ['one'] two,three3four4 => .. test = re.split('[bc]','abcd') print(test) # ['a', '', 'd']
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
# 无分组 origin = "hello alex bcd alex lge alex acd 19" r = re.split("alex", origin, 1) print(r) # 有分组 origin = "hello alex bcd alex lge alex acd 19" r1 = re.split("(alex)", origin, 1) print(r1) r2 = re.split("(al(ex))", origin, 1) print(r2)
finditer()
finditer()
# 返回结果为迭代对象 p = re.compile(r"d+") w = p.finditer(' 1 drum44ers druming , 11 ... 10 ...') for match in w: print(match.group(),match.span()) # 1 (1, 2) # 44 (7, 9) # 11 (23, 25) # 10 (30, 32)
反斜杠的困扰
与大多数编程语言相同,正则表达式里使用""
作为转义字符,这就可能造成反斜杠困扰。
假如你需要匹配文本中的字符""
,那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\"
前两个和后两个分别用于在编程语言里转义成反斜杠,转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。
Python里的原生字符串很好地解决了这个问题,这个例子中的正则表达式可以使用r"\"
表示。
同样,匹配一个数字的"\d"
可以写成r"d"
。有了原生字符串,你再也不用担心是不是漏写了反斜杠,写出来的表达式也更直观。
常用正则表达式
# IP: ^(25[0-5]|2[0-4]d|[0-1]?d?d)(.(25[0-5]|2[0-4]d|[0-1]?d?d)){3}$ # 手机号: ^1[3|4|5|8][0-9]d{8}$ # 邮箱: [a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(.[a-zA-Z0-9_-]+)+
练习题:计算器
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#!/usr/bin/env python # -*-coding:utf-8 -*- import re # 加减运算: def add_sub(origin): ''' 进行加减运算,按+ - 符号拆分, :param origin: 传入的表达式 :return: ''' data = re.split('([+-]{1})', origin) # 预处理 把 '' 转换成 '0' for i in range(len(data)): if data[i].strip() == '': data[i] = '0' # 预处理 负负得正 情况: for i in range(len(data)): if data[i].strip() == '0' and i != 0 : if data[i-1].strip() == '-': data[i+1] = '+' # 计算开始: total = 0 # flag = 0 默认加号 1为减号 flag = 0 for i in range(len(data)): if data[i].strip() == '-': flag = 1 continue elif data[i].strip() == '+': flag = 0 continue elif flag == 0 : total += float(data[i].strip()) if '.'in data[i] else int(data[i].strip()) elif flag == 1 : total -= float(data[i].strip()) if '.'in data[i] else int(data[i].strip()) return total # 计算乘除,乘方运算: def plus_div(origin): ''' 按前后顺序拆分,需要进行 乘除,乘方 运算的地方,获得式子,计算出结果,顶替回原来位置,循环此步骤,只剩加减法,再把只剩加减法的式子传入add_sub()计算 :param origin: 传入的表达式 :return: ''' while True: data = re.split('([-]?d+.?d*s*(?:[*/]|**)s*[-]?d+.?d*)',origin,1) # 判断表达式是否只剩加减运算 , 传入 add_sub() 进行加减法的计算 if len(data) ==1: result = add_sub(data[0]) return result break # 判断表达式是否还包含 乘除,乘方 符号 ,如果包含,继续拆分运算,最终获得只剩加减的式子 elif len(data) ==3: counts = data[1] # 获得匹配出的 运算符号 * / 或 ** before, content, after = data else: print('Error') # 判断需要进行哪种运算, if '**' in counts: num = counts.split('**') left = float(num[0].strip()) if '.'in num[0] else int(num[0].strip()) right = float(num[1].strip()) if '.' in num[1] else int(num[1].strip()) total = left ** right elif '/' in counts: num = counts.split('/') left = float(num[0].strip()) if '.'in num[0] else int(num[0].strip()) right = float(num[1].strip()) if '.' in num[1] else int(num[1].strip()) total = left / right elif '*' in counts: num = counts.split('*') left = float(num[0].strip()) if '.'in num[0] else int(num[0].strip()) right = float(num[1].strip()) if '.' in num[1] else int(num[1].strip()) total = left * right # 此时只进行了表达式内的一次乘除,乘方运算, 计算结果拼接顶替原来的位置,继续循环直到只剩加减法 origin = before + str(total) + after def count(origin): """ 1.一步一步拆分括号,每获得一次 最里层的括号表达式 ,就传入plus_div()函数 进行 该表达式的所有乘除运算,再进行加减运算,返回该表达式最终结果, 拼接回原表达式,替换回括号位置.再循环寻找下一个括号内表达式,直到所有括号的表达式计算完毕,最终只剩一条只包含单纯的乘除加减运算的表达式. :param origin: 需要计算的表达式 :return: """ while True: # 拆分() 获得最里层的括号! data = re.split('(([^()]+))',origin,1) if len(data) == 3: before,content,after = data result = plus_div(content) # () 里面的表达式传入 plus_div 进行计算 origin = before + str(result) + after # 把计算结果 拼接回原来括号的位置. 进行下一次括号寻找! else: # 当只剩一条只包含单纯的乘除加减运算的表达式时, result = plus_div(data[0]) return result break origin = " 6 * 2 + ( 4 -3.5 + 1 * 91 + (-1 +2) * 5 -5 ) / 2 + 2 ** 9" result = count(origin) print('表达式: ' + origin) print('我的计算结果 : ' + str(result)) print('eval计算结果: '+ str(eval(origin)))