python正则表达式详解（三）：正则表达式常用方法（函数）

内容提要：

说明：仅供学习交流使用

compile   match    fullmatch search   sub      subn     split    findall  finditer  purge    escape 

三、python正则表达式中常用的方法（函数）

3.1 compile  

将模式编译为模式对象.

用法：
re.compile(pattern, flags=0)

#示例：

p=re.compile('\d{4}\-\d{7}',re.A)
print(type(p))
# <class 're.Pattern'>

flags参数说明:
该参数表示一系列的内置的变量，分别如下：
 A  ASCII       使模板匹配ASCII码范围内的\w, \W, \b, \B, \d, \D，该模板在unicode编码范围内才有意义，对python
                      默认是使用的该模式.
 I  IGNORECASE  执行不区分大小写的匹配
 L  LOCALE      使\w， \w， \b， \b，取决于当前区域设置.
 M  MULTILINE   多行匹配模式，使"^"和“$”能在一个换行符后继续使用。
 S  DOTALL      使"."能够匹配包括换行符的所有字符.
 X  VERBOSE     为更优雅的显示正则表达式，忽视注释与空白字符.
 U  UNICODE     仅供兼容性。忽略字符串模式(默认)，并且禁止字节模式。

3.2 match    

从头开始匹配一个正则表达式模式，如果匹配，则返回一个match对象，如果不匹配，则返回None,即使在多行模式下，匹配也是从整个字符串的开头开始，而不是从每行的开头开始。

语法格式：match(pattern, string, flags=0)

#示例：
# ip地址的匹配：正则(\d{1,3}\.){3}(\d{1,3})
#1.直接由re调用match 进行匹配
m=re.match(r'(\d{1,3}\.){3}(\d{1,3})','192.168.1.1')

print(type(m))
# <class 're.Match'>

print(m.group())
# 192.168.1.1

#2.利用pattern对象进行匹配
p=re.compile(r'(\d{1,3}\.){3}(\d{1,3})')

m=p.match('192.168.1.1')

print(type(m))
# <class 're.Match'>

print(m.group())
# 192.168.1.1

#上面的例子中正则与要匹配的字符是完全匹配的，如果是部分匹配，示例如下：
#本处利用上面的模板，旨在探索match对部分匹配的处理

#正则匹配部分字符串，但不是整个字符串
m=p.match('192.168.1.1 is my ip address')

#查看结果：
print(m)
# <re.Match object; span=(0, 11), match='192.168.1.1'>.匹配

#部分字符串匹配正则表达式的部分，
m=p.match('192.168.1 is a wrong ip address')

#查看结果：
print(m)
# None

结论：只有从字符串的开头完全匹配正则表达式的时候，才会返回结果，无论字符串是否是整个字符串一部分。否则返回None

3.3 fullmatch

完全匹配，如果整个字符串匹配正则表达式，才会返回match对象，如果不匹配或有部分匹配，返回None.

语法格式：fullmatch(pattern, string, flags=0)

#示例：
# ip地址的匹配：正则(\d{1,3}\.){3}(\d{1,3})
p=re.compile('(\d{1,3}\.){3}(\d{1,3})')

m=p.fullmatch('192.168.1.1')

print(m)
# <re.Match object; span=(0, 11), match='192.168.1.1'>

#正则匹配部分字符串，但不是整个字符串
m=p.fullmatch('192.168.1.1 is my ip address')

#查看结果：
print(m)
# None

3.4 search   

在字符串中搜索是否存在模式，不是从字符串的开头进行匹配，而是在整个字符串的所有位置进行查找，返回第一个 符合条件的字符的match对象

语法格式:search(pattern, string, flags=0)

#示例：
#查找一个字符串是否出现ip地址
p=re.compile('(\d{1,3}\.){3}(\d{1,3})')

m1=p.search('my ip address is 192.168.1.1')

print(m1)
# <re.Match object; span=(17, 28), match='192.168.1.1'>

m2=p.search('my ip address is 192.168.1.1,and the local loop address is 127.0.0.1')

print(m2)
# <re.Match object; span=(17, 28), match='192.168.1.1'>

结论:search只会查找是否在字符串出现了匹配正则的字符串，不论其是否在开头，同时， search方法也不会判断一个字符串有几个匹配。search也只会返回第一个匹配的字符串。

3.5 sub      

替换字符串中出现的符合表达式的字符串,如果替换成功，则返回替换后的字符串，如果没有替换成功，则返回原字符串.
语法格式:sub(pattern, repl, string, count=0, flags=0)
参数说明：
       repl:要替换的字符串，可以是一个字符串，也可以是一个函数（方法），字符串中也可以 含有正则

#示例：
#普通的替换：将一个字符串所有ip地址全部替换为字符ipaddr
p=re.compile('((\d{1,3}\.){3}(\d{1,3}))')

raw_string='my ip address is 192.168.1.1,and the local loop address is 127.0.0.1'

new_string=p.sub('ipaddr',raw_string)

print(new_string)
# my ip address is ipaddr,and the local loop address is ipaddr

#利用正则表达式将所有的ip变成[ip]的形式
new_string=p.sub(r'[\1]',raw_string)

print(new_string)
# my ip address is [192.168.1.1],and the local loop address is [127.0.0.1]

#定义一个函数，用来处理匹配到的内容：该函数要接受一个match的对象，同时，返回一个字符串

def identify_ip(ipobj):
    if ipobj is not None:
        ip=ipobj.group()
        if ip=='192.168.1.1':
            return '%s(remote ip)'% ip
        elif ip=='127.0.0.1':
            return '%s(local ip)'% ip
    pass

new_string=p.sub(identify_ip,raw_string)

print(new_string)
# my ip address is 192.168.1.1(remote ip),and the local loop address is 127.0.0.1(local ip)

3.6 subn     

与sub相同，但返回替换次数.

#示例：
#利用前面的模板，查看当前的模板：
new_string=p.subn('ipaddr',raw_string)

print(new_string)
# ('my ip address is ipaddr,and the local loop address is ipaddr', 2)

结论，subn返回的是一个tuple，在该tuple中，有两个值，前面是返回的替换后的字符串，后面是替换的次数。

3.7  split    

利用与表达式匹配的子字符串分割给定字符串.
语法格式: split(pattern, string, maxsplit=0, flags=0)
                 返回的值是一个分割后的列表

#示例:
#利用数字进行分割
res=re.split('\d','an apple is $5,an orange is $1, a banana is $2')

print(res)
# ['an apple is $', ',an orange is $', ', a banana is $', '']

#利用3位数字进行分割
res=re.split('\d{3}','an apple is $5,an orange is $1, a banana is $2')

print(res)
# ['an apple is $5,an orange is $1, a banana is $2']，也就是说，如果在没有符合条件的字符串进行分割，也会返回一个list，在该list中，
#会包含一项整个字符串的项。

#利用一个空字符进行分割：
res=re.split(r'\s+','an apple is $5,an orange is $1, a banana is $2')

print(res)
# ['an', 'apple', 'is', '$5,an', 'orange', 'is', '$1,', 'a', 'banana', 'is', '$2']

#利用以a开头的字符进行分割
print(re.split(r'a\B','an apple is $5,an orange is $1, a banana is $2'))
# ['', 'n ', 'pple is $5,', 'n or', 'nge is $1, a b', 'n', 'na is $2']

 

3.8 findall  

找到所有的符合正则表达式的字符串返回的是一个列表.
语法：findall(pattern, string, flags=0)
返回：一个匹配正则表达式的字符串列表。

# 示例：查找字符串中的所有的非字母数字字符
print(re.findall(r'\W+','Period:.,Question Mark:?,Exclamtion Mark:!,Comma:,,Colon::,Ellipsis:...,Semicolon:;,Hyphen:-'))
# [':.,', ' ', ':?,', ' ', ':!,', ':,,', '::,', ':...,', ':;,', ':-']

#如果在正则表达式中有多个组
print(re.findall(r'(\(\w+\))=(\d+)','ord(a)=67,ord(b)=68,ord(c)=69,ord(d)=70,ord(e)=71'))
# [('(a)', '67'), ('(b)', '68'), ('(c)', '69'), ('(d)', '70'), ('(e)', '71')]

3.9 finditer 

返回一个迭代器，为每个匹配生成一个匹配对象.
语法：finditer(pattern, string, flags=0)
返回：一个match的迭代器

# 示例：查找字符串中的所有的非字母数字字符
print(re.finditer(r'\W+','Period:.,Question Mark:?,Exclamtion Mark:!,Comma:,,Colon::,Ellipsis:...,Semicolon:;,Hyphen:-'))
# <callable_iterator object at 0x000001634595D2B0>

#如果在正则表达式中有多个组
print([x for x in re.finditer(r'(\(\w+\))=(\d+)','ord(a)=67,ord(b)=68,ord(c)=69,ord(d)=70,ord(e)=71')])
# [<_sre.SRE_Match object; span=(3, 9), match='(a)=67'>, ...],迭代出的每一个对象可以按match对象的操作方法进行操作。

3.10 escape   

转义字符串中所有的非数字字母字符.
说明：当要匹配的字符串含有正则表达式的元字符的时候，可以先利该方法进行转义。

#如我们需要匹配一个字符串中的文件名，test.py，可以用如下的表达式：
print(re.findall(re.escape('test.py'),'I hava a test.py in the folder named test_py'))
# ['test.py']

print(re.findall('test.py','I hava a test.py in the folder named test_py'))
# ['test.py', 'test_py']