Python编程——正则表达式（附实例）

正则表达式的介绍

正则表达式是简介表达一组字符串的表达式，正则表达式可以方便的检查一个字符串是否与某种模式匹配。在正则表达式中，使用最多的就是如下几种函数，在下面将分别介绍。

import re

re.match()   #match函数从头开始匹配,如果不是起始位置匹配成功的话，match函数的匹配结果就为none。
re.search()   #搜索整个字符串，并返回第一个成功的匹配
re.findall()   #搜索整个字符串，返回一个list(最常用的)
re.compile()   #compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象
re.split()    #将一个字符串按照正则表达式匹配的结果进行分割，返回列表类型
re.sub()    #在一个字符串中替换所有匹配正则表达式的子串，返回替换后的字符串

1. re.match函数

match函数从头开始匹配,如果不是起始位置匹配成功的话，match函数的匹配结果就为none。匹配成功，re.match方法返回一个匹配的对象

语法如下：re.match(pattern, string, flags=0)

• pattern：需要匹配的正则表达式；
• string：在那个字符串中就行匹配 ；
• flags：标志位（默认为0），它可以控制正则表达式的匹配方式

常见的flags如下:

• re.I 忽略匹配时的大小写
• re.M 多行匹配，影响 ^ 和 $
• re.S . 默认不匹配换行，使 . 匹配包括换行在内的所有字符
• re.U 根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B

示例如下：

我们可以看出，match函数匹配成功的话，re.match方法返回一个匹配的对象，而不是匹配的正则表达式；通过span（）可以获取匹配的位置。

>>> import re
>>> astr='11you are 3344 my apple\n 11开心果，you\n66a77'
>>> re.match('11',astr)
<_sre.SRE_Match object; span=(0, 2), match='11'>
>>> re.match('11',astr).span()
(0, 2)
>>> print(re.match('you',astr))
None

如果需要将匹配的正则表达式显示出来，我们就需要使用group(num) 或 groups() 匹配对象函数来获取匹配的表达式。

例如：re.match(r'\d(.)(\d)',astr))，在需要匹配的字符串中，可以有多个括号，每个括号为一组。

• group(0)匹配的是整个表达式的字符串,即\d(.)(\d)；
• group(1)表示第一个括号里的内容，即（.）; 依次类推。
• group(num=2,3,4...)表示对应括号的内容;
• groups()返回一个包含所有括号里面的字符串的内容，返回的结果为一个元组。

>>> import re
>>> astr='11you are 3344 my apple\n 11开心果，you\n66a77'
>>> re.match('\d(\d)(.)',astr,re.S).group(0)
'11y'

>>> re.match('\d(\d)(.)',astr,re.S).group(1)
'1'

>>> re.match('\d(\d)(.)',astr,re.S).group(2)
'y'

>>> re.match('\d(\d)(.)',astr,re.S).groups()
('1', 'y')

2. re.search函数

搜索整个字符串，并返回第一个成功的匹配。

语法如下：re.search(pattern, string, flags=0)

• pattern：需要匹配的正则表达式；
• string：在那个字符串中就行匹配 ；
• flags：标志位（默认为0），它可以控制正则表达式的匹配方式

常见的flags如下:

• re.I 忽略匹配时的大小写
• re.M 多行匹配，影响 ^ 和 $
• re.S . 默认不匹配换行，使 . 匹配包括换行在内的所有字符
• re.U 根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B

 示例如下：

我们可以看出，search函数匹配成功的话，re.search方法返回一个匹配的对象，而不是匹配的正则表达式；通过span（）可以获取匹配的位置。如果没有匹配到，则返回为None。

>>> import re
>>> astr='11you are 3344 my apple\n 11开心果，you\n66a77'
>>> re.search('11',astr)
<_sre.SRE_Match object; span=(0, 2), match='11'>

>>> re.search('you',astr)
<_sre.SRE_Match object; span=(2, 5), match='you'>

>>> re.search('you',astr).span()   #通过span（）获取匹配的位置
(2, 5)

>>> re.search('11',astr).span()
(0, 2)

>>> print(re.search('22',astr))
None

如果需要将匹配的正则表达式显示出来，我们就需要使用group(num) 或 groups() 匹配对象函数来获取匹配的表达式。

例如：re.search(r'\d(.)(\d)',astr))，在需要匹配的字符串中，可以有多个括号，每个括号为一组。

• group(0)匹配的是整个表达式的字符串,即\d(.)(\d)；
• group(1)表示第一个括号里的内容，即（.）; 依次类推。
• group(num=2,3,4...)表示对应括号的内容;
• groups()返回一个包含所有括号里面的字符串的内容，返回的结果为一个元组。

>>> import re
>>> astr='1you are 3344 my apple\n 11开心果，you\n66a77'
>>> re.search('\d(\d)(.)',astr,re.S).group(0)
'334'

>>> re.search('\d(\d)(.)',astr,re.S).group(1)
'3'

>>> re.search('\d(\d)(.)',astr,re.S).group(2)
'4'

>>> re.search('\d(\d)(.)',astr,re.S).groups()
('3', '4')

re.match 函数与re. search函数的区别：

re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配，如果没有匹配到，则返回None。

3. re.findall函数

搜索整个字符串，返回一个list

语法如下：re.findall（string）

 示例如下：

>>> import re
>>> astr='1you are 3344 my apple\n 11开心果，you\n66a77'
>>> re.findall('\d\d',astr)         #列表形式显示所有的两个数字
['33', '44', '11', '66', '77'] 

>>> re.findall('\d{2,4}',astr)      #列表形式显示所有的2——4个数字，默认贪婪匹配
['3344', '11', '66', '77']

>>> re.findall('\d+',astr)          #（1，无穷）
['1', '3344', '11', '66', '77']

>>> re.findall('\d*',astr)          #（0，无穷）
['1', '', '', '', '', '', '', '', '', '3344', '', '', '', '', '', '', '', '', '', '', '', '11', '', '', '', '', '', '', '', '', '66', '', '77', '']

>>> re.findall('\d?',astr)          #匹配0或1
['1', '', '', '', '', '', '', '', '', '3', '3', '4', '4', '', '', '', '', '', '', '', '', '', '', '', '1', '1', '', '', '', '', '', '', '', '', '6', '6', '', '7', '7', '']

>>> re.findall('\d{2,3}?',astr)      #一个模式后跟？，不贪婪匹配，范围后面？，有两次就先取两次
['33', '44', '11', '66', '77']

>>> re.findall('\d.\d',astr)         #匹配两个数字与中间任意字符
['334', '6a7']

>>> re.findall('^\d',astr)           #以数字开头
['1']

>>> re.findall('^\d',astr,re.M)      #多行匹配
['1', '6']   

>>> re.findall('\d$',astr)           #以数字结尾
['7']

>>> re.findall('\d$',astr,re.M)      #多行匹配，影响^和$
['7']

>>> re.findall('\d(.)(\d)',astr,re.S)#列表形式返回，每项为一个元组
[('3', '4'), ('a', '7')]

4. re.compile函数

compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象。

语法如下：re.compile(pattern，flags=0)

• pattern：需要匹配的正则表达式；
• flags：标志位（默认为0），它可以控制正则表达式的匹配方式

常见的flags如下:

• re.I 忽略匹配时的大小写
• re.M 多行匹配，影响 ^ 和 $
• re.S . 默认不匹配换行，使 . 匹配包括换行在内的所有字符
• re.U 根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B

示例如下：

>>> import re
>>> astr='AS12as34er567q!"3456'
>>> m1=re.compile(r'\d\d')     #编译
>>> m1.search(astr).group()    #匹配
'12'

>>> m1.findall(astr)
['12', '34', '56', '34', '56']

>>> m2=re.compile(r'a',re.I)  #编译
>>> m2.findall(astr)          #匹配
['A', 'a']  

5. re.split函数

将一个字符串按照正则表达式匹配的结果进行分割，返回列表类型

语法如下：re.split(pattern, string , maxsplit=0 ，flags=0)

• pattern：需要匹配的正则表达式；
• string：在那个字符串中就行匹配 ；
• maxsplit：分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。
• flags：标志位（默认为0），它可以控制正则表达式的匹配方式

常见的flags如下:

• re.I 忽略匹配时的大小写
• re.M 多行匹配，影响 ^ 和 $
• re.S . 默认不匹配换行，使 . 匹配包括换行在内的所有字符
• re.U 根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B

 示例如下：

>>> import re
>>> astr='AS12as34er567q!"3456'
>>> astr.split('12')           #通过12进行分割
['AS', 'as34er567q!"3456']

>>> re.split("\d{2}",astr)     #通过两个数字进行分割
['AS', 'as', 'er', '7q!"', '', '']

>>> re.split("\d+",astr)       #通过数字进行分割
['AS', 'as', 'er', 'q!"', '']

>>> m3=re.compile(r'\d+')      #与上面等价，运用了compile函数
>>> m3.split(astr)
['AS', 'as', 'er', 'q!"', '']  

>>> m3.split(astr,3)           #指定分割几次
['AS', 'as', 'er', 'q!"3456']

6. re.sub函数

在一个字符串中替换所有匹配正则表达式的子串，返回替换后的字符串

语法如下：re.sub(pattern, repl, string, count=0，flags=0)

• pattern：需要匹配的正则表达式；
• repl : 替换的字符串，也可为一个函数。
• string：在那个字符串中就行匹配 ；
• count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
• flags：标志位（默认为0），它可以控制正则表达式的匹配方式

常见的flags如下:

• re.I 忽略匹配时的大小写
• re.M 多行匹配，影响 ^ 和 $
• re.S . 默认不匹配换行，使 . 匹配包括换行在内的所有字符
• re.U 根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B

 示例如下：

>>> import re
>>> astr='AS12as34er567q!"3456' 
>>> re.sub("5",'9',astr)     #将5替换为9
'AS12as34er967q!"3496'

>>> m4=re.compile(r"\d+")    
>>> m4.sub(' ',astr)         #将数字替换为空字符串
'AS as er q!" '

>>> m4.sub(' ',astr,2)       #指定替换几次
'AS as er567q!"3456'

 repl参数是一个函数，实现将字符串中的数字乘以2

>>> import re
>>> def f(m):
...     return str(2*int(m.group()))
...
>>> re.sub('\d',f,'a2233q')
'a4466q'

7. 正则表达式修饰符 - 可选标志

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：

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

---

8. 正则表达式的常见模式

常见模式：

模式	描述
^	匹配字符串的开头
$	匹配字符串的末尾。
.	匹配任意字符，除了换行符，当re.S标记被指定时，则可以匹配包括换行符的任意字符。
*	前一个字符0次或无限次扩展
+	前一个字符1次或无限次扩展
?	前一个字符0次或1次扩展，非贪婪方式
{m}	扩展前一个字符m次。例如， ab{2}c表示abbc
{m,n}	扩展前一个字符m至n次（包含n），贪婪方式
a| b	匹配a或b
( )	分组标记，内部只能使用  |  操作符，
\w	匹配字母数字及下划线，等价于[A-Za-z0-9_]
\W	匹配非字母数字及下划线,等价于 '[^A-Za-z0-9_]'
\s	匹配任意空白字符，等价于 [\t\n\r\f].
\S	匹配任意非空字符,  等价于 [^ \f\n\r\t\v]
\d	匹配任意数字，等价于 [0-9].
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B	匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。

正则表达式实例：

实例	描述
^[A-Za-z]+$	由26个字母组成的字符串
^[A-Za-z0-9]+$	由26个字母和数字组成的字符串
^-?\d+$	整数形式的字符串
[1-9]\d{5}	中国境内邮政编码，6位
[\u4e00-\u9fa5]	匹配中文字符
\d{3}-\d{8}|\d{4}-\d{7}	电话号码