re模块
re模块
- 使用re模块时需要先导入re模块
- 参数：
- pattern：正则匹配规则
- string：需要进行匹配的字符串
- flags
一、findall()的用法
-
格式：findall(pattern, string, flags=0)
-
findall()返回值：
- 列表形式
- 所有符合匹配的结果都会写入列表中返回
- 只有一个返回值列表
import re pattern = '\d\w' string = '1e1r1s4w' result = re.findall(pattern, string) print(result) # 结果是：['1e', '1r', '1s', '4w']
二、match()和search()的用法
格式：match/search(pattern, string, flags)
-
search/match()的返回值：
- 只返回符合匹配规则的第一个结果，后边符合的不返回
- 返回值是一个对象类型，并且写着符合匹配结果在字符串中的下标范围
- 如果匹配上返回一个匹配值对象，如果没有匹配上返回为None
- 使用group()从匹配的对象中获取匹配到的字符串片段
import re pattern = '\d\w' string = '1e1r1s4w' result1 = re.match(pattern, string) print(result1) print(result1.group()) result2 = re.search(pattern, string) print(result2.group()) print(result2) # 结果是： # <re.Match object; span=(0, 2), match='1e'> # 1e # 1e # <re.Match object; span=(0, 2), match='1e'> -
search和match用法的区别：
match在匹配上默认在匹配结果前加上^，即必须以匹配规则作为开头，
search匹配没有这个要求，match相当于在search的匹配规则上加上^import re pattern = '\d\w\s' string = '%^2e 2343452322w 345a ' result = re.search(pattern, string) print(result) result1 = re.match(pattern, string) print(result1) # 打印结果： # <re.Match object; span=(2, 5), match='2e '> # None
三、sub()和subn()用法
sub()和subn()都用于替换字符串中的内容
sub()
- 格式：re.sub(pattern, 替换内容, string, count, flags)
- 替换的内容是pattern匹配到的所有结果全部替换成替换内容
- count表示当匹配到多个结果的时候可以替换几次
- 返回值：替换后的字符串内容
subn()
- 格式：subn(pattern, 替换的内容，string,count, flags)
- 返回值：(替换后的字符串，替换的次数)
pattern = '\w\d.{2}'
string = 'w2er 23wew2er1'
str1 = string.replace('ew', 'mm')
print(str1)
# 普通字符串的内容替换
result = re.sub(pattern, 'H', string, 2)
print(result)
result1 = re.subn(pattern, 'H', string, 2)
print(result1)
# subn()返回的结果是替换后的字符串和替换的次数组成的元组
# subn和sub的区别在于subn返回值是一个元组，并且元组中包括替换的次数，sub没有替换次数
'''
# 结果是：
w2er 23wmm2er1
H Hw2er1
('H Hw2er1', 2)
'''
```
###四、split()
split()用于字符串切割
- 格式为：re.split(pattern, string, maxsplit=0, flags=0)
- 返回值：以列表的形式返回切割后剩余的字符串
```python
import re
pattern = '\w\d.{2}'
string = 'w2er 23wew2er1'
result2 = re.split(pattern, string, maxsplit=2)
print(result2)
# 打印结果：['', ' ', 'w2er1']
```
###五、进阶用法:爬虫和自动化运维
####(一)、re.compile()用法(时间上节省)
- 格式：re.compile(pattern)
- re.compile()是把匹配的规则设置成为通用的匹配规则模版，可以多次重复使用
- 再把获得的模版结果用到上边的几个式子中
- 这个模版用于重复使用时来节省时间，但是单次使用时不会节省时间
```python
import re
re_compile = re.compile(pattern)
# re.compile(匹配规则)获取的是通用的匹配规则模版，这个模版用于重复使用时来节省时间，但是单次使用时不会节省时间
print(re_compile)
result = re.search(re_compile, string)
print(result.group())
'''
结果是：
re.compile('\\w\\d.{2}')
w2er
'''
```
####(二)、finditer()的用法(空间上节省)
- 格式为：re.finditer(pattern, string, flags=0)
- 当匹配的结果比较少的时候用findall()，但是当匹配的结果比较大的时候必须用finditer()，可以节省内存
- 通过finditer()返回的结果是一个可迭代对象，通过for循环可以获取每一个匹配的对象，再通过group()获取到每一个匹配的字符
```python
import re
pattern = '\w\d.'
string = 's3ed3de3shoihuiuhj;klnhjghcugiopi[;kbjd3sd2sf4sf5swsdfskghj3sj3sj4dja5s'
result = re.finditer(pattern, string)
print(result)
for i in result:
print(i.group())
'''
<callable_iterator object at 0x105f7afd0>
s3e
d3d
e3s
d3s
d2s
f4s
f5s
j3s
j3s
j4d
a5s
'''
```
> 所有空间效率的都伴随着时间效率的提高
###六、分组优先原则
分组优先：是在正则表达式中通过()来实现分组，当匹配的字符串后显示的不是全部匹配成功的字符串，
而只是匹配括号内匹配上的结果
####(一)、findall()中出现
- 分组优先只会出现自findall()中，不会出现在search和match中
- 取消分组优先：<font color='red'>在正则表达式的括号内最前边加上"?:"即可取消分组优先</font>
```python
import re
pattern = 'www\.(baidu|jinritoutiao)\.com'
# 当正则表达式中使用()进行分组后，通过findall()获取的结果是括号内匹配上的内容，而不是全部匹配上的内容
# 分组优先原则
string = 'www.baidu.com'
result = re.findall(pattern, string)
print(result)
pattern = 'www\.(?:baidu|jinritoutiao)\.com'
# 在括号中第一个位置加上?:可以取消分组优先，显示全部的内容
string = 'www.baidu.com'
result = re.findall(pattern, string)
print(result)
pattern = 'www\.baidu\.com|www\.jinritoutiao\.com'
# 普通的用法
string = 'www.baidu.com'
result = re.findall(pattern, string)
print(result)
'''
结果是：
['baidu']
['www.baidu.com']
['www.baidu.com']
'''
```
####(二)、在split()中的分组优先使用
在split()切割中会把符合匹配的规则的字符切割掉，返回值中不包括这些内容，可以给正则表达式添加()使用分组优先原则
，使得切割的内容也在返回值中显示
```python
pattern = '\d+'
string = 'alex100taibai20peiqi69'
result = re.split(pattern, string)
# 不使用分组优先原则切割掉的内容不会显示
print(result)
pattern = '(\d+)'
# 在正则中通过()使用分组优先的原则，可以在切割的时候把正常情况下切割掉的内容正常显示出来
string = 'alex100taibai20peiqi69'
result = re.split(pattern, string)
print(result)
'''
结果是：
['alex', 'taibai', 'peiqi', '']
['alex', '100', 'taibai', '20', 'peiqi', '69', '']
'''
```
####(三)、在group()中使用分组优先
当查询到结果后通过group()可以显示匹配到的字符，当pattern存在多个group()时，在返回的结果中可以通过group(num)来获取每一个group()匹配到的结果
group()中不写数字获取的是匹配的所有数据，当写1的时候获取的是第一个group匹配的内容，2获取的是第二个group匹配的内容，以此类推。
```python
pattern = '\d(\.\d+)(\.\d+)(\.\d+)(\.\d+)(\.\d+)'
string = '1.2.3.4.5.6.7'
result = re.search(pattern, string)
print(result)
print(result.group())
print(result.group(1))
print(result.group(2))
print(result.group(3))
print(result.group(4))
print(result.group(5))
'''
结果是：
1.2.3.4.5.6
.2
.3
.4
.5
.6
'''
```
####(四)、html标签分组命名匹配
html中标签名是前后对应的，在html中匹配标签内的内容，同时确保前后标签的名字是保持一致的，一共两种方式：
#####(一)、使用分组命名方式
- 格式为：pattern = r'<(?P<name>)\w+>(\w+)</(?P=name)>'
- 注意：前边'<(?P<name>\w+)>'是定义好标签的名字；后边</(?P=name)>是使用前边定义好的名字，第二个尖括号中必须加上'/'。
```python
'''分组命名'''
pattern = r'<(?P<name>\w+)>(\w+)</(?P=name)>'
# 规范的格式为：前：<(?P<name>正则表达式)> 后: </(?P=name)>
string = '<p>这是一个p标签</p>'
result = re.search(pattern, string)
print(result.group())
# 通过分组命名的方式来规范匹配的前后标签名一致
# 结果是：<p>这是一个p标签</p>
```
- 可以给每一个组进行命名，不局限于标签命名，然后把每一个组的命名放到group(name)中打印
```python
pattern = r'<(?P<tag>\w+)>(?P<content>\w+)</(?P=tag)>'
string = r'<a>这是一个超链接</a>'
result = re.search(pattern, string)
print(result)
print(result.group('tag'))
print(result.group('content'))
# 可以为每一个分组进行命名，然后把每一组的名字放到group中打印每一个组的内容
```
#####(二)、使用\1来实现标签前后一致
- 格式：<(\W+)>(\w+)<(/\1)>
- 注意：前边的标签：<(\w+)>， 后边的标签直接使用</\1>来对应
> 与分组命名相比，第二种方式更为简洁，但是这种方式有一个缺点：当匹配的规则非常多的时候，\1很容易使开发者混乱，搞不清楚对应那个开头。
```python
pattern = r'<(\w+)>(\w+)</\1>'
# 在后边对应的标签上写入</\1>即可以保证后边的标签名和前边的一致，但是这种方式当匹配的正则很多的情况下容易忘记
string = '<p>这是一个p标签</p>'
result = re.search(pattern, string)
print(result.group())
# 结果是：
<p>这是一个p标签</p>
```