Python中的re模块--正则表达式

Python中的re模块--正则表达式

使用match从字符串开头匹配

以匹配国内手机号为例，通常手机号为11位，以1开头。大概是这样13509094747，（这个号码是我随便写的，请不要拨打），我们通常还能看到其他美观的显示形式。

• 135-0909-4747
• 135 0909 4747

前三位由运营商规定，这里我们不考虑。

如何使用正则表达式匹配类似上面的手机号呢？

import re

result = re.match('\d\d\d-\d\d\d\d-\d\d\d\d', '135-0909-4747')
print(result)

\d表示匹配一个数字。于是上面的写法可以匹配，但是打印的内容是这样的

# out
<_sre.SRE_Match object; span=(0, 13), match='135-0909-4747'>

没有出现None说明匹配成功了，字符范围[0, 13]，十一位的手机号加上两位分隔符-刚好13位。match里显示了匹配成功的字符串。这样的结果并不直观。

使用result.group()即可提取出match里面的内容。并且是str类型，更方便我们处理。

...
print(result.group()) # out: 135-0909-4747

上面的写法还是太臃肿，result = re.match('\d{3}-\d{4}-\d{4}', '135-0909-4747')，这种写法和上面等价。{}里面的次数表示要匹配的次数。当然里面可以填区间，区间是闭区间，包含左右的数字。比如

• \d{3,} 匹配数字3或者3次以上
• \d{,9} 匹配数字0次~9次之间
• \d{2,4}匹配数字2次~4次之间

一定要注意，填入区间的时候，逗号左右都没有空格。

如果一个规则我们经常要用到，可以使用re.compile编译成一个pattern object对象。像这样

import re

phone_p = re.compile('\d{3}-\d{4}-\d{4}')
result = re.match(phone_p, '135-0909-4747')
print(result)
# result = phone_p.match('135-0909-4747')
# print(result)

phone_p是一个对象，可以用它直接调用match方法，直接填入要匹配的字符串就好了。就像上面被注释掉的地方一样。也可以使用re.match，不同的是，第一个参数需要填上这个模式对象，第二个参数才是要匹配的字符串。两种方法得到的结果一样，喜欢哪种用哪种。

使用search搜寻字符串中可能存在的匹配

re还有一个serach方法，和match用法极其相似。唯有不同的是，match要求匹配必须从字符串的开头开始，也就是说，如果第一个字符就不匹配，后面即使有和模式匹配的字符串，也被认为是匹配失败。这么说不好理解。举个例子，还是手机号。

import re

phone_p = re.compile('\d{3}-\d{4}-\d{4}')
result = re.match(phone_p, 'Bob 135-0909-4747')
print(result)

在手机号前加了机主姓名，我们可以看到，后面还是以前的手机没有变，按理说这个模式应该能提取出手机号，但是打印的却是None，因为使用的是match匹配，模式中要求是3个数字打头，然后给出的字符串以字母开始。第一个字符就挂掉了。所以说match是从字符的开头匹配的。

再看看search呢？

只需将match改成search，输出<_sre.SRE_Match object; span=(4, 17), match='135-0909-4747'>表示匹配成功，字符范围[4:17]，不含17。可以看到search搜寻字符串里所有可能的情况，一旦发现有匹配的子字符串就返回。

为了加深理解，再看这样的例子

import re
# 注意多了个^
phone_p = re.compile('^\d{3}-\d{4}-\d{4}')
result = re.search(phone_p, 'Bob 135-0909-4747')
print(result) # None

再模式的最前面加上^表示匹配开始的标志，即必须以^后的内容开头，在这句里的意思就是必须以3个数字开头（而不是1个，\d{3}是一个整体）。可以看到，即使是search方法也不能匹配成功了。因被强制从字符串开头处开始匹配，这句的意思不就和和使用match方法达到同样的效果了吗？

说到^就不得不提$，后者是匹配结束的标志，必须以$前的字符结尾。

import re

phone_p = re.compile('^\d{3}-\d{4}-\d{4}$')
# 不小心在开头或者结尾多输入了一位
result = re.search(phone_p, '135-0909-47475') # or 1135-0909-4747
print(result) # None

显然结是4个数字结尾（或不是3个数字开头），返回None。

这句模式限制了必须是11位的数字加分隔符组成。多一位少一位都不行。

还有一个地方要注意，不管是match还是search，即使可能存在多个正确的匹配，它们找到第一个后就立即停止，所有我们得到的永远是第一个成功匹配的字符串。

import re

phone_p = re.compile('\d{3}-\d{4}-\d{4}')
result = re.search(phone_p, 'My phone number is 135-0909-4747 and another is 123-4567-8901')
print(result) # 135-0909-4747

找到第一个手机号就不在匹配了，第二个手机号被忽略了。

使用findall找到所有成功的匹配

上面的例子，如何找到所有的手机号呢？用re.findall，它返回所有成功匹配字符串的列表.

import re

phone_p = re.compile('\d{3}-\d{4}-\d{4}')
result = re.findall(phone_p, 'My phone number is 135-0909-4747 and another is 123-4567-8901')
print(result)

仅是将search换成findall，会打印['135-0909-4747', '123-4567-8901']可以看到，所有的手机号都被找到了！

在正则表达式中尽量使用原始字符串

由于正则表达式中经常要用到\，而转义字符可能影响到我们的模式表达。

p = re.compile('gg\\d')
p_1 = re.compile('gg\d')

print('\d') # \d
print('\\d') # \d

上面的例子，打印结果都一样\d，因为\d没有对应的转义。两种模式的写法也没有区别。

但是有些字符是可以转义的，比如n。

print('\n') # 换行
print('\\n') # \n

上面例子，结果就不一样了。又回到正则表达式中来

p_0 = re.compile('gg\n') # 匹配'gg\n', \n换行
p_1= re.compile('gg\\n') # 匹配'gg\n'， \n换行
# 使用了原始字符串
p_2 = re.compile(r'gg\n') # 匹配'gg\n'，\n换行
p_3 = re.compile(r'gg\\n') # 匹配'gg\\n', \n字符串

可以看到没有使用原始字符串时候，会让人迷惑，上述前两行，两种匹配模式匹配的都是gg和一个换行符。使用了原始字符串就比较清楚了，待匹配的字符串（就不要再使用原始字符串了），和模式对应起来了，不会混淆，如上述的最后两行代码。

当然打印的时候又会有些不一样

print('gg\\n') # gg\n
print('gg\n') # gg换行
print(r'gg\n') # gg\n
print(r'gg\\n') # gg\\n

打印时，原始字符串完全忽略了\对字符的转义，字符串里是啥样，打印出来就是啥样。

在正则表达式里面的原始字符串（对\还是有一定程度的影响）和打印时候的原始字符串还时有点差别的。

原始字符串在处理文件路径时相当有用。

# 这么写不对，会被转义，结果就是路径错了
filepath = 'F:\nb\person\a.txt' 
# 保险一点的做法,用\\将自身转义，表示真正意义上的'\'，
filepath = 'F:\\nb\person\\a.txt'
# 使用原始字符串
filepath = r'F:\nb\person\a.txt'

当然了，直接用Linux/OS X的路径方式在Windows上貌似也是可以的。直接远离了转义字符的困扰。

filepath = 'F:/nb/person/a.txt'

也可以运行成功，没问题。

讨论了这么多其实就想说，正则表达式编译模式时，尽可能地使用原始字符串。

高级匹配模式

"[]"匹配集合里面的任意一个字符

import re

p = re.compile(r'[朱刘马]帅吃饭了吗')
result = re.match(p, '马帅吃饭了吗') # or 朱帅吃饭了吗 or 刘帅吃饭了吗
print(result)

[]里面的内容表示任意一个字符，只要在这个集合里面的就能匹配成功。所以上面的模式可以匹配

马帅吃饭了吗
朱帅吃饭了吗
刘帅吃饭了吗

这是针对单个字符的，还可以这样写[a-z0-9]代表一个范围。这表示一个字符只要是字母或者数字就能匹配成功，当然后面可以加上{}。p = re.compile(r'[0-9]{3}')可以匹配3位数字，其实和\d+{3}异曲同工。

"|"匹配这个或那个字符串

上面的例子还可以这样写。

import re

p = re.compile(r'朱|刘|马帅吃饭了吗')

result = re.match(p, '马帅吃饭了吗')
print(result)

效果和上面一样。这是单个字符的时候，来看看涉及到特定的多个字符时候。

import re

p = re.compile(r'Bob|Jerry|Tom Lee')

result = re.match(p, 'Jerry Lee')
print(result)

这能匹配三个人名

Bob Lee
Jerry Lee
Tom Lee

如果使用[]就不好操作了。下面也能匹配上面的三个名字，不过哪个更易懂不言而喻。所以要分场合用最合适的。

p = re.compile(r'[BJT][oe][brm][\sry]{,2} Lee')

还有一点，[]里可以使用^表示“非”的意思。

p = re.compile(r'[^0-9]')这就表示，除开数字的其他任意一个字符。

“?”匹配0次或者1次

import re

p = re.compile(r'我有一万?元')

result = re.match(p, '我有一元') # or我有一万元
print(result)

“万”字匹配0次（没有）或者1次都是成功的。通俗点讲，这个字符时可选的。其实用?可以看成是p = re.compile(r'我有一万{,1}元')的简写。

“*”匹配任意次, "+"匹配至少1次

*可以匹配0次，也可以匹配多次。实际上可看作p = re.compile(r'我有一万{0,}元')

+匹配至少一次，可以看作p = re.compile(r'我有一万{1,}元').这意味着它不能匹配我有一元，必须含有一个或者多个“万”字。

贪婪匹配和非贪婪

Python的正则表达式默认是贪婪匹配。这意味着它将尽可能多的，尽可能往后匹配。只要后面还有能成功匹配的字符串，就不会停下来。

比如

import re

p = re.compile(r'我有一万*')
result = re.match(p, '我有一万万万万万')
print(result)

虽然*可匹配0次，1次...多次。但是不是返回我有一或者我有一万，而是后面有多少就匹配到多少。

如果要变成非贪婪匹配呢？后加?

p = re.compile(r'我有一万*?')
result = re.match(p, '我有一万万万万万')

这样就会尽可能少的匹配，因为*最少能匹配0次，所以这里返回我有一。

注意，这里的?不要解释成0次或者1次，在非贪婪里面的?和上面介绍的?是有差别的。

通配字符"."

.可以匹配除了换行符之外的所有字符，如果加入标志位flags=re.DOTALL，使得.什么都可以匹配（包括换行符），还有re.IGNORECASE和re.VERBOSE

# re.DOTALL
p = re.compile(r'good.haha', re.DOTALL)
result = re.findall(p, 'good\nhaha')
# 按位或可以同时使用两种模式
p = re.compile(r'good.haha', re.IGNORECASE | re.DOTALL)
result = re.findall(p, 'GOOD\nHahA')

# re.VERBOSE可以忽略空白字符和注释，当模式比较复杂时这样可能会直观点
p = re.compile(r'''    \w+. # asdf    \w+''' # some..
               , re.IGNORECASE | re.DOTALL | re.VERBOSE)

result = re.findall(p, 'GOOD\nHahA')

顺便一提，\w匹配单词字符，它包括了数字

搭配*和?更好用

.*  贪婪匹配所有字符
.*? 非贪婪匹配所有字符

举个例子

import re
#贪婪
p = re.compile(r'abcd.*1234', re.DOTALL)
result = re.findall(p, 'abcdDAMN1234IT1234')
print(result) # ['abcdDAMN1234IT1234']全部匹配
# 非贪婪
p = re.compile(r'abcd.*?1234', re.DOTALL)
result = re.findall(p, 'abcdDAMN1234IT1234')
print(result) # ['abcdDAMN1234']遇到第一个1234就停止

使用捕获组

上面的例子如果使用()将.*?包含起来，在findall下将只返回括号里的内容，这很有用，往往我们需要的只是那里面的内容。

```python
import re

p = re.compile(r'abcd(.*?)1234', re.DOTALL)
result = re.findall(p, 'abcdFUCK1234')
print(result) # ['FUCK']
```

如果有多个括号呢？

import re
p = re.compile(r'[aprint(result.group(1))print(result.group(2))print(result.group(3))-z]+((\d+)-(\d+))[a-z]+', )

result = re.findall(p, 'afs123-456gds')
print(result)

可以看到，我们把数字用括号包起来了，这里有3个括号。输出是这样的

[('123-456', '123', '456')]列表里面实际上是一个元组，分别对应了三个括号里面的值。如果觉得findall返回的形式不够清楚，可以用group

p = re.compile(r'[a-z]+((\d+)-(\d+))[a-z]+', )

result = re.match(p, 'afs123-456gds')
print(result.group()) # afs123-456gds
print(result.group(1)) # 123-456
print(result.group(2)) # 123
print(result.group(3)) # 456

group()或者group(0)意思一样，永远放回匹配成功的整个字符串。貌似和括号没有什么关系。不过要是使用group(1)查看下就会发现，它返回了第一个分组里的内容。上面共有3个分组，所以最多group(3)，group(4)就要报错了。发现Python将最外层的括号视为第一组，里面的分组按照从左到右的顺序依次为第二组、第三组。

还能使用groups()方法，返回所有分组（注意和group()区分）

('123-456', '123', '456')按照顺序依次是第一第二第三组，这和用findall返回的数据一样（只是少了列表包围）

分割字符串

使用re.split()

import re
# 以这个模式为分隔符
p = re.compile(r'\d+')

result = re.split(p, 'tom32jerry456haha')
print(result) # ['tom', 'jerry', 'haha']

可以看到，以数字为分隔符，将单词提取出来了。

字符串的替换

还是上面的例子，上面以数字分割，这次让汉字替换掉数字。

import re

p = re.compile(r'\d+')

result = re.sub(p, '中文', 'tom32jerry456haha')
print(result) # tom中文jerry中文haha

如果要用到匹配得文本本身，可以使用\1和\2这样的形式，表示使用分组得第一组和第二组，\0没有这样的写法，这会被当成空字符串

import re

p = re.compile(r'(\d+)abcd(\d+)')

result = re.sub(p, r'\2invert\1', '12345abcd67890')
print(result) # 67890invert12345

有两个分组，r'\2\1'这里要使用原始字符串，不用的话自己试试看输出啥东西。

表示用分组2invert分组1得内容替代原字符串。由于分组1为12345，分组2为67890，所以是使用了67890invert12345代替了原字符串.

哦对了，平常还有一个用得比较多。\s可以匹配空格/换行符/制表符等等空白字符。其他的，用到的时候再查表吧！

针对我个人日常得使用，掌握这么多应该差不多了。不过有个博客总结得更详细，推荐Python正则表达式指南