python标准库之re库详解

re正则解析库 主要用于字符串匹配,为什么要用re,因为re比xpath快10倍,xpath比bs4快10倍!

• re库使用raw string 类型(原生字符串类型)来表达正则表达式

• 原生字符串在字符串外面加个r比如r’hello world’ 或 r’[1-9\d{5}]’

• 在python中"\"被定义为转义符,如果不使用原生字符串会更麻烦

一、re库的6个常用功能函数调用

1.re.search()
在被搜索的字符串中匹配正则表达式的第一个位置,返回match对象
参数：
pattern：正则表达式

string：被匹配的字符串

flags=0：控制标记
re.I：忽略大小写区分,比如[A-Z]会匹配出大写A-Z和小写a-z
re.M：正则表达式中的’^’,表示只匹配字符串的开始部分,设定re.M后,假如字符串是一篇文章,那么会匹配每一行的开始部分
re.S：能够让‘.’匹配所有的字符,默认中’.'不能匹配换行符

实例：

import re
m = re.search(r'[a-z]{5}','123hello')
print(m[0])#结果将匹配出‘hello’

2.re.match()
从被搜索的字符串的起始位置匹配正则表达式,返回match对象
参数：
pattern、string、flags=0 功能同上
实例：

import re
m = re.match(r'[a-z]{5}','hello123')
print(m[0])#结果将匹配出‘hello’

3.re.findall()
搜索字符串返回所有能匹配的字符串,返回list对象
参数：
pattern、string、flags=0 功能同时
实例：

import re
l = re.findall(r'[a-z]{5}','hello123world')
print(l)#获得列表对象['hello'，‘world’]

4.re.split()
将一个字符串按照正则表达式匹配的结果进行分割,返回list对象
参数：
pattern：同上
string：同上
maxsplit=0：最大分割数,剩余的部分作为最后一个元素,默认全部分割
flags=0：同上
实例：

import re
l = re.split(r'[a-z]{5}','123hello456world789')
print(l)#获得列表对象['123','456','789']

#只分割1次
l = re.split(r'[a-z]{5}','123hello456world789',1)
print(l)#获得列表对象['123', '456world789']

5.re.finditer()
搜索字符串,匹配结果返回为一个迭代对象,迭代元素都是match对象
参数：
pattern、string、flags=0 功能同上
实例：

import re
i = re.finditer(r'[a-z]{5}','hello123world')
for m in i:
	print(m[0])#打印结果为‘hello’,‘world’

6.re.sub()
将正则表达式匹配出来的字符串替换掉,并返回替换后的字符串
参数：
pattern：同上
repl：将要替的字符串
string：同上
count=0：被替换次数，默认全部替换
flags=0：同上
实例：

import re
s = re.sub(r'[a-z]{5}','中国人','123hello456world789')
print(s)#返回结果为‘123中国人456中国人789’

#只替换1次
s = re.sub(r'[a-z]{5}','中国人','123hello456world789',1)
print(s)#返回结果为‘123中国人456world789’

二、面向对象调用

pat = re.compile(r’[a-z]{5}’)
该函数可以将正则表达式的表示编译成正则表达式对象pat
参数：
pattern：同上
flags=0：同上

pat对象就可以直接调用re的6个主要功能函数,这种面向对象调用的好处是经过一次编译可以多次对同一个字符串进行多次匹配或者提取
pat.search(‘hello123world’)
参数：
string：同上
实例：

import re

str1 = '123hello456world789'
str2 = '111hello222kitty333'
pattern = r'[a-z]{5}'
pat = re.compile(pattern)

matc1 = pat.search(str1)
matc2 = pat.search(str2)

list1 = pat.findall(str1)
list2 = pat.findall(str2)

iter1 = pat.finditer(str1)
iter2 = pat.finditer(str2)
...

三、match对象介绍

search()
match()
finditer()
在re库中这三个方法都会返回match对象
match对象的属性实例：

import re

pat = re.compile(r'[a-z]{5}')
match = pat.search('123hello456world789')

print(match.string)#待匹配的文本
#结果：123hello456world789
print(match.re)#匹配时使用的pattern对象,也就是编译后的正则表达式
#结果：re.compile('[a-z]{5}')
print(match.pos)#正则表达式搜索文本的开始位置
#结果：0
print(match.endpos)#正则表达式搜索文本的结束位置
#结果：19

match对象的方法实例：

import re

pat = re.compile(r'[a-z]{5}')
match = pat.search('123hello456world789')

print(match.group())#获得匹配到的字符串
#结果：hello
print(match.start())#匹配到的字符串在文本中的开始位置
#结果：3
print(match.end())#匹配到的字符串在文本中的结束位置
#结果：8
print(match.span())#以元祖类型返回start()和end()
#结果：(3, 8)

四、re库的最小匹配和贪婪匹配

re库默认为贪婪匹配,即匹配最多的值
实例：

import re
#默认为贪婪匹配，匹配最多的值
m = re.search(r'\d+','123456')
print(m[0])
#输出结果为：123456

如果在实际应用中，只需要匹配到‘1’，需要用到操作符‘？’
实例：

import re
#使用操作符'?'使用最小匹配
m = re.search(r'\d+?','123456')
print(m[0])
#输出结果为：1

…

''''
?操作符可以跟在4个元字符的后面,这样就是非贪婪匹配了
*      *?
+      +?
?	   ??
{m,n}  {m,n}?
'''