文章目录
一、为什么要学正则表达式
实际上爬虫一共就四个主要步骤：
- 明确目标（要知道你准备在哪个范围或者网站去搜索）
- 爬（将所有的网站的内容全部爬下来）
- 取（去掉对我们没用处的数据）
- 处理数据（按照我们想要的方式存储和使用）
我们在之前的案例里实际上省略了第 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('正则表达式')
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'>
如果要进行分组，必须使用()来进行分组
可以使用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
拓展：分组的反向引用
注意：反向引用不代表分组，只是前面分组的值的引用
例：
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)) # 报错
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)
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'>
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) # []
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())
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']
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
第二种：使用函数
语法：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
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']
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) # ['你好', '世界']
三、案例----猫眼电影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)
182
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
