python正则表达式函数的用法

正则表达式的用法

#导入模块 re
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'