python标准库:re

1，匹配符号

* : 匹配前一个字符0次，1次，多次
+ : 匹配前一个字符1次，多次
? : 匹配前一个字符0次，1次
{n} : 匹配前一个字符n次
{n,} : 匹配前一个字符至少n次
{n,m} : 匹配前一个字符n到m次

. : 匹配任意一个字符（除了换行符/n），若指定flag
^ : 匹配字符串开头（无法匹配换行符后的位置）
$ : 匹配字符串结尾（无法匹配换行符前的位置）
| : 或
[] : 或
() : 捕获分组，可以设置?:不捕获分组

\A : 匹配字符串开始，与^的区别是\A不受MULTILINE影响？
\Z : 匹配字符结尾，与$的区别是\Z不受MULTILINE影响？
\d : 匹配数字
\D : 匹配非数字
\w : 匹配[a-zA-Z0-9]
\W : 匹配非[a-zA-Z0-9]
\s : 匹配空白字符, 即[\f\n\r\t\v]
\S : 匹配任何非空白字符，即[^ \f\n\r\t\v]
\b : 单词边界
\B : 非单词边界
[a-z] : 匹配任意小写字母
[A-Z] : 匹配任意大写字母
[a-zA-Z] : 匹配任意字母

2，匹配flags

MULTILINE(M)：改变“^”和“$”，让“^”能够匹配到换行符后的位置，让“$”能够匹配到换行符前的位置
DOTALL(S)：改变“.”，让“.”能够匹配换行符
IGNORECASE(I)：忽略大小写
LOCALE(L)
UNICODE(U)
VERBOSE(X)
ASCII(A)

3，匹配模式

整体匹配（只匹配第一次）：re.search / re.match
全局匹配（匹配所有）：re.findall
分组捕获：()，整体匹配和全局匹配都可以进行分组捕获，捕获匹配结果中的部分内容，分组捕获可以嵌套，详见匹配举例

4，匹配写法

方法一，需要重复执行匹配的，先编译再匹配

regex = re.compile(p)

regex.search(s)

re.search(regex, s)

方法二，简单的可以直接匹配

re.search(p, s)

5，匹配方法

1)re.search(p, s)

从s中提取完全符合p的内容，只提取第一次命中的，返回re.match对象

提取整体匹配结果：searchObj.group(), searchObj.group(0)

提取所有分组捕获结果：searchObj.groups()

提取单个分组捕获结果：searchObj.group(n), 即groups()[i] = group(i+1)

2)re.findall(p, s)

提取所有符合p的内容，返回字符串组成的列表

使用分组捕获时，返回分组捕获结果(元组)组成的列表

re.search使用分组捕获时既可以捕获整体匹配，也可以捕获分组内容

re.findall使用分组捕获时只能捕获分组内容

3)re.match(p, s)

可以用re.search(^)替代

MULTILINE模式下，match也只匹配s，但re.search可以匹配换行后的开始

4)re.finditer(p, s)

re.findall的惰性版，返回iterator

5)re.split(p, s)

根据p分割字符串s

6)re.sub(p, repl, s, count=n)

p是匹配到的值，repl是替换后值，s是m目标字符串，count是替换多少次

re.subn(p, repl)可以返回替换次数

6，分组捕获时添加标签

>>>ID = "310115199012128765"
>>>p = "(?P<dictrict>[0-9]{6})(?P<birthday>[0-9]{8})"
>>>re.search(p, ID).groupdict()
{'dictrict': '310115', 'birthday': '19901212'}

7，懒惰匹配和贪婪匹配

.*是贪婪比配，尽可能多

.*?是懒惰匹配，满足条件时，尽可能少

>>>re.search('a.*?b', 'abab').group()
ab
>>>re.search('a.*?b', 'abab').group()
abab
>>>re.search('192\.168\.1\..*$', '192.168.1.12').group() 
192.168.1.12
>>>re.search('192\.168\.1\..*?', '192.168.1.12').group() # 没有结束符，懒惰不匹配
192.168.1.
>>>re.search('192\.168\.1\..*', '192.168.1.12').group() # 没有结束符，贪婪匹配至最后
192.168.1.12

8，前向界定和后向界定

(?<=s)：前向界定，s后面的位置

(?=s)：后向界定，s前面的位置

>>>s = 'ab1c ab2c\nab3c'
>>>re.findall('(a.*?)(?:\s|$)', s) # 貌似$不能用[]或
['ab1c', 'ab2c', 'ab3c']
>>>re.findall('((?<=b).*?)(?:\s|$)', s) # b后面的位置开始
['1c', '2c', '3c']
>>>re.findall('((?=b).*?)(?:\s|$)', s) # b前面的位置开始
['b1c', 'b2c', 'b3c']

9，转义

编程语言的转义：

>>>s = 'c:\name.txt'
>>>print('c:\name.txt')
c:
ame.txt

不转义就会被换行处理，解决方法是print('c:\\name.txt')或者print(r'c:\name.txt')

正则表达式的转义：

>>>s = 'c:\\name.txt'
>>>re.search('c:\\\\.*?\.', s).group()
'c:\\name.'
>>>re.search(r'c:\\.*?\.', s).group()
'c:\\name.'

自动转义：

有些编程语言没有特殊意义的字符，可能无需转义

例如print('\n)和print('\\n')不一样

但是print('\d)和print('\\d')是一样的

10，匹配举例

'ab1c ab2c\nab3c'匹配例子：

>>>s = 'ab1c ab2c\nab3c'

>>>re.search('a.*?c a.*?c', s).group() # 整体匹配
ab1c ab2c
>>>re.search('a(.*?)c a(.*?)c', s).groups() # 整体匹配 + 捕获分组
'b1 b2'
>>>re.search('a(\w(\w))c a(\w(\w))c', s).groups() # 整体匹配 + 捕获分组
('b1', '1', 'b2', '2')

>>>re.findall('a.*?c', s) # 全局匹配
['ab1c', 'ab2c', 'ab3c']
>>>re.findall('a(.*?)c', s) # 全局匹配 + 捕获分组：只能捕获分组内容
['b1', 'b2', 'b3']
>>>re.findall('a(\w(\w))c', s) # 全局匹配 + 捕获分组嵌套
[('b1', '1'), ('b2', '2'), ('b3', '3')]

>>>re.findall('a.*?c$', s)
['ab3c']
>>>re.findall('a.*?c$', s, flags=re.M) # re.M影响$
['ab1c ab2c', 'ab3c']
>>>re.findall('^a.*?c', s)
['ab1c']
>>>re.findall('^a.*?c', s, flags=re.M) # re.M影响^
['ab1c', 'ab3c']
>>>re.search('a.*c', s).group()
'ab1c ab2c'
>>>re.search('a.*c', s, flags=re.DOTALL).group() # re.DOTALL影响.
'ab1c ab2c\nab3c'

>>>re.split('\s', s)
['ab1c', 'ab2c', 'ab3c']
>>>re.split('(\s)', s) # re.split + 分组可以看到分隔符
['ab1c', ' ', 'ab2c', '\n', 'ab3c']

'a b, c ; d\ e'匹配例子：

>>>s = 'a b, c ; d\ e'
>>>s
'a b, c ; d\\ e'  # \被自动转成\\
>>>re.split(r'\s*[\s,;\\]\s*', s)
['a', 'b', 'c', 'd', 'e']
>>>re.split(r'\s*(?:\s|,|;|\\)\s*', s) # []的等效写法
['a', 'b', 'c', 'd', 'e']
>>>re.split(r'\s*(\s|,|;|\\)\s*', s) # 不用?:只抓到了单个分隔符，用它去对s分割会包含单个分隔符
['a', ' ', 'b', ',', 'c', ';', 'd', '\\', 'e']
>>> re.split(r'(\s*(?:\s|,|;|\\)\s*)', s) # 包含完整的分隔符
['a', ' ', 'b', ', ', 'c', ' ; ', 'd', '\\ ', 'e']

猜你喜欢