Python标准库re的使用（正则化匹配）

常用正则表达式

正则表达式                                                              描述                                    匹配结果
\d+(\.\d*)?                                                       任意整数和浮点数                            0.004 2 75.

\b[^\Wa-z0-9_][^\WA-Z0-9_]*\b                                      首字母只能大写                               Boo Foo

^http:\/\/([\w-]+(\.[\w-]+)+(\/[\w-.\/\?%&=\u4e00-\u9fa5]*)?)?$      验证网址                           http://www.baidu.com/?id=1

^[\u4e00-\u9fa5]{0,}$                                                验证汉字                                 汉字汉字

\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*                       验证电子邮件                             example@163.com

^[1-9]([0-9]{16}|[0-9]{13})[xX0-9]$                                 验证身份证                            14525419951215445X

^13[0-9]{1}[0-9]{8}|^15[9]{1}[0-9]{8}                               验证手机号                             138459572***

^(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9])          验证IP                             192.168.1.1
\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)
\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)
\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[0-9])$	

^[a-zA-Z0-9]+([a-zA-Z0-9\-\.]+)?\.s|)$                                验证域名                                baidu.com

^([a-zA-Z]\:|\\)\\([^\\]+\\)*[^\/:*?"<>|]+\.txt(l)?$               验证文件路径	                             C:\user\wo

<(.*)>(.*)<\/(.*)>|<(.*)\/>                                        HTML标签匹配(需修改)                          xxxx
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

一，必备知识

1.修饰符（flag）

re.I  使匹配对大小写不敏感
re.L  做本地化识别匹配
re.M  多行匹配,影响^和$
re.S  使.匹配包括换行在内的所有字符
re.U  根据Unicode字符集解析字符.这个标志影响\w \W \b \B
re.X  该标志通过给予你更灵活的格式以便你将正则表达式写的更易于理解.

# 例子 result = re.match('^The.*?(\d+).*?phone.', content, re.S)
1
2
3
4
5
6
7
8

2.匹配模式

^          匹配字符串开头
$          匹配字符串结尾
.          匹配人以字符,除了换行符号.当re.DOTAALL标记被指定时,则可以匹配包括换行符的任意字符.
[...]      用来表示一组字符,单独列出:[amk]匹配a,m或k
[^...]     不在[]中的字符:[^amk]匹配除amk之外的字符
re*        匹配0个或多个的表达式
re+        匹配1个或多个的表达式
re?        匹配0个或1个由前面的正则表达式定义的片段,非贪婪方式.
re{n}      精准匹配n个前面表达式
re{n,}     匹配大于等于n个前面表达式
re{n,m}    匹配n到m个前面的表达式定义的片段,贪婪方式
a|b        匹配a或b
(re)       对正则表达式分组,并记住匹配的文本
(?imx)     正则表达式包含三种可选标志,imx,只影响括号中的区域.
(?-imx)    正则表达式关闭imx可选标志,只影响括号中的区域.
(?:re)     类似(...)但不表示一个组
(?imx:re)  在括号中使用imx可选标志
(?-imx:re) 在括号中不是用imx可选标志
(?#...)    注释
(?=re)     前向肯定界定符.如果所含正则表达式,以...表示,在当前位置成功匹配时成功,否则失败.但一旦所含表达式已经尝试,匹配引擎根本没有提高,模式的剩余部分还要尝试界定符右边.
(?!re)     前向否定界定符.与肯定界定符相反;当所含的表达式不能在字符串当前位置匹配成功时成功.
(?>re)     匹配的独立模式,省去回朔.
\w         匹配字符数字以及下划线
\W         匹配非字母数字下划线
\s         匹配任意空白字符,等价于[\t\n\r\f]
\S         匹配任意非空白字符
\d         匹配任意数字
\D         匹配任意非数字
\A         匹配字符串开始
\Z         匹配字符串结束,如果是存在换行,只匹配到换行前的结束字符串.
\z         匹配字符串结束
\G         匹配最后匹配完成的位置
\b         匹配一个单词边界,也就是指单词和空格之间的位置
\B         匹配非单词边界
\n \t      匹配一个换行符,一个制表符
\1...\9    匹配第n个分组的内容
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

3. r的作用

• r’(\w+) (\w+)(?P.*)’，字符串之前的r可以避免转行符混淆

正则表达式使用反斜杠来表示特殊形式，或者把特殊字符转义成普通字符。

而反斜杠在普通的 Python 字符串里也有相同的作用，所以就产生了冲突。

解决办法是对于正则表达式样式使用 Python 的原始字符串表示法；在带有 ‘r’ 前缀的字符串字面值中，反斜杠不必做任何特殊处理。

import re

if re.search(r'\\d', 'I have one nee\dle') is not None:
    print('match it',re.search(r'\\d', 'I have one nee\dle').group(0))
else:
    print('not match')

# match it \d
1
2
3
4
5
6
7
8

4. 贪婪与非贪婪—通配符后面加？

• 在贪婪匹配下，.* 会匹配尽可能多的字符。
• 正则表达式中.*后面是\d+，也就是至少一个数字，并没有指定具体多少个数字，因此，.*就尽可能匹配多的字符，这里就把12345匹配了，给\d+留下个可满 足条件的数字 6.最后得到的内容就只有数字6了

import re

content = 'The 123456 is my one phone number.'
print('贪婪匹配:')
result = re.match(r'^The.*(\d+).*', content) #使用match匹配, 第一个参数为正则表达式, 第二个为要匹配的字符串
print(result.group()) #输出匹配内容
print('result = %s'%result.group(1)) #输出第一个被()包裹的内容

print('-'*20)

print('非贪婪匹配:')
result = re.match(r'^The.*?(\d+).*', content) 
print(result.group())
print('result = %s'%result.group(1))

# 贪婪匹配:
# The 123456 is my one phone number.
# result = 6
# --------------------
# 非贪婪匹配:
# The 123456 is my one phone number.
# result = 123456
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

5.转义匹配的使用

• 由于()属于正则表达式的特殊字符, 因此在需要匹配()时, 需要加上转义字符\.

import re

content = '(百度)www.baidu.com'
result = re.match('(百度)www.baidu.com', content)
result2 = re.match('\(百度\)www\.baidu\.com', content)
if result:
    print(result.group())
else:
    print('result = None')
if result2:
    print(result2.group())
else:
    print('result2 = None')

# result = None
# (百度)www.baidu.com
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

6. group(num = 0)和groups( )

• group 函数有一个int类型的参数，参数为0表示返回正则匹配的字符串，参数为1返回正则中第一个组匹配的内容，2返回第二组的内容一次类推
• groups 函数是所有group函数结果组成一个元组。

二，函数应用

1. re.compile(pattern,flags=0)—自定义匹配模板

• 他的第一个参数是正则字符串，第二个参数是修饰符
• 编译成一个正则表达式对象，可以用于匹配match/search/findall 方法 序列
• 在需要匹配相同正则表达式情况下, 事先定义一个compile可以简化代码量, 同时compile中也可以使用修饰符r.S等.

import re

content1 = '2016-1-1 12:01'
content2 = '2017-1-1 12:02'
content3 = '2018-1-1 12:03'

pattern = re.compile('\d{2}:\d{2}')
result1 = re.sub(pattern, '', content1)
result2 = re.sub(pattern, '', content2)
result3 = re.sub(pattern, '', content3)
print(result1, result2, result3)

#2016-1-1  2017-1-1  2018-1-1 
1
2
3
4
5
6
7
8
9
10
11
12
13

2. re.match(pattern,string,flags=0)—从第一个字符开始匹配

• 该函数从第一个字符开始匹配，如果第一个对不上，就不可能匹配到数据。
  

• 从第一个字符开始进行匹配，不成功则返回None。

• 一个正则表达式中若有多个（）可用group方法输出，比如：ex_re=re.match(‘(.?)actor(.?)$’),可用ex_re.group()访问生成的列表，可用ex_re.group(0)访问第一个括号里的元素。

• pettern 就是正则字符串，如果是通过re.compile方法生成的正则对象.match来调用的话，就不需要这个参数了，因为正则对象本身就代表了一个正则匹配模式。

• string 就是要进行匹配的目标字符串

• flags 就是正则的修饰符，比如 re.I

import re
regex = '(foo\w)(\w)'
m = re.match(r'(foo\w)(\w)','fooasdfooasd')
if m is not None:
    print(m.group(1))
    print(m.groups())

#输出
#fooa
#('fooa', 's')
1
2
3
4
5
6
7
8
9
10

3. re.search(pattern,string,flags=0)—不固定开始，但是只匹配第一个

• re.search()并不要求必须从字符串的开头进行匹配如match()，也就是说，正则表达式可以是字符串的一部分。
• 用法基本与match相同，只不过是扫描整个字符串，从一开始匹配到的地方开始。

import re
regex = '<(.*)>(.*)<\/(.*)>|<(.*)\/>'
m = re.search(regex,"aa<a>aaaa</a>")
#一样只有search能匹配到标签
if m is not None:
    print(m)
    print(m.group())

# 结果
# <re.Match object; span=(2, 13), match='<a>aaaa</a>'>
# <a>aaaa</a>
1
2
3
4
5
6
7
8
9
10
11

4. re.findall(pattern, string，[, flags])—匹配所有数据

• match()和search()都是返回匹配到的第一个内容就结束匹配, findall()是返回所有符合匹配规则的内容
• 搜索字符串内，以列表形式返回全部能匹配的子串。

import re
text = "I am so happy! "
array1 = re.findall("[a-zA-Z]", text)
array2 = re.findall("[a-zA-Z]+", text)
print(array1)
print(array2)

#结果
# ['I', 'a', 'm', 's', 'o', 'h', 'a', 'p', 'p', 'y']
# ['I', 'am', 'so', 'happy']
1
2
3
4
5
6
7
8
9
10

5. finditer(pattern, string，[,flags] )—返回的是匹配到的迭代器对象

• 与findall()相同，但返回的是一个迭代器。对于每一次匹配，迭代器都能返回一个匹配对象

import re
regex = 'apple'
m = [ g.group() for g in re.finditer(regex,'apple1 apple2 apple3')]
print(m)
#输出
#['apple', 'apple', 'apple']
1
2
3
4
5
6

6. split(pattern, string, max = 0)

• 根据正则表达式的模式分隔符，split函数将字符串分割为列表，返回匹配列表，分割最多操作max次

import re
list = [
'aaa,bbb,ccc',
'ddd,eee,fff',
]
for i in list:
    print(re.split(',',i))


# ['aaa', 'bbb', 'ccc']
# ['ddd', 'eee', 'fff']
1
2
3
4
5
6
7
8
9
10
11

7. re.sub(pattern, repl, string, count=0, flags=0)—可正则的字符串替换

• 替换字符串中的某些子串，可以用正则表达式来匹配被选子串。
  pattern：表示正则表达式中的模式字符串；

• repl：被替换的字符串（既可以是字符串，也可以是函数）；

• string：要被处理的，要被替换的字符串；

• count：匹配的次数, 默认是全部替换

import re
st = "hello 2019"
st = re.sub("([0-9]+)","yudengwu",st)
print(st)

#结果
# hello yudengwu
1
2
3
4
5
6
7

8. str.replace(old, new，max)—不是re函数，仅用作字符串替换

• 替代字符串中的某一些子串为另一些字符。
• old – 将被替换的子字符串。
• new – 新字符串，用于替换old子字符串。
• max – 可选字符串, 替换不超过 max 次

import re
st = "我喜欢你，喜欢你"
st = st.replace("喜欢","爱",1)
print(st)

# 我爱你，喜欢你
1
2
3
4
5
6