花生_TL007

这个屌丝很懒，什么也没留下！

热门标签

Python（爬虫篇）--- 正则表达式_python 请求标头转成正则

作者：花生_TL007 | 2024-05-05 19:43:00

踩

python 请求标头转成正则

文章目录

一、为什么要学正则表达式
二、基础正则表达式语法
三、案例----猫眼电影TOP100榜单信息爬取

一、为什么要学正则表达式

实际上爬虫一共就四个主要步骤：

明确目标（要知道你准备在哪个范围或者网站去搜索）
爬（将所有的网站的内容全部爬下来）
取（去掉对我们没用处的数据）
处理数据（按照我们想要的方式存储和使用）

我们在之前的案例里实际上省略了第 3 步，也就是"取"的步骤。因为我们 down 下了的数据是全部的网页，这些数据很庞大并且很混乱，大部分的东西使我们不关心的，因此我们需要将之按我们的需要过滤和匹配出来。那么对于文本的过滤或者规则的匹配，最强大的就是正则表达式，是 Python 爬虫世界里必不可少的神兵利器。

二、基础正则表达式语法

正则表达式，又称规则表达式，通常被用来检索、替换那些符合某个模式(规则)的文本。
正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。
给定一个正则表达式和另一个字符串，我们可以达到如下的目的：

给定的字符串是否符合正则表达式的过滤逻辑(“匹配”)；
通过正则表达式，从文本字符串中获取我们想要的特定部分(“过滤”)。

（一）元字符

常见元字符：前面提到的元字符\b 表示匹配单词的开始和结束。引出其他元字符

匹配边界

元字符	含义
^	匹配行首
$	匹配行尾

重复次数

元字符	含义
?	重复匹配 0 次或 1 次
*	重复匹配 0 次或更多次
+	重复匹配 1 次或更多次 1
{n，}	重复 n 次或更多次
{n，m}	重复 n~m 次
{n}	重复 n 次

各种字符的表示

元字符	含义
[a-z]	任意 a-z 的字母
[abc]	a/b/c 中的任意一个字符
[^123abc]	匹配除了 123 abc 这几个字符以外的任意字符
.	匹配除换行符以外的任意一个字符
\b	匹配单词的开始和结束
\B	匹配不是单词开始和结束的位置
\d	匹配数字
\D	匹配任意非数字的字符
\w	匹配字母，数字，下划线
\W	匹配任意不是字母，数字，下划线的字符
\s	匹配任意空白，包括空格，制表符(Tab)，换行符
\S	匹配任意不是空白符的字符

其他

元字符	含义
[^a]	匹配除了a 以外的任意字符
123丨abc	匹配 123 或者abc

（二）python 中正则表达式模块——re

在 Python 中，我们可以使用内置的 re 模块来使用正则表达式。有一点需要特别注意的是，正则表达式使用对特殊字符进行转义，所以如果我们要使用原始字符串，只需加一个r 前缀。

re 模块的一般使用步骤如下：
第一步：使用 compile()函数将正则表达式的字符串形式编译为一个 Pattern 对象。
第二步：通过 Pattern 对象提供的一系列方法对文本进行匹配查找，获得匹配结果，一个 Match 对象。
第三步：最后使用 Match 对象提供的属性和方法获得信息，根据需要进行其他的操作。

compile 函数
compile 函数用于编译正则表达式，生成一个 Pattern 对象，它的一般使用形式如下：

import re
pattern = re.compile('正则表达式')
1
2

Pattern 对象的一些常用方法主要有：

方法	描述
match	从起始位置开始查找，一次匹配
search	从任何位置开始查找，一次匹配
findall	全部匹配，返回列表
finditer	全部匹配，返回迭代器
split	分割字符串，返回列表
sub	替换

1. match方法

语法：match(‘待匹配字符串’[,起始索引,结束索引])

说明：
从头开始匹配，如果开头的字符不符合匹配规则，直接返回None
如果匹配成功，返回的是match对象
如果没有匹配成功，返回None

例：

import re

str = '123hello456world'

match_pattern = re.compile(r'\d+')
result = match_pattern.match(str)
result = match_pattern.match(str,8,12)
print(result)  # <_sre.SRE_Match object; span=(0, 3), match='123'>
1
2
3
4
5
6
7
8

如果要进行分组，必须使用()来进行分组
可以使用group(n)来获取对应组的内容，n是从1开始
可以使用group()获取匹配成功的内容

例：

import re

group_str = '123hello123world'
match_pattern = re.compile(r'\d+')
result = match_pattern.match(group_str)
print(result.group())  # 123

# group_str = '1h2e3lloworld'
# pattern = re.compile(r'(\d)h(\d)e(\d)')
# result = pattern.match(group_str)
# print(result.group())  # 1h2e3
# print(result.group(1))  # 1
# print(result.group(2))  # 2
# print(result.group(3))  # 3
# print(result.group(0))  # 1h2e3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

拓展：分组的反向引用
注意：反向引用不代表分组，只是前面分组的值的引用
例：

import re

html = '<html><h1>helloworld</h1></html>'
pattern = re.compile(r'<(html)><(h1)>(.*)</\2></\1>')
result = pattern.match(html)
print(result.group())
print(result.group(1))
print(result.group(2))
print(result.group(3))
print(result.group(4))  # 报错
1
2
3
4
5
6
7
8
9
10

span()方法作用：查看匹配成功的子串的索引范围，支持分组查看

例：

span_str = '1h2e3lloworld'
pattern = re.compile(r'(\d)h(\d)e(\d)')
result = pattern.match(span_str)
print(result.span())  # (0, 5)
print(result.span(2))  # (2, 3)
1
2
3
4
5

2. search方法

语法：search(‘待匹配的字符串’[,起始索引,结束索引])

说明：
如果匹配成功，返回match对象
如果开头不符合匹配规则，继续向下匹配
直到整个字符串中都没有找到符合规则的时候，返回None

例：

import re

search_str = '1h2e3lloworld'
search_str = 'h2e3lloworld'
pattern = re.compile(r'\d')
result = pattern.search(search_str)
print(result) #  <_sre.SRE_Match object; span=(0, 1), match='1'>
1
2
3
4
5
6
7

3. findall方法

语法：findall(‘待匹配的字符串’[,起始索引,结束索引])

说明：
全局匹配，和match、search放均不同
所有符合条件的子串，全部返回，返回的是一个列表，列表中的元素是匹配成功的内容
列表中元素不是match对象
如果没有符合条件的子串，返回的是一个空列表

例：

import re

findall_str = '1h2e3lloworld'
findall_str2 = 'helloworld'
pattern = re.compile('\d')
result = pattern.findall(findall_str)
result2 = pattern.findall(findall_str2)
print(result)  # ['1', '2', '3']
print(result2)  # []
1
2
3
4
5
6
7
8
9

4. finditer方法

说明：
全局匹配和findall()相似
如果匹配成功，返回的是可迭代的对象，可迭代对象中，包含所有匹配成功的match对象

例：

finditer_str = '1h2e3lloworld'
pattern = re.compile('\d')
result = pattern.finditer(finditer_str)
# print(result)  # <callable_iterator object at 0x000000000288E710>
for i in result:
    print(i)  # match对象
    print(i.group())
1
2
3
4
5
6
7

5. split方法

语法：split(‘待切割的字符串’[,maxsplit])

说明：
切割方法,返回列表
可以使用maxsplit指定最大的切割次数

例：

import re

split_str = 'a,b,c;d e'
pattern = re.compile(r'[,; ]')
result = pattern.split(split_str)
print(result)  # ['a', 'b', 'c', 'd', 'e']

result = pattern.split(split_str,maxsplit=2)
print(result)  # ['a', 'b', 'c;d e']
1
2
3
4
5
6
7
8
9

6. sub方法

语法：sub(‘新的字符串’,‘旧的字符串’)

说明：替换方法

第一种：直接替换
例：

import re

sub_str = 'hello 123,hello 456'
pattern = re.compile(r'(\w+) (\d+)')
result = pattern.sub('hi world',sub_str)
print(result)  # hi world,hi world
1
2
3
4
5
6

第二种：使用函数
语法：sub(‘函数名’,‘旧的字符串’)
说明：
对函数的要求：

函数必须要有形式参数,参数作用：代表匹配到的子串
函数必须要有返回值，返回值必须是字符串类型，返回值作用：代表新的字符串

例：

import re

sub_str = 'hello 123,hello 456'
pattern = re.compile(r'(\w+) (\d+)')
def func(m):
    print(m)
    return 'hi ' + m.group(2)
result = pattern.sub(func,sub_str)
print(result)  # hi 123,hi 456
1
2
3
4
5
6
7
8
9

7. 贪婪模式和非贪婪模式

贪婪模式：尽可能多的获取
非贪婪模式：尽可能少的获取

例：

import re

html = '<div>hello</div><div>world</div><div>python</div><div>java</div>'
# 贪婪模式：
pattern = re.compile(r'<div>(.*)</div>')
result = pattern.findall(html)
print(result) # ['hello</div><div>world</div><div>python</div><div>java']

# 非贪婪模式：
pattern = re.compile(r'<div>(.*?)</div>')
result = pattern.findall(html)
print(result)  # ['hello', 'world', 'python', 'java']
1
2
3
4
5
6
7
8
9
10
11
12

8. 爬虫的万能表达式

.*?(非贪婪模式) 需要配合边界值使用

re.compile(r’<边界>(.*?)</边界>’,re.S) 无敌表达式
re.S：代表能够匹配到换行
re.I：代表忽略大小写

9. 匹配中文

中文编码:[\u4e00-\u9fa5]

例：

import re

cn_str = 'hello 你好 world 世界'
pattern = re.compile(r'[\u4e00-\u9fa5]+')
res = pattern.findall(cn_str)
print(res)  # ['你好', '世界']
1
2
3
4
5
6

三、案例----猫眼电影TOP100榜单信息爬取

需求：获取猫眼电影TOP100榜下，所有电影的排名、电影名、主演、上映时间以及评分

完整代码：

# 1. 导入requests模块
import requests,re

# 定义请求头
headers = {
    'User-Agent': '略',
    'Cookie': '略'
}

# 分页：找出URL规律
# 第二页：https://maoyan.com/board/4?offset=10
# 第三页：https://maoyan.com/board/4?offset=20
# 第n页：https://maoyan.com/board/4?offset=(n-1)*10

# 定义参数字典
params = {}

# 制定获取dd之间的内容
dd_pattern = re.compile(r'<dd>(.*?)</dd>',re.S)
# 制定获取排名规则
rank_pattern = re.compile(r'<i class="board-index board-index-\d+">(.*?)</i>', re.S)

# 制定获取电影名的规则
movie_pattern = re.compile(r'<p class="name"><a.*?>(.*?)</a></p>', re.S)

# 制定获取主演的规则
actor_pattern = re.compile(r'<p class="star">(.*?)</p>', re.S)

# 制定获取上映时间的规则
release_time_pattern = re.compile(r'<p class="releasetime">(.*?)</p>', re.S)

# 制定获取评分的规则
score_pattern = re.compile(r'<p class="score"><i class="integer">(.*?)</i>'
                           r'<i class="fraction">(.*?)</i></p>', re.S)
for page in range(1,11):
    params['offset'] = (page-1)*10

    # 2. 发起请求
    response = requests.get(url='https://maoyan.com/board/4',headers=headers,params=params)

    # 提取数据
    dd_list = dd_pattern.findall(response.text)

    # 循环获取电影信息
    for dd in dd_list:
        # print(dd)
        # 获取排名
        rank = rank_pattern.findall(dd)[0]
        # 获取电影名
        movie = movie_pattern.findall(dd)[0]
        # 获取主演
        actor = actor_pattern.findall(dd)[0].strip()
        # 获取上映时间
        release_time = release_time_pattern.findall(dd)[0]
        # 获取评分
        score = score_pattern.findall(dd)[0]
        score_full = score[0]+score[1]
        print(rank,movie,actor,release_time,score_full)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/540531