正则与re模块

一、正则表达式

在线测试工具 http://tool.chinaz.com/regex/

1.字符组

1. ​ 在同一个位置可能出现的各种字符组成一个字符组，在正则表达中用[ ]表示
2. ​ 一个正则就是一条匹配规则，可以规定一次匹配字符的长度，字符组每次匹配一个长度为1的字符，例如：待匹配字符为：2a+ 使用字符组进行匹配时就会进行三次比较

正则	待匹配字段	匹配结果	说明
[0123456789]	5	5	在一个字符组里枚举所有合法的字符，待匹配字符与其中一个相同，即便匹配成功
[0123456789]	56	5和6	匹配个数为2 (见第二条说明)
[0-9]	7	7	用-表示范围,[0-9]和[0123456789]规则相同
[a-z]	h	h	匹配所有的小写字母
[a-z]	7h	h	匹配个数为1
[a-z]	b	b	匹配所有的大写字母
[0-9a-da-d]	1ecd	1、c和d	匹配个数为3 (该正则可以匹配十六进制字符)

2.字符

元字符	待匹配字符	匹配个数	匹配说明
.	1$,a	4	匹配除换行符以外的任意字符
\w	_1w@	3	匹配字母数字下划线
\w	_1w@	1	匹配非字母数字下划线
\s			匹配空白（空格、换行和tab）
\s			匹配非空白
\d			匹配数字
\d			匹配非数字
\n			匹配一个换行符
\t			匹配一个制表符
\b	a 2+	4	匹配字符的开始或结束
^			匹配字符串的开始
$			匹配字符串的结束
a|b	acfb	2	符合|左右其一即可
（012）	0123	1	匹配括号内的表达式（整体），与[012]区分
[^123]	28291	2	匹配非括号内的所有字符

3.量词

量词	说明
*	重复0次或多次
+	重复1次或多次
？	重复0次或1次
{n}	重复n次
{n,}	重复n次或更多次（至少n次）
{n,m}	重复n次到m次

4.转义

正则	待匹配字符	匹配 结果	说明
\n	\n	false	因为在正则表达式中\是有特殊意义的字符，所以要匹配\n本身，用表达式\n无法匹配
\n	\n	true	转义\之后变成\\，即可匹配
\\\\n	\\n	true	如果在python中，字符串中的'\'也需要转义，所以每一个字符串'\'又需要转义一次
r'\n'	r'\n'	true	在字符串之前加r，让整个字符串不转义

5.贪婪匹配

贪婪匹配：在满足匹配时，匹配尽可能长的字符串，默认情况下，采用贪婪匹配

正则	待匹配字符	匹配 结果	说明
<.*>	<script>...<script>	<script>...<script>	默认为贪婪匹配模式，会匹配尽量长的字符串
<.*?>	r'\d'	<script> <script>	加上？为将贪婪匹配模式转为非贪婪匹配模式，会匹配尽量短的字符串

#贪婪匹配，回溯算法
#\d+8    123456812381281766 匹配结果：12345681238128

二、re模块

python官方文档：https://docs.python.org/zh-cn/3.7/library/re.html?highlight=re#module-re

1.常用函数

1.findall()

​ 返回字符串中所有非重叠匹配项的列表。

import re
ret = re.findall('aba', 'cababa') 
print(ret) 
#结果：['aba']

ret = re.findall('a', 'cababa') 
print(ret) 
#结果：['a', 'a', 'a']

2.finditer()函数

返回一个含有所有非重叠匹配项的迭代器。

ret = re.finditer('a', '1a2a3ab')  
print(ret)
r1=ret.__next__()  #r1=ret.__next__().group()
r2=ret.__next__()
print(r1)
print(r2)
#运行结果：
<callable_iterator object at 0x0370e450>
<re.match object; span=(1, 2), match='a'>   # a
<re.match object; span=(3, 4), match='a'> 
stopiteration


#span(起始位置,结束位置)

3.fullmatch()

​ 完全匹配。

ret = re.fullmatch('aba', 'cababa') 
print(ret)
#结果：
none

ret = re.fullmatch('aba', 'aba') 
print(ret)
#<re.match object; span=(0, 3), match='aba'>

4.match()

​ 尝试在字符串的开头应用pattern，返回匹配对象(不可迭代)，如果没有找到匹配，则为none。

ret = re.match('aba', 'cababa') 
print(ret)
#结果：
none

ret = re.match('\d', '12ab3') #相当于re.search('^\d','12ab3')
print(ret)
re1=ret.group(0)
print(re1)
#结果：
<re.match object; span=(0, 1), match='1'>
1

5.search()

​ 扫描字符串，寻找与第一个符合匹配的字符串，然后返回匹配对象(不可迭代)，如果没有找到匹配，则为none。

ret = re.search('\d', 'c13ab2ab') 
print(ret)
#结果:
<re.match object; span=(1, 4), match='aba'>
<re.match object; span=(1, 2), match='1'>
1
#如果没有则ret为none，不可使用ret.group()
#if ret:
    ret.group

6.split(self, /, string, maxsplit=0)

​ 根据模式的出现情况拆分源字符串，返回包含结果子字符串的列表。如果捕获括号在pattern中使用，然后是all的文本模式中的组也作为结果的一部分返回列表。如果maxsplit不为零，则最多发生maxsplit拆分，字符串的其余部分作为最后一个元素返回的列表。

ret = re.split('aba', 'cababa1aba') 
print(ret) 
#结果:
['c', 'ba1', '']  

ret = re.split('aba', 'cababa1aba2') 
print(ret) 
#结果:
['c', 'ba1', '2']

ret = re.split('aba', 'cababa1aba2',maxsplit=1) 
print(ret) 
#结果:
['c', 'ba12']

ret = re.split('[ab]', 'abcd')  # 先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割
print(ret)  
# 结果
['', '', 'cd']

7.sub(pattern, repl, string, count=0, flags=0)

​ 返回通过pattern非重叠替换repl得到的字符串。

• repl可以是字符串，也可以是可调用的;
• 如果是字符串，则处理其中的反斜杠转义。
• 如果它是一个可调用的对象，它传递了match对象并必须返回要使用的替换字符串

ret = re.sub('\d{2}','+', '2ad232c') 
print(ret) 
#结果:
2ad+2c

import random
def fun(s):
    i = random.randint(0,len(s))
    return s[i]
ret = re.sub('\d{2}',fun('#$%'), '2ad232c') 
print(ret) 

8.subn(pattern, repl, string, count=0, flags=0)

返回通过pattern非重叠替换repl得到的字符串与替换次数组成的二元组。

• repl可以是字符串，也可以是可调用的;
• 如果是字符串，则处理其中的反斜杠转义。
• 如果它是一个可调用的对象，它传递了match对象并必须返回要使用的替换字符串

ret = re.subn('\d{2}','+', '2ad232c') 
print(ret) 
#结果：
('2ad+2c', 1)

9.compile()

将正则表达式编译成为一个 正则表达式对象,节省编译时间

obj = re.compile('\d{3}') 
ret = obj.search('abc123d') #正则表达式对象调用search，参数为待匹配的字符串
print(ret.group()) 
#结果：
123

10.template(pattern, flags=0)

​ 编译一个模板模式，返回一个模式对象

11.purge()

清除正则表达式缓存

二、分组的使用

import re
s = '<a>dfjsjgs</a>'
reg = '<a(>)(.+)<'
ret = re.search(reg,s)
print(ret.group()) #或print(ret.group(0)) 默认是0,取所有
print(ret.group(1))
print(ret.group(2))
#结果:
<a>dfjsjgs<
>
dfjsjgs


#findall(),匹配后优先返回括号内的匹配
import re
s = '1.234+4.23'
reg = '\d\.(?:\d+)'
ret = re.findall(reg,s)
print(ret)
#结果：['.234', '.23']

#取消优先  ？：
s = '1.234+4.23'
reg = '\d\.(?:\d+)'
ret = re.findall(reg,s)
print(ret)
#结果：['1.234', '4.23']


#split()
ret = re.split('\d+','abc12de34')
print(ret)
#结果：
['abc', 'de', '']
ret = re.split('(\d+)','abc12de34')
print(ret)
#结果：
['abc', '12', 'de', '34', '']


#分组命名
s = '<a>dfjsjgs</a>'
reg = '<(?p<na>\w)>\w+</a>'  #(?p<na>\w)分组命名为'na'
ret = re.search(reg,s)
print(ret.group('na'))
#结果：
a

#当要求满足正则并且相同时可以，使用分组命名
s = '<a>dfjsjgs</a>'
reg = '<(?p<na>\w)>\w+</(?p=na\w)>'
ret = re.search(reg,s)
print(ret.group('na'))
#结果：
a

s = '<a>dfjsjgs</a>'
reg = '<(?p<na>\w)>\w+</(?p=na\w)>'
ret = re.search(reg,s)
print(ret.group('na'))
#结果：
a

#分组用法示例，匹配整数
s = '1+2.4*(32-1.5)-11.11'  
reg = '\d+\.\d+|\d+'
ret = re.findall(reg,s)
print(ret)
#结果：
['1', '2.4', '32', '1.5', '11.11']
#可以对上面得到的结果进行遍历判断

s = '1+2.4*(32-1.5)-11.11'  
reg = '(\d+\.\d+)|(\d+)'
ret = re.findall(reg,s)
print(ret)
#结果：
[('', '1'), ('2.4', ''), ('', '32'), ('1.5', ''), ('11.11', '')]
#还可以利用分组进行，再次筛选
s = '1+2.4*(32-1.5)-11.11'  
reg = '\d+\.\d+|(\d+)'
ret = re.findall(reg,s)
print(ret)
#结果：
['1', '', '32', '', '']
#使用列表的remove('')

三、flags

some of the functions in this module takes flags as optional parameters:
        a  ascii       for string patterns, make \w, \w, \b, \b, \d, \d
                       match the corresponding ascii character categories
                       (rather than the whole unicode categories, which is the
                       default).
                       for bytes patterns, this flag is the only available
                       behaviour and needn't be specified.
        i  ignorecase  perform case-insensitive matching.
        l  locale      make \w, \w, \b, \b, dependent on the current locale.
        m  multiline   "^" matches the beginning of lines (after a newline)
                       as well as the string.
                       "$" matches the end of lines (before a newline) as well
                       as the end of the string.
        s  dotall      "." matches any character at all, including the newline.
        x  verbose     ignore whitespace and comments for nicer looking re's.
        u  unicode     for compatibility only. ignored for string patterns (it
                       is the default), and forbidden for bytes patterns.
    
    this module also defines an exception 'error'.
    
  re模块中的一些函数含有可选参数flags
        a           匹配相应的ascii字符类别(而不是默认的整个unicode)
                    对于字节模式，a是惟一可用的，不需要指定。
        i           执行不区分大小写的匹配     
        m           “^”匹配行开头(换行之后)的字符串。"$"匹配行(换行之后)的结尾字符串
        s           "."匹配所有，包括换行
 
 #re.s
s = '1q$\n+'
ret = re.findall('.',s)
print(ret)
结果：
['1', 'q', '$', '+']
s = '1q$\n+'
ret = re.findall('.',s,re.s)
print(ret)
结果：
['1', 'q', '$', '\n', '+']


#re.m
s = '123\n45 6'
ret = re.findall('^\d+',s)
print(ret)
结果：
['123']

s = '123\n45 6'
ret = re.findall('^\d+',s,re.m)
print(ret)
结果：
['123', '45']