目录
web请求与requests库
1. web请求
1.1 客户端渲染与服务端渲染
1.2 抓包
1.3 HTTP状态代码
2. requests库
2.1 requests模块的下载
2.2 发送请求头与请求参数
2.3 GET请求与POST请求
GET请求的例子：
POST请求的例子：
3. 案例：爬取豆瓣电影榜
正则表达式与re库
1. 正则表达式
1.1 贪婪匹配
1.2 惰性匹配
2. re库
2.1 compile() - 创建正则对象
2.2 match()与search() - 单个匹配
2.3 findall()与finditer() - 所有匹配
2.4 sub() - 替换
2.5 split() - 分割
捕获组与非捕获组
3. 案例：爬取豆瓣top250电影指定数据
web请求与requests库
1. web请求
web请求是指客户端向服务端发送的请求，以此获得服务端提供的资源，或者与服务端进行交互。其中，客户端是发送请求的一方，通常指浏览器、移动应用等；服务端是响应的一方，指运行在服务器上的web应用程序。
爬虫属于客户端，通过向服务端发送web请求，获取服务端的数据。
下面介绍常见的两种web请求类型，这里暂不做详细介绍：
- http请求：遵循http协议。
- https：http的加密版。
1.1 客户端渲染与服务端渲染
- 客户端渲染（CSR），指在客户端完成界面的渲染：
服务端将基础的HTML骨架和源代码打包发给客户端，客户端经加载源代码后，再进行请求数据和界面渲染。因为服务端发送的并非成熟的HTML文件，爬虫需要额外的开销来加载和执行源代码。
- 服务端渲染（SSR），指在服务端完成界面的渲染：
服务端完成页面的渲染，并将经渲染的HTML文件发送给客户端，浏览器无需经过源文件的加载和执行，便可直接展示界面。由于服务端提供了HTML文件，爬虫可以直接获取完整的HTML文件，而无需等待加载源文件，因此服务端渲染对爬虫更为友好。
1.2 抓包
渲染方式不同，获取URL的方式也略有不同。
基本步骤：打开需要爬取的界面 - F12 - 刷新 - 网络 - 打开第一个数据包
- 服务端
第一个数据包（黑色方框）为数据，因此该网页为服务端渲染。从该数据包预览页中可以看到页面的所有信息。
此数据包的标头，存放着需爬取的URL。
- 客户端渲染
第一个数据包是HTML骨架，没有完整的界面信息。
此时我们需要找到存放数据的包，这个为爬虫需要爬的内容。
应使用该数据包的URL：
1.3 HTTP状态代码
在抓包过程中，我们注意到表头有一行状态代码显示：“200 OK”，表示请求成功、并返回了资源。在平时生活中，也会遇到“404”、“304”等情况。“404”“304”与“200”一样，都属于HTTP的状态代码，用来表示HTTP请求的处理结果。这些状态代码被划分到了不同的类型，具有独特的意义。我们需要熟记每一类状态码的意义。
1xx - 信息性状态码
- 100 Continue：服务器已收到请求的第一部分，正在等待其余部分。
- 101 Switching Protocols：服务器根据客户端的请求切换协议。
2xx - 成功状态码
- 200 OK：请求成功，服务器返回了请求的资源。
- 201 Created：请求成功，服务器创建了新的资源。
- 202 Accepted：请求已接受，但尚未处理完成。
- 204 No Content：请求成功，但服务器没有返回内容。
3xx - 重定向状态码
- 301 Moved Permanently：请求的资源已永久移动到新的URL。
- 302 Found：请求的资源临时移动到新的URL。
- 304 Not Modified：资源未修改，客户端可以使用缓存的版本。
4xx - 客户端错误状态码
- 400 Bad Request：请求格式错误。
- 401 Unauthorized：请求未授权，需要身份验证。
- 403 Forbidden：服务器拒绝访问请求的资源。
- 404 Not Found：请求的资源未找到。
- 405 Method Not Allowed：请求的方法不被允许。
5xx - 服务器错误状态码
- 500 Internal Server Error：服务器内部错误。
- 501 Not Implemented：服务器不支持请求的功能。
- 502 Bad Gateway：服务器作为网关时，从上游服务器收到无效响应。
- 503 Service Unavailable：服务器暂时无法处理请求。
- 504 Gateway Timeout：服务器作为网关时，上游服务器未在规定时间内响应。2.
2. requests库
requests是一个常用的python第三方库，常用于发送HTTP请求。requests库封装了底层的HTTP协议的细节，使得发送和响应HTTP请求变得十分轻松。
2.1 requests模块的下载
这里介绍采用命令行的方式下载：win+R - 打开cmd - 输入命令行
pip install requests如果因为超时导致下载失败，可以考虑延长pip等待时间，通过--default timeout的方式设置超时时间。
pip install requests --default-timeout=120
这样，就下载成功了。
2.2 发送请求头与请求参数
- 请求头的获取
一些网址的爬取要求加上请求头，这样可以让程序看起来更像真人。
- 请求参数
一些URL链接过长，其原因是链接后面接了部分参数。可以通过发送请求参数，减短URL链接。一般情况下，“？”后的数据为参数。
import requests
# 设置请求头
headers = {'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36 Edg/132.0.0.0'}
#设置请求参数
params ={
'q': '陈奕迅'
'qs': 'n'
'form': 'QBRE'
'sp': -1
'lq': 0
'pq': '陈奕迅'
'sc': '13-3'
'sk':''
'cvid': 'D6F23A59983048E485AA76E7A663ED49'
'ghsh': 0
'ghacc': 0
'ghpl':'' }
#若不设置请求参数，url为：
#https://cn.bing.com/search?q=%E9%99%88%E5%A5%95%E8%BF%85&qs=n&form=QBRE&sp=-1&lq=0&pq=%E9%99%88%E5%A5%95%E8%BF%85&sc=13-3&sk=&cvid=D6F23A59983048E485AA76E7A663ED49&ghsh=0&ghacc=0&g
url="https://cn.bing.com/search"2.3 GET请求与POST请求
GET请求和POST请求是HTTP协议中最常用的两种请求方式。
- GET请求：通过URL发送请求，访问页面资源，参数在URL中传递，是一种无副作用的请求方式。
- PORT请求：参数包含在请求体中，用于修改服务器上的数据，是一种有副作用的请求方式。
GET请求的例子：
import requests #导入requests模块
url = 'https://baike.baidu.com/item/陈奕迅/128029' #获取url链接
header={
"User-Agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36 Edg/132.0.0.0"
}
resp = requests.get(url,headers=header) #发送请求并用变量resp接收
#添加user-agent表头，使看起来更像真人访问
print(resp.text)
运行可以看到，网页的编码出现在了运行结果处。这就是个简单的爬虫程序。
我们已经成功向服务端发送请求并获得了响应。接下来则需要将获取到的数据写入HTML文件中：
try:
resp = requests.get(url,headers=header) #发送请求并用变量resp接收
#请求成功，将响应的内容存放至HTML文档中，追加方式为'w'(写入),写入格式为utf-8。
with open('eason.html','w',encoding='utf-8') as file:
file.write(resp.text)
print("请求成功，已将数据存放至HTML文件！")
except Exception as e:
print("请求失败！")运行，将自送生成一个html文件。打开该文件即可浏览我们爬下来的页面。
POST请求的例子：
以百度翻译为例子。当输入信息后，会自动生成几个数据包。
筛选Fetch/XHR文档，找到存放服务端返回内容的数据包，即可得到对应的URL和数据表单。
import requests #导入requests模块
url = 'https://fanyi.baidu.com/sug' #获取url链接
headers={
#模拟浏览器发送请求
"user-agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36 Edg/132.0.0.0"
}
data={
#模拟表单数据，发送关键字apple
"kw":"apple"
}
#发送post请求
resp=requests.post(url,headers=headers,data=data)
#响应是json格式，可以直接解析并打印。
print(resp.json())运行，即可获取返回的数据。
网页上显示的数据如下：
3. 案例：爬取豆瓣电影榜
找到存放豆瓣电影榜的数据包：
URL中，"？"后的数据为参数，可删去，而用负载中的数据表示这些参数
import requests #导入requests模块
url='https://movie.douban.com/j/chart/top_list'
#请求头
headers={'user-agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36 Edg/132.0.0.0'}
#请求参数
params ={
'type': 11,
'interval_id': '100:90',
'action':'',
'start': 0,
'limit': 20
}
# 尝试发送 GET 请求
try:
resp = requests.get(url, headers=headers, params=params)
print(resp.json()) # 尝试解析 JSON 数据
except Exception:
print("请求失败!")
正则表达式与re库
1. 正则表达式
正则表达式是一种表示字符串的基本语法，可以用来匹配字符串。
例如，我们拿“\d”去匹配字符串“123ABC”，可以得到3种匹配结果：“\d”分别匹配1、2、3。
而正则对象“a*.”可以用来匹配“aaaaab”：
“a*”中*可以匹配0次或多次前面元素a，即“a*”可以匹配“aaaaa”；而“.”可以匹配任意字符，即“.”可以匹配“b”。因此正则对象“a*.”可以匹配字符串“aaaaab”。
下面是一些正则表达式的常见用法：
| \w | 匹配单个字母/数字/下划线 |
| \s | 匹配单个空格 |
| \d | 匹配单个数字 |
| \n | 匹配单个换行符 |
| \t | 匹配单个制表符 |
| ^ | 匹配字符串的开始 |
| ＄ | 匹配字符串的结尾 |
| \W | 匹配非数字、字母、下划线 |
| \D | 匹配非数字 |
| \S | 匹配非空白符 |
| a|b | 匹配a或b |
| () | 分组，用于分组匹配或捕获子字符串 |
| [] | 字符集，用于匹配括号内任意单个字符 |
| . | 匹配除换行符以外的任意单个字符 |
| * | 匹配前面元素0次或多次 |
| + | 匹配前面元素1次或多次 |
| ？ | 匹配前面元素0次或1次 |
| {n} | 匹配前面元素n次 |
| {n,} | 匹配前面元素n次或多次 |
| {n,m} | 匹配前面元素n次到m次 |
1.1 贪婪匹配
贪婪匹配是正则表达式中的一种匹配模式，他的思想是：尽可能匹配更长的字符串。如“\d+”就是一种贪婪匹配模式，能够尽可能多的匹配字符串中的数字。在字符串“abc~12345~de_67_”中，对于正则对象“\d+”可以找到两种匹配：“12345”“67”，这两种匹配已是最长。
再如，“.*”也是一种贪婪匹配模式，可以“a.*b”可以理解为：忽略a与b间的内容，找到最长的匹配。
1.2 惰性匹配
惰性匹配是正则表达式中的一种匹配模式，与贪婪匹配相反，他的思想是：尽可能匹配更短的字符串。要想实现惰性匹配，只需在量词后加上？。如“\d+？”就是一种惰性匹配模式，能够尽可能少的匹配字符串中的数字。在字符串“abc~12345~de_67_”中，对于正则对象“\d+？”能找到的匹配是单个数字字符。因此，“\d”就是一种惰性匹配。
再如，“.*？”也是一种惰性匹配模式，可以“a.？*b”可以理解为：忽略a与b间的内容，找到最短的匹配。
2. re库
re是python的标准库之一，用于正则表达式的处理。
2.1 compile() - 创建正则对象
re.compile()：用于创建新的正则对象。
import re
#匹配1个或多个字符
pattern = re.compile(r'\d+')
# 匹配URL链接
url_pattern = re.compile(
r'^(https?)://' # 匹配 http、https 或 ftp
r'([a-zA-Z0-9.-]+)' # 域名
r'(:\d+)?' # 端口号
r'(/[^?\s]*)?' # 路径
r'(\?[^#\s]*)?' # 查询参数
r'(#\S*)?$' # 锚点
)2.2 match()与search() - 单个匹配
match()与search()均用于查找字符串的第一个匹配，区别在于：match是从字符串最开始处匹配，一旦这个字符串的最开始部分与正则表达式不匹配，无论后面是否有子字符串与之匹配，都将匹配失败；而search()只需要找到与正则表达式匹配的子字符串，无论这个子字符串是否在字符串开头。
- re.match(pattern,text)：判断字符首部是否与pattern匹配。
import re
pattern = re.compile(r'\d+')
text=['123abc456','abc456def']
match=[re.match(pattern,text[0]),re.match(pattern,text[1])]
for i in range(2):
if match[i]:
print(f"text[{i}]:匹配成功！{match[i].group()}")
else:
print(f"text[{i}]:匹配失败！")
#text[0]:匹配成功！123
#text[1]:匹配失败！- pattern.search(text)：用于判断字符串text中是否有与正则表达式匹配的子字符串：若有，则返回第一个匹配的字符串；若没有，返回None。
import re
pattern = re.compile(r'\d+')
test = "abc123de456"
match=pattern.search(test)
if match:
print(match.group()) #123
else:
print("匹配失败！")2.3 findall()与finditer() - 所有匹配
findall()与finditer()都用于查找所有的匹配，但他们的返回值有所不同：findall()将返回与正则表达式匹配的子字符串列表，而finditer()则返回一个迭代器，每次迭代返回一个Match对象。关于Match对象的用法：
match.group()：返回匹配的字符串。
match.start()：返回匹配的起始位置。
match.end()：返回匹配的结束位置。
match.span()：返回一个元组 (start, end)，表示匹配的起始和结束位置。
- pattern.findall(text)：用于查找所有匹配，并返回一个列表。
import re
pattern = re.compile(r'\d+')
test = "abc123de456"
match=pattern.findall(test)
if match:
print(match) #['123', '456']
else:
print("匹配失败！")- pattern.finditer(pattern,text)：用于查找所有匹配，并返回一个迭代器。
import re
text="hello,python!"
pattern = re.compile(r'\w+')
matches=re.finditer(pattern,text)
# 使用迭代器逐个处理匹配结果
for match in matches:
print(f"Match found: {match.group()} at position {match.start()}-{match.end()}")
#Match found: hello at position 0-5
#Match found: python at position 6-122.4 sub() - 替换
re.sub(pattern,str,text)：用str替换text中匹配正则对象pattern的内容。
import re
pattern = re.compile(r'\d+')
test = "abc123de456"
res=re.sub(pattern,"x",test)
print(res) #abcxdex2.5 split() - 分割
re.split(pattern,text)：依照正则对象pattern分割text，与pattern匹配的字符串作为分割边界。
import re
pattern = re.compile(r'\d+')
test = "abc123de456"
result= re.split(pattern,test)
print(result) #['abc', 'de', '']
捕获组与非捕获组
- 捕获组用(…)表示，兼具分组和捕获的作用。经匹配过的字符串依照正则表达式进行分组，通过.group(idx)的方式可以捕获不同分组。分组的下标从1开始。
如，格式为YYYY-MM-DD的日期字符串，我们希望对其进行分组，从而能分别捕获年、月、日。那么对该字符串的分组为：(YYYY)、(MM)、(DD)，对应的正则表达式为：(\d{4})-(\d{2})-(\d{2})
import re
pattern = re.compile(r'(\d{4})-(\d{2})-(\d{2})') #YYYY-MM-DD
text='2025-01-01'
match=re.match(pattern,text)
if match:
#捕获不同分组
yyyy=match.group(1)
mm=match.group(2)
dd=match.group(3)
print(f"Year:{yyyy},Month:{mm},Date:{dd}") #Year:2025,Month:01,Date:01
else:
print("匹配失败！")在捕获组中，可以添加“?<name>”来命名捕获组，如：(?<name>pattern)
- 非捕获组用(?:…)表示，仅具有分组功能而无法对分组进行捕获。这里不再展示。
3. 案例：爬取豆瓣top250电影指定数据
要求爬取数据：电影名称、上映年份、国家、评分，并把数据存入csv文件中。
如何用正则表达式表达爬取所需的格式？
首先，需要找到数据存放的位置。
选择图上这个图标，点击“肖申克的救赎”，可以快速定位数据所在位置。找到数据所在位置后，我们找到它的最外层文件：可以看到，当光标停放在<li>这一行时，《肖申克的救赎》这部电影的所有数据都囊括在阴影处。往下可以找到需要爬去的数据。因此我们的正则表达式可以从"<li>"开始，接下来只需要表达式能特异性地识别到数据存放的位置。
依据上图，最后的正则表达式为：
(正则表达式不唯一)
obj=re.compile(r'<li>.*?<div class="item">.*?' #最外层及第二层文件
r'<span class="title">(?P<name>.*?)</span>.*?' #电影名称
r'<br>(?P<year>.*?) / (?P<country>.*?) /.*?' #年份、国家
r'<span class="rating_num" property="v:average">(?P<score>.*?)</span>', #评分
re.S)<li>.*?<div class="item">
“ .*? ”是一种惰性匹配*匹配任意字符，.*? 意味着要尽量少的匹配字符，直到出现下一次匹配。这里可以理解为：忽略<li>与<div class="item">之间的内容。其他位置 “ .*? ”同理。
<span class="title">
精确匹配HTML的标签，这是电影名的开始处。其他处同理。
(?P<name>.*?)
这是一个捕获组，采用了 (?P<name>…) 用于捕获电影名称，并使其可以被name捕获。其他处同理。
</span>
精确匹配HTML的标签，这是电影名的结束位置。其他处同理。
/
HTML中相邻两项的分隔。
re.S
编译标志，也被称为DOTALL模式，使“ . ”可以匹配包括换行符在内的任意字符。
最后的程序：
import requests
import re
import csv
url = "https://movie.douban.com/top250" #URL链接
headers = { #请求头
'user-agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36 Edg/132.0.0.0'
}
try:
#发送请求
resp=requests.get(url,headers=headers)
#状态判断
if resp.status_code!=200:
raise Exception(f"状态码错误：{resp.status_code}")
#创建正则表达式
obj=re.compile(r'<li>.*?<div class="item">.*?'
r'<span class="title">(?P<name>.*?)</span>.*?'
r'<br>(?P<year>.*?) / (?P<country>.*?) /.*?'
r'<span class="rating_num" property="v:average">(?P<score>.*?)</span>',re.S)
result=obj.finditer(resp.text)
# 写入 CSV 文件
with open('data.csv', mode='w', newline='', encoding='utf-8') as file:
csvwriter = csv.writer(file)
csvwriter.writerow(['Name', 'Year', 'Country', 'Score']) # 写入表头
for match in result:
dic = match.groupdict()
csvwriter.writerow([dic['name'].strip(), dic['year'].strip(), dic['country'].strip(), dic['score'].strip()])
except Exception as e:
print(f"请求失败：{e}")
finally:
print("程序结束！")
