Python（11）——正则表达式

---

目录：

正则表达式

Python中的re模块

---

一：正则表达式

正则表达式是一个特殊的字符序列，通常被用来对文本进行查询和替换功能。

基本上所有的编程语言都支持利用正则表达式对字符串进行一些操作，Python也不例外，在Python中正则表达式被打包在re模块中，使用正则表达式时导入re模块即可。

二：Python中的re模块

Python中的re模块支持正则表达式所有的操作，以一个简单的例子来示范，如下：

a = 'hello1234' # 使用Python中自带的replace方法来将数值替换为*
print(a.replace('1234', '*', 1)) 
# 这样是非常麻烦的，因为我们已经提前预知了字符串中的数值信息。
# 打印结果如下：
hello*
​
# 可以导入re模块，来使用re模块中的正则表达式实现方式
import re
a = 'hello1234' # 使用Python中re模块中正则表达式的实现,来更简洁有效的操作字符串
print( re.sub ( r'\d', '*', a ) )
# 打印结果如下：
hello****
# 可以见得使用正则表达式时更灵活便捷

re模块中有许多针对字符串有用的方法，如下：

re模块里面的字符串查找方法，search、match、finditer、findall方法。

re.search方法如下：

import re
# search方法是根据指定的规则在字符串中查找,并以re.match类型来保存
a = 'helloworld'
print(re.search( r'world', a ))
# 打印结果如下：
<re.Match object; span=(5, 10), match='world'>
# re.Match 表示这是一个re.Match对象
# span 表示字符串的位置
# match 表示查找的字符串
re.match方法如下：
import re
a = 'helloworld'
# match和search差不多,但是match是从开头匹配,如果匹配失败则直接返回None
print(re.match( 'world', a))
print(re.match( 'hello', a))
# 打印结果如下：
None
<re.Match object; span=(0, 5), match='hello'>

finditer方法如下：
import re
a = 'helloworld'
# finditer获取的是一个可迭代对象
print(re.finditer(r'l', a))
# 打印结果如下：
<callable_iterator object at 0x00000000006B4358>
​
​
# 既然是可迭代对象,那可以使用for..in语句来操作,如下：
for  n in re.finditer(r'l', a):
    print(n)
# 打印结果如下：
<re.Match object; span=(2, 3), match='l'>
<re.Match object; span=(3, 4), match='l'>
<re.Match object; span=(8, 9), match='l'>
（search和match与finditer方法不同的是，search、match方法只会查询一次，而finditer会全部查询。）

findall方法如下：
import re
a = 'helloworld'
# findall将匹配到的字符以字符串的形式保存在列表中
print( re.findall( r'l', a ) )
# 打印结果如下：
['l', 'l', 'l']

re中的Match类。
match、search、finditer、findall方法都是re.Match类的对象，这意味着它们可以使用re.Match类的方法，re.Match类中的方法如下：
import re
a = 'helloworld'
b = re.search(r'l', a) # 创建了一个Match类对象
print(dir(b)) # dir方法获取对象的所有属性和方法
# 打印结果如下：
[ 'end', 'endpos', 'expand', 'group', 'groupdict', 'groups', 'lastgroup', 'lastindex', 'pos', 're', 'regs', 'span', 'start', 'string']
​
# 下面介绍常用的方法
# Match类的group方法：
import re
a = 'hinihao'
# . 表示任意字符
# * 表示出现任意次数
b = re.search(r'(h.*h)(a.*o)', a) # 创建了一个Match类对象
# r'(h.*h)(a.*o)' 表示分成了3组：
# 0组：h.*ha.*o，表示从h后匹配任意字符到h结束，从a后匹配任意字符到o结束
# 1组： (h.*h) 表示从h匹配到任意h结束
# 2组： (a.*o) 表示从a后匹配任意字符到o
print(b.group(0)) 
print(b.group(1))
print(b.group(2))
# 打印结果如下：
hinihao
hinih
ao
​
# re.Match类还包含了groups方法，如下：
import re
a = 'hinihao'
# . 表示任意字符
# * 表示出现任意次数
b = re.search( r'(h.*h)(a.*o)', a ) 
print( b.groups( ) ) # grops将匹配的除了第一个分组的数据已元组的方式保存
# 打印结果如下：
('hinih', 'ao')
​
# compile方法
# compile方法得到一个re.pattern类型的对象
import re
a = re.compile(r'n')# 生成了一个re.Pattern对象,作为了匹配字符串的规则
print(type(a)) 
print(a.match('nhnhh')) # 直接传递给字符串,从而使用之前compile定义的规则
# 打印结果如下：
<class 're.Pattern'>
<re.Match object; span=(0, 1), match='n'>

正则表达式的匹配规则：
1.字符和数字表示其本身，如下：

import re
a = 'abcdefg110'
print(re.search(r'a', a)) # 匹配字符a
print(re.search(r'110', a)) # 匹配数值110
# 打印结果如下：
<re.Match object; span=(0, 1), match='a'>
<re.Match object; span=(7, 10), match='110'>

2.当字符前面出现了反斜杠时表示特殊含义，如“\d”表示数字。如下

import re
a = 'abcdefg110'
print( re.search( r'\d', a ) )
# 打印结果如下：
<re.Match object; span=(7, 8), match='1'>

3.绝大多数标点符号都是代表特殊含义，如下：

“.”代表任意字符，如下：
import re
a = 'abcdefg110'
print( re.search( r'a.c', a ) )
# 打印结果如下：
<re.Match object; span=(0, 3), match='abc'>
# 要想对.进行匹配,则需要使用反斜杠将其转义

正则表达式特殊字符详细：

1.\n：匹配一个换行符

import re
print( re.findall ( r'\n', 'abfc\nadsf' ) )
# 打印结果如下：
['\n']

2.\r：匹配一个回车符

import re
print(re.findall(r'\r', 'abfcadsf'))
# 打印结果如下：
[]

3.\t：匹配一个制表符

import re
print(re.findall(r'\t', 'abfcadsfjj'))
# 打印结果如下：
[]

4.\v：匹配一个垂直制表符

import re
print(re.findall(r'\v', 'abfcadsfjj'))
# 打印结果如下：
[]

5.\s：匹配任意空白符

import re
print(re.findall(r'\s', 'abfc ad sfj j'))
# 打印结果如下：
[' ', ' ', ' ']

6.\S：匹配任意非空白

import re
print(re.findall(r'\S', 'abfc ad sfj j'))
# 打印结果如下：
['a', 'b', 'f', 'c', 'a', 'd', 's', 'f', 'j', 'j']

7.\d：匹配数值

import re
print(re.findall(r'\d', 'abfc12ad sfj j'))
# 打印结果如下：
['1', '2']

8.\D：匹配非数值

import re
print(re.findall(r'\D', 'abfc12ad\nsfj\tj'))
# 打印结果如下：
['a', 'b', 'f', 'c', 'a', 'd', '\n', 's', 'f', 'j', '\t', 'j']

9.\w：匹配数值和字母

import re
print(re.findall(r'\w', 'abfc12ad\nsfj\tj'))
# 打印结果如下：
['a', 'b', 'f', 'c', '1', '2', 'a', 'd', 's', 'f', 'j', 'j']

10.\W：匹配除了字母和数字以外的字符

import re
print(re.findall(r'\W', 'ab*fc-12a,d\ns,f.j\tj'))
# 打印结果如下：
['*', '-', ',', '\n', ',', '.', '\t']

11. “.”：匹配除了换行以外的其他任意字符

import re
print(re.findall(r'.', 'abcsd\nda')) 
# 打印结果如下：
['a', 'b', 'c', 's', 'd', 'd', 'a']
# 要想匹配.则可以使用反斜杠进行转义

12.“[ ]”：表示一个区间（可选范围）

import  re
print(re.search(r'[a-z]', '120124a010g'))
# 打印结果如下：
<re.Match object; span=(6, 7), match='a'>
​
# 或者如下：
import  re
print(re.findall(r'[a-z]', '120124a010g'))
# 打印结果如下：
['a', 'g']

13.“|”：表示可选值，如下：

import  re
print(re.search(r'a(b|c)d', '1acd24a010g'))
# 打印结果如下：
<re.Match object; span=(1, 4), match='acd'>

14.“{ }”：表示限定{ }前面字符出现的次数，如下：

import  re
print(re.search(r'ab{2}', 'adffabb'))
# 打印结果如下：
<re.Match object; span=(4, 7), match='abb'>
​
# 可以增加匹配的次数，如下：
import  re
print(re.search(r'ab{2,}', 'adffabbbbbb')) 
#  r'ab{2,} 表示b要出现2次以上（包含2次）
# 打印结果如下：
<re.Match object; span=(4, 11), match='abbbbbb'>
​
# 可以是指定最高的出现次数以下，都匹配。如下：
import  re
print(re.search(r'ab{,4}', 'ffabbb'))
# 打印结果如下：
<re.Match object; span=(2, 6), match='abbb'>
​
# {n,m}：指定前面字符出现的次数区间

15.“？”：表示字符最多出现一次，如下：

import  re
print(re.search(r'a?b', 'ffabbb'))
# 打印结果如下：
<re.Match object; span=(2, 4), match='ab'>

16.“*”：表示字符出现任意次数，如下：

import  re
print(re.search(r'ab*c', 'ffaabbbc'))
# 打印结果如下：
<re.Match object; span=(3, 8), match='abbbc'>

17.“+”：表示字符出现一次以上，如下：

import  re
print(re.search(r'ab+c', 'ffaabbbc'))
# 打印结果如下：
<re.Match object; span=(3, 8), match='abbbc'>

18.“^”：表示以什么字符开始，如下：

import  re
print(re.search(r'^a', 'aabbbc'))
# 打印结果如下：
<re.Match object; span=(0, 1), match='a'>

19.“$”：表示以什么字符结束，如下：

import  re
print(re.search(r'a$', 'aabbbca'))
# 打印结果如下：
<re.Match object; span=(6, 7), match='a'>

re模块里面的替换方法：

sub方法可以实现，如下：

import  re
print(re.sub(r'\d', '*','aa123bbbca')) # \d表示匹配数值，将数值换为*
# 打印结果如下：
aa***bbbca
​
# 可以利用count来控制换的次数，如下：
import  re
print(re.sub(r'\d', '*','aa123bbbca',count=1)) 
# 打印结果如下：
aa*23bbbca
​
# 还可以在sub中使用函数来实现其他的特有需求

贪婪模式和非贪婪模式：

在正则表达式中，默认匹配时，都是可以能尽可能的多匹配。

在贪婪模式前加“？”可将贪婪模式转为非贪婪模式。

（鉴于正则表达式是一门独立的知识点，想要深入了解可以参考《精通正则表达式》）