爬虫基础（4）发送请求之requests库的使用

一. 什么是Requests库

Requests 库是⽤Python语⾔编写，基于urllib，采⽤Apache2 Licensed开源协议的 HTTP 库。它⽐ urllib 更加⽅便，可以节约我们⼤量的⼯作，完全满⾜HTTP测试需求。

可以说Requests最大的特性就是其风格的简单直接优雅。无论是请求方法，还是响应结果的处理，还有cookies，url参数，post提交数据，都体现出了这种风格。

Requests目前基本完全满足web请求的所有需求，以下是Requests的特性：

• Keep-Alive & 连接池
• 国际化域名和 URL
• 带持久 Cookie 的会话
• 浏览器式的 SSL 认证
• 自动内容解码
• 基本/摘要式的身份认证
• 优雅的 key/value Cookie
• 自动解压
• Unicode 响应体
• HTTP(S) 代理支持
• 文件分块上传
• 流下载
• 连接超时
• 分块请求
• 支持 .netrc

Request库的官方文档：https://requests.readthedocs.io/zh_CN/latest/

二. 安装Requests库

requests 库能通过 pip 来安装：

$ python -m pip install requests
或者
$pip install requests

你也可以在github上下载最新的源码，解压之后进入目录进行安装：

$git clone git:https://github.com/psf/requests.git

$python setup.py install

三. Requests库的基本应用

（一）发送请求

1. 实例引入

urllib 库中的 urlopen() 方法实际上是以GET方式请求网页，而 requests 中相应的方法就是 get()方法。下面通过实例来看一下：

import requests

response = requests.get('http://www.baidu.com/')
print(type(response))
print(type(response.text))
print(type(response.cookies))

# 运行结果：
<class 'requests.models.Response'>
<class 'str'>
<class 'requests.cookies.RequestsCookieJar'>

这里我们调用 get() 方法实现与 urlopen() 相同的操作，得到一个 response 对象，然后分别输出 Response 的类型、响应体的类型以及Cookies的类型。

通过运行结果可以发现，它的返回类型是 requests.models.Response ，响应体的类型是字符串 str，Cookies 的类型是 RequestsCookieJar。

当然，除了get()方法，还有post()、put()、delete()等请求方法：

r = requests.post('http://httpbin.org/post’) 
r = requests.put(’http://httpbin.org/put’) 
r = requests.delete('http://httpbin.org/delete') 
r = requests.head (’http://httpbin.org/get’) 
r = requests.options(’http://httpbin.org/get')

2. GET请求

HTT 中最常见的请求之一就是 GET 请求，下面我们详细了解一下利用 requests 构建 GET 请求的方法。

在构建GET请求之前，我们要了解get()方法的调用格式：

requests.get(url, params=None, **kwargs):

该方法有三个参数：

• url：必选参数，该参数指定了发送请求的目标URL
• params：可选参数，它是发送请求时传递给Request对象的参数，其数据类型可以是字典、列表、元组或者字节型数据
• **kwargs：可选参数

（1）最基本的GET请求

首先，构建一个最简单的 GET 请求，请求的链接为 /httpbin.org/ ，该 网会判断如果客户端发起的是 GET 请求的话，它返回相应的请求信息：

import requests
 
response = requests.get('http://httpbin.org/get')
print(response.text)

# 运行结果：
{
    
    
  "args": {
    
    }, 
  "headers": {
    
    
    "Accept": "*/*", 
    "Accept-Encoding": "gzip, deflate", 
    "Host": "httpbin.org", 
    "User-Agent": "python-requests/2.24.0", 
    "X-Amzn-Trace-Id": "Root=1-5f60973e-1787830a4f06ee8a3dec1d86"
  }, 
  "origin": "221.207.18.109", 
  "url": "http://httpbin.org/get"
}

可以发现，我们成功发起了 GET 请求，返回结果中包含请求头、URL 和 IP 等信息。

（2）带参数的GET请求

对于 GET 请求，如果要附加额外的信息，一般怎样添加呢？比如现在想添加两个参数，其中 name=germey，age=22：

import requests

data = {
    
    
    'name':'germey',
    'age':22
}
response = requests.get("http://httpbin.org/get", params=data)
print(response.text)

# 运行结果：
{
    
    
  "args": {
    
    
    "age": "22", 
    "name": "germey"
  }, 
  "headers": {
    
    
    "Accept": "*/*", 
    "Accept-Encoding": "gzip, deflate", 
    "Host": "httpbin.org", 
    "User-Agent": "python-requests/2.24.0", 
    "X-Amzn-Trace-Id": "Root=1-5f6098ac-247285d09016a318f68ecbb0"
  }, 
  "origin": "221.207.18.109", 
  "url": "http://httpbin.org/get?name=germey&age=22"
}

通过运行结果可以判断，请求的链接自动被构造成了：http://httpbin.org/get?name=germey&age=22。当然，我们也可以直接将参数放到请求URL中发送请求：

response = requests.get("http://httpbin.org/get?name=germey&age=22")

（3）解析JSON

响应体的类型实际上是 str 类型，但是它很特殊，是 JSON 格式的数据。所以，如果想直接解析返回结果，得到一个字典格式的话，可以直接调用 json() 方法，示例如下：

import requests
import json
 
response = requests.get("http://httpbin.org/get")
print(type(response.text))
print(response.json())
print(type(response.json()))

# 运行结果：
<class 'str'>
{
    
    'args': {
    
    }, 'headers': {
    
    'Accept': '*/*', 'Accept-Encoding': 'gzip, deflate', 'Host': 'httpbin.org', 'User-Agent': 'python-requests/2.24.0', 'X-Amzn-Trace-Id': 'Root=1-5f609a2f-86ba9d38d21e0034d01fcebc'}, 'origin': '221.207.18.109', 'url': 'http://httpbin.org/get'}
<class 'dict'>

可以发现，调用 json() 方法，就可以将返回结果是 JSON 格式的字符串转化为字典。或者是用json.loads()也可以将 JSON 格式的返回结果转换为字典格式：

import requests
import json
 
response = requests.get("http://httpbin.org/get")
res_dict = json.loads(response.text)
print(type(res_dict))
print(res_dict)

# 运行结果：
<class 'dict'>
{
    
    'args': {
    
    }, 'headers': {
    
    'Accept': '*/*', 'Accept-Encoding': 'gzip, deflate', 'Host': 'httpbin.org', 'User-Agent': 'python-requests/2.24.0', 'X-Amzn-Trace-Id': 'Root=1-5f609cce-0bcd2d0ee79f7a4f3b9f4a9c'}, 'origin': '221.207.18.109', 'url': 'http://httpbin.org/get'}

（4）抓取二进制数据

如果想抓取图片、音频、 视频等文件，应该怎么办呢？图片、音频、视频这些文件本质上都是由二进制码组成的，由于有特定的保存格式和对应的解析方式， 我们才可以看到这些形形色色的多媒体。所以，想要抓取它们，就要拿到它们的二进制码。下面以 GitHub 站点图标为例来看一下：

import requests
 
response = requests.get("https://github.com/favicon.ico")
print(type(response.text), type(response.content))
print(response.text)
print(response.content)

# 运行结果：
<class 'str'> <class 'bytes'>
# response.text的运行内容略
b'\x00\x00\x01\x00\x02\x00\x10\x10\x00\x00\x01\x00......''

从运行结果我们可以发现，text的内容在打印时发生了乱码，而content的内容以二进制码打印显示。

然后，我们将刚刚爬取的图片保存到本地：

import requests
 
response = requests.get("https://github.com/favicon.ico")
with open('favicon.ico', 'wb') as f:
    f.write(response6.content)

同样地，音频和视频文件也可以用这种方法获取。

（5）添加headers

与urllib.request 一样，我们也可以通过 headers 参数来传递请求头。例如，下面以爬取知乎的“发现”页面为例：

如果发送请求时不传递headers，就不能正常请求：

import requests

response7 = requests.get("https://www.zhihu.com/explore")
print(response7.text)

# 运行结果：
<html>
<head><title>400 Bad Request</title></head>
<body bgcolor="white">
<center><h1>400 Bad Request</h1></center>
<hr><center>openresty</center>
</body>
</html>

但如果加上了 headers 并加上 User-Agent 信息，就能正常发送请求了：

import requests

headers = {
    
    
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.102 Safari/537.36'
}
response7 = requests.get("https://www.zhihu.com/explore", headers=headers)
print(response7.text)

# 该运行结果不做展示

当然，我们可以在 headers 这个参数中任意添加其他的字段信息。

3. POST请求

前面我们了解了最基本的 GET 请求，另外一种比较常见的请求方式是 POST 。调用post()方法的格式是：

requests.post(url, data=None, json=None, **kwargs)

该方法有四个参数：

• url：必选参数，该参数指定了发送请求的目标URL
• data：可选参数，它是发送请求时传递给Request对象的参数，其数据类型可以是字典、列表、元组、字节型或者文件
• json：可选参数，它是发送请求时传递的 JSON 格式数据
• **kwargs：可选参数

使用 requests 实现 POST 请求同样非常简单，示例如下：

import requests

data = {
    
    
    'name': 'germey',
    'age': '22'
}
response = requests.post("http://httpbin.org/post", data=data)
print(response.text)

# 运行结果：
{
    
    
  "args": {
    
    }, 
  "data": "", 
  "files": {
    
    }, 
  "form": {
    
    
    "age": "22", 
    "name": "germey"
  }, 
  "headers": {
    
    
    "Accept": "*/*", 
    "Accept-Encoding": "gzip, deflate", 
    "Content-Length": "18", 
    "Content-Type": "application/x-www-form-urlencoded", 
    "Host": "httpbin.org", 
    "User-Agent": "python-requests/2.24.0", 
    "X-Amzn-Trace-Id": "Root=1-5f60c46d-19fd8bc7bf3e82cd3702dcbd"
  }, 
  "json": null, 
  "origin": "111.44.130.165", 
  "url": "http://httpbin.org/post"
}

可以发现，我们成功获得了返回结果，其中 form 部分就是提交的数据，这就证明 POST 请求成功发送了。

（二）接收响应

发送请求后，得到的自然就是响应。下面我们了解一下返回的响应信息和响应状态码。

1. 响应信息

发送请求之后，返回的 Response 对象有很多属性和方法，我们可以从中获取很多有用的信息，常用的一些属性和方法如下表所示：

序号	属性/方法	类型	意义
1	content	bytes	返回的字节类型的响应内容
2	cookies	requests.cookies.RequestsCookieJar	服务器返回的Cookies
3	headers	requests.structures.CaseInsensitiveDict	返回的响应头
4	history	list	请求历史
5	json()	method	将JSON格式的响应体内容转换为字典格式
6	reason	str	返回响应的HTTP状态的文本原因
7	status_code	int	返回响应的HTTP状态的编码
8	text	str	返回的unicode类型的响应内容
9	url	str	返回响应的最终URL

2. 响应状态码

响应状态码常用来判断请求是否成功，而requests还提供了一个内置的状态码查询对象 request.codes ，如下示例：

import requests

response = requests.get('http://www.jianshu.com')
print("Request Fails!") if not response.status_code == requests.codes.ok else print("Request Successfully!")

# 运行结果：
Request Fails!

这里通过比较返回码和内置的成功返回码，来保证请求得到了正常响应，输出成功请求的消息，否则程序终止，这里我们用 requests.codes.ok 得到的是成功的状态码：200。

requests内置的状态码跟响应状态码一样，包括五类：

• 信息性状态码

  100: ('continue',),
  101: ('switching_protocols',),
  102: ('processing',),
  103: ('checkpoint',),
  122: ('uri_too_long', 'request_uri_too_long'),
  

• 成功状态码

  200: ('ok', 'okay', 'all_ok', 'all_okay', 'all_good', '\\o/', '✓'),
  201: ('created',),
  202: ('accepted',),
  203: ('non_authoritative_info', 'non_authoritative_information'),
  204: ('no_content',),
  205: ('reset_content', 'reset'),
  206: ('partial_content', 'partial'),
  207: ('multi_status', 'multiple_status', 'multi_stati', 'multiple_stati'),
  208: ('already_reported',),
  226: ('im_used',),
  

• 重定向状态码

  301: ('moved_permanently', 'moved', '\\o-'),
  302: ('found',),
  303: ('see_other', 'other'),
  304: ('not_modified',),
  305: ('use_proxy',),
  306: ('switch_proxy',),
  307: ('temporary_redirect', 'temporary_moved', 'temporary'),
  308: ('permanent_redirect', 'resume_incomplete', 'resume',),
  

• 客户端错误状态码

  400: ('bad_request', 'bad'),
  401: ('unauthorized',),
  402: ('payment_required', 'payment'),
  403: ('forbidden',),
  404: ('not_found', '-o-'),
  405: ('method_not_allowed', 'not_allowed'),
  406: ('not_acceptable',),
  407: ('proxy_authentication_required', 'proxy_auth', 'proxy_authentication'),
  408: ('request_timeout', 'timeout'),
  409: ('conflict',),
  410: ('gone',),
  411: ('length_required',),
  412: ('precondition_failed', 'precondition'),
  413: ('request_entity_too_large',),
  414: ('request_uri_too_large',),
  415: ('unsupported_media_type', 'unsupported_media', 'media_type'),
  416: ('requested_range_not_satisfiable', 'requested_range', 'range_not_satisfiable'),
  417: ('expectation_failed',),
  418: ('im_a_teapot', 'teapot', 'i_am_a_teapot'),
  421: ('misdirected_request',),
  422: ('unprocessable_entity', 'unprocessable'),
  423: ('locked',),
  424: ('failed_dependency', 'dependency'),
  425: ('unordered_collection', 'unordered'),
  426: ('upgrade_required', 'upgrade'),
  428: ('precondition_required', 'precondition'),
  429: ('too_many_requests', 'too_many'),
  431: ('header_fields_too_large', 'fields_too_large'),
  444: ('no_response', 'none'),
  449: ('retry_with', 'retry'),
  450: ('blocked_by_windows_parental_controls', 'parental_controls'),
  451: ('unavailable_for_legal_reasons', 'legal_reasons'),
  499: ('client_closed_request',),
  

• 服务端错误状态码

  500: ('internal_server_error', 'server_error', '/o\\', '✗'),
  501: ('not_implemented',),
  502: ('bad_gateway',),
  503: ('service_unavailable', 'unavailable'),
  504: ('gateway_timeout',),
  505: ('http_version_not_supported', 'http_version'),
  506: ('variant_also_negotiates',),
  507: ('insufficient_storage',),
  509: ('bandwidth_limit_exceeded', 'bandwidth'),
  510: ('not_extended',),
  511: ('network_authentication_required', 'network_auth', 'network_authentication'),
  

四. Requests库的高级应用

下面我们再来了解一下 requests 的一些高级用法，如文件上传、 Cookies设置、代理设置等。

（一）文件上传

我们知道 requests 可以模拟提交一些数据。假如有的网站需要上传文件，我们也可以用它来实现，这非常简单，示例如下：

import requests

files = {
    
    'file': open('favicon.ico', 'rb')}
r = requests.post("http://httpbin.org/post", files=files)
print(r.text)

运行结果如下：

{
    
    
  "args": {
    
    }, 
  "data": "", 
  "files": {
    
    
    "file": "data:application/octet-stream;base64,AAABAAIAEBAAAAEAIAAoBQAA...AAAAAAAA="
  }, 
  "form": {
    
    }, 
  "headers": {
    
    
    "Accept": "*/*", 
    "Accept-Encoding": "gzip, deflate", 
    "Content-Length": "6665", 
    "Content-Type": "multipart/form-data; boundary=0d54744bcb75b88d0d8a38207e997e3d", 
    "Host": "httpbin.org", 
    "User-Agent": "python-requests/2.24.0", 
    "X-Amzn-Trace-Id": "Root=1-60573552-72447c4905e3cb177005dea8"
  }, 
  "json": null, 
  "origin": "111.44.174.173", 
  "url": "http://httpbin.org/post"
}

以上省略部分内容，这个网站会返回响应，里面包含 files 这个字段，而 form 字段是空的，这证明文件上传部分会单独有一个 files 字段来标识。

（二）Cookies

前面我们使用 urllib 处理过 Cookies，写法比较复杂，而有了 requests，获取和设置 Cookies 只需一步即可完成。

1. 获取 Cookies

我们先用一个实例看一下获取 Cookies 的过程：

r = requests.get("https://www.baidu.com")
print(r.cookies)
for key, value in r.cookies.items():
    print(key + '=' + value)

# 运行结果：
<RequestsCookieJar[<Cookie BDORZ=27315 for .baidu.com/>]>
BDORZ=27315

这里我们首先调用 cookies 属性即可成功得到 Cookies，可以发现它是 RequestCookieJar 类型。然后用 items() 方法将其转化为元组组成的列表，遍历输出每一个 Cookie 的名称和值，实现 Cookie 的遍历解析。

2. 应用实例

下面以知乎为例来说明。首先登录知乎，将 Headers 中的 Cookie 内容复制下来：

这里可以替换成自己的 Cookie，将其设置到 Headers 里面，然后发送请求，示例如下：

import requests

headers = {
    
    
    'Cookie': '_zap=64d38126-f2ad-4c43-a81b-7dc23fbd7e10; _xsrf=q6upjuYdnTJukfZxReHuqwqh4ROEBjRb; d_c0="AEAflpFB1RKPTnGOzhlyFW1xQ9N34YerGyc=|1616329021"; captcha_session_v2="2|1:0|10:1616329022|18:captcha_session_v2|88:SWd2R2EzbE5OVmhwNWVLQ2ordlJUdDRUTE42YzZmaWFaOHY3RUhYYTVZaGU4bHA5YW4xdTdJV3hVaVR5L1lYNg==|5fbda731ffd67ad78af2954932689fc1c2a84d8f5fe0c5e81d8e00f08b231c0e"; __snaker__id=yNqkINZR88aUPluZ; gdxidpyhxdE=rcWk%5CI%5Cmyi9i9ja%2FAu1cjyf021OP7NjV42iuDWLA1eEN0NGdpV2%2FQ7vsXDUu76yozsqw8MViBrLxdfR41gI8N82l97oMg2RGt7oHCR%5CPwWpu9NLyezmOH9nv%2BusywDABLYXvm7W3aLl1KIlb%5CMC3gjZlimygbc4ebRY4vxIO2gfSCxG1%3A1616329926421; _9755xjdesxxd_=32; YD00517437729195%3AWM_NI=BwRECah%2BtbnmkkskBS%2FQfs5NttkQ5kLyBHQyocXcd%2BftfNTVXWr2DMYYD7nO5SiS3kcNMDFkN0C%2F8%2BNcFceioKeNfCeqvhRma3orgXx1gQK6rCM5u9e%2B1EYpGg%2FFspqISWI%3D; YD00517437729195%3AWM_NIKE=9ca17ae2e6ffcda170e2e6ee97bb59a9ed858cf55096bc8ab3c54a979f8abaae3b9897a58ffc3dafb4a4d2d32af0fea7c3b92a82a99ea6c26bacf5bc83ed67a9b5bd8cc159ed8faa94b846b8aca5b2b86190a78ea9d473adbd9884e721a6acaaafd75e9c89bed3c7479b878cd8ed45f78da7b4b261a19283a5c5618ef08dd0bb218ebd8a84e863ad95abafe549a7afba89d167a3eda193e654bcefa9b2ca3eb29d83d6f833a7f5ffa6dc7c85b9e1a7f27cb3979db8cc37e2a3; YD00517437729195%3AWM_TID=lnKXz1t%2FvmxFURRFQVd7kDY0n26300ke; captcha_ticket_v2="2|1:0|10:1616329041|17:captcha_ticket_v2|704:eyJ2YWxpZGF0ZSI6IkNOMzFfNW9pN2J0YlV5ay1zeDRuVm5RVHo2NXJlZzR1SUE3WnhYLXZNTXpxWHRVRlJ6c1pVSndlVDdKQzhvNHp6czVsLW9HdjZaRC11UzhoaXY2bEs4Zi1RVjA5UTZWVjBRTFlrY0s4NDZKa3VjUFdob05qbjJSeWt3S3FKZWNxVHM0VUt0RHM0WGh4RXJ2bGpJQ1Vfa2ZvamZlMUJlWGJTQ1pWcUR2VUp0T21hVWQ0TkMwUGRJRldQb3NvN2k2bThYdUJYWDA5cHFIXzRtaFd4dVF3SEVBT291MXh6b2txTndOMi1BUENRZ19NUGpNSWYtcUZybEdTOFU3SWpORVBiZDJpSzQxVndxc2FNaE1NNnRDWWFST2dlUy4xYVlZVmNXS0hEOFNrckdhRmthMjFSQ3hCQjlqMGhVMlJ0THVHQTRaYW9EZkdtMkhXWGpGbmY3YlZGQjg2dG1SUUR2SG1NeDYxVEVxbGNVaDlTV3liWEFSR0xXQWhNeUNJVWZ3WkZ5QnhjeEo0NkYuSFdya2ZPLXZtazR0VUhXVi5OMmpCOVpEV2NGRmI0ZnR0eWM3aUZ1ajhRWGMuS2dKUTFpQVA3enhmOUhac3ZiRnRPakt6TUQuX2NEOThySFZZR0xzU3RRRmNXaExsY3lVV2o2RDVpUlg2MDVzMmNfV2c5MnROMyJ9|50ecdd6a7bb93674cb8aecd421e41102baa223b669f1261b982742a3065ab8e3"; z_c0="2|1:0|10:1616329146|4:z_c0|92:Mi4xMVVUU0t3QUFBQUFBUUItV2tVSFZFaVlBQUFCZ0FsVk51WWRFWVFCdnRETkdiS3IxZHdhdUZQQWV2d25QTFVqMU1R|e6441d290628dd2defd7c7958e3f3713d34b7ceb98ec668aeb1e874569dbc0ae"; tst=r; Hm_lvt_98beee57fd2ef70ccdd5ca52b9740c49=1616329021,1616329489; Hm_lpvt_98beee57fd2ef70ccdd5ca52b9740c49=1616329489; SESSIONID=TFCq1p1iqVUumN3DG3IxOtLefNEwShLQVgsvAyNBu2M; KLBRSID=fe78dd346df712f9c4f126150949b853|1616329491|1616329014; JOID=Vl8dBUxasIMoEJjXV1hQ0X6M2wJJDfnOWCLr6TAo5dlTfNXnHEWK20oQlNZY4ZIW0vuK0sVRHqwYQtH5LjUk2Uo=; osd=Vl4XAUxasYksEJjWXVxQ0X-G3wJJDPPKWCLq4zQo5dhZeNXnHU-O20oRntJY4ZMc1vuK089VHqwZSNX5LjQu3Uo=',
    'Host': 'www.zhihu.com',
    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.116 Safari/537.36',
}
r = requests.get('https://www.zhihu.com', headers=headers)
print(r.text)

我们发现，在运行结果中包含了登录后的结果，如下图所示，这证明登录成功。

除了上述代码中，在 headers 里面设置 Cookies，我们也可以通过 cookies 参数来设置，不过这样就需要构造 RequestsCookieJar 对象，而且需要分割一下 cookies。这种方式相对烦琐，不过效果是相同的，示例如下：

import requests

cookies = '_zap=64d38126-f2ad-4c43-a81b-7dc23fbd7e10; _xsrf=q6upjuYdnTJukfZxReHuqwqh4ROEBjRb; d_c0="AEAflpFB1RKPTnGOzhlyFW1xQ9N34YerGyc=|1616329021"; captcha_session_v2="2|1:0|10:1616329022|18:captcha_session_v2|88:SWd2R2EzbE5OVmhwNWVLQ2ordlJUdDRUTE42YzZmaWFaOHY3RUhYYTVZaGU4bHA5YW4xdTdJV3hVaVR5L1lYNg==|5fbda731ffd67ad78af2954932689fc1c2a84d8f5fe0c5e81d8e00f08b231c0e"; __snaker__id=yNqkINZR88aUPluZ; gdxidpyhxdE=rcWk%5CI%5Cmyi9i9ja%2FAu1cjyf021OP7NjV42iuDWLA1eEN0NGdpV2%2FQ7vsXDUu76yozsqw8MViBrLxdfR41gI8N82l97oMg2RGt7oHCR%5CPwWpu9NLyezmOH9nv%2BusywDABLYXvm7W3aLl1KIlb%5CMC3gjZlimygbc4ebRY4vxIO2gfSCxG1%3A1616329926421; _9755xjdesxxd_=32; YD00517437729195%3AWM_NI=BwRECah%2BtbnmkkskBS%2FQfs5NttkQ5kLyBHQyocXcd%2BftfNTVXWr2DMYYD7nO5SiS3kcNMDFkN0C%2F8%2BNcFceioKeNfCeqvhRma3orgXx1gQK6rCM5u9e%2B1EYpGg%2FFspqISWI%3D; YD00517437729195%3AWM_NIKE=9ca17ae2e6ffcda170e2e6ee97bb59a9ed858cf55096bc8ab3c54a979f8abaae3b9897a58ffc3dafb4a4d2d32af0fea7c3b92a82a99ea6c26bacf5bc83ed67a9b5bd8cc159ed8faa94b846b8aca5b2b86190a78ea9d473adbd9884e721a6acaaafd75e9c89bed3c7479b878cd8ed45f78da7b4b261a19283a5c5618ef08dd0bb218ebd8a84e863ad95abafe549a7afba89d167a3eda193e654bcefa9b2ca3eb29d83d6f833a7f5ffa6dc7c85b9e1a7f27cb3979db8cc37e2a3; YD00517437729195%3AWM_TID=lnKXz1t%2FvmxFURRFQVd7kDY0n26300ke; captcha_ticket_v2="2|1:0|10:1616329041|17:captcha_ticket_v2|704:eyJ2YWxpZGF0ZSI6IkNOMzFfNW9pN2J0YlV5ay1zeDRuVm5RVHo2NXJlZzR1SUE3WnhYLXZNTXpxWHRVRlJ6c1pVSndlVDdKQzhvNHp6czVsLW9HdjZaRC11UzhoaXY2bEs4Zi1RVjA5UTZWVjBRTFlrY0s4NDZKa3VjUFdob05qbjJSeWt3S3FKZWNxVHM0VUt0RHM0WGh4RXJ2bGpJQ1Vfa2ZvamZlMUJlWGJTQ1pWcUR2VUp0T21hVWQ0TkMwUGRJRldQb3NvN2k2bThYdUJYWDA5cHFIXzRtaFd4dVF3SEVBT291MXh6b2txTndOMi1BUENRZ19NUGpNSWYtcUZybEdTOFU3SWpORVBiZDJpSzQxVndxc2FNaE1NNnRDWWFST2dlUy4xYVlZVmNXS0hEOFNrckdhRmthMjFSQ3hCQjlqMGhVMlJ0THVHQTRaYW9EZkdtMkhXWGpGbmY3YlZGQjg2dG1SUUR2SG1NeDYxVEVxbGNVaDlTV3liWEFSR0xXQWhNeUNJVWZ3WkZ5QnhjeEo0NkYuSFdya2ZPLXZtazR0VUhXVi5OMmpCOVpEV2NGRmI0ZnR0eWM3aUZ1ajhRWGMuS2dKUTFpQVA3enhmOUhac3ZiRnRPakt6TUQuX2NEOThySFZZR0xzU3RRRmNXaExsY3lVV2o2RDVpUlg2MDVzMmNfV2c5MnROMyJ9|50ecdd6a7bb93674cb8aecd421e41102baa223b669f1261b982742a3065ab8e3"; z_c0="2|1:0|10:1616329146|4:z_c0|92:Mi4xMVVUU0t3QUFBQUFBUUItV2tVSFZFaVlBQUFCZ0FsVk51WWRFWVFCdnRETkdiS3IxZHdhdUZQQWV2d25QTFVqMU1R|e6441d290628dd2defd7c7958e3f3713d34b7ceb98ec668aeb1e874569dbc0ae"; tst=r; Hm_lvt_98beee57fd2ef70ccdd5ca52b9740c49=1616329021,1616329489; Hm_lpvt_98beee57fd2ef70ccdd5ca52b9740c49=1616329489; SESSIONID=TFCq1p1iqVUumN3DG3IxOtLefNEwShLQVgsvAyNBu2M; KLBRSID=fe78dd346df712f9c4f126150949b853|1616329491|1616329014; JOID=Vl8dBUxasIMoEJjXV1hQ0X6M2wJJDfnOWCLr6TAo5dlTfNXnHEWK20oQlNZY4ZIW0vuK0sVRHqwYQtH5LjUk2Uo=; osd=Vl4XAUxasYksEJjWXVxQ0X-G3wJJDPPKWCLq4zQo5dhZeNXnHU-O20oRntJY4ZMc1vuK089VHqwZSNX5LjQu3Uo='
jar = requests.cookies.RequestsCookieJar()
headers = {
    
    
    'Host': 'www.zhihu.com',
    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.116 Safari/537.36'
}
for cookie in cookies.split(';'):
    key, value = cookie.split('=', 1)
    jar.set(key, value)
r = requests.get("http://www.zhihu.com", cookies=jar, headers=headers)
print(r.text)

这里我们首先新建了一个 RequestCookieJar 对象，然后将复制下来的 cookies 利用 split() 方法分割，接着利用 set() 方法设置好每个 Cookie 的 key 和 value，然后通过调用 requests 的 get() 方法并传递给 cookies 参数即可。当然，由于知乎本身的限制，headers 参数也不能少，只不过不需要在原来的 headers 参数里面设置 cookie 字段了。

运行代码，结果同前面代码运行结果一致。

（三）维持会话、模拟登录

在 requests 中，如果直接利用 get() 或 post() 等方法的确可以做到模拟网页的请求，但是这实际上是相当于不同的会话，也就是说相当于你用了两个浏览器打开了不同的页面。

设想这样一个场景，第一个请求利用 post() 方法登录了某个网站，第二次想获取成功登录后的自己的个人信息，你又用了一次 get() 方法去请求个人信息页面。实际上，这相当于打开了两个浏览器，是两个完全不相关的会话，能成功获取个人信息吗？那当然不能。

有人可能会说，我在两次请求时设置一样的 cookies 不就行了？可以，但这样做起来显得很烦琐，我们有更简单的解决方法。

其实解决这个问题的主要方法就是维持同一个会话，也就是相当于打开一个新的浏览器选项卡而不是新开一个浏览器。但是我又不想每次设置 cookies，那该怎么办呢？这时候就有了新的利器 ——Session 对象。

利用它，我们可以方便地维护一个会话，而且不用担心 cookies 的问题，它会帮我们自动处理好。如下示例：

import requests

requests.get('http://httpbin.org/cookies/set/number/123456789')
r = requests.get('http://httpbin.org/cookies')
print(r.text)

这里我们请求了一个测试网址 http://httpbin.org/cookies/set/number/123456789。请求这个网址时，可以设置一个 cookie，名称叫作 number，内容是 123456789，随后又请求了 http://httpbin.org/cookies，此网址可以获取当前的 Cookies。

这样能成功获取到设置的 Cookies 吗？试试看。运行结果如下：

{
    
    
  "cookies": {
    
    }
}

这种方法并不行。我们再用 Session 试试看：

import requests

s = requests.Session()
s.get('http://httpbin.org/cookies/set/number/123456789')
r = s.get('http://httpbin.org/cookies')
print(r.text)

再看一下运行结果：

{
    
    
  "cookies": {
    
    
    "number": "123456789"
  }
}

这次成功获取！所以，利用 Session，可以做到模拟在一个浏览器中打开同一站点的不同页面。它通常用于模拟登录成功之后再进行下一步的操作。

（四）SSL证书验证

此外，requests 还提供了证书验证的功能。当发送 HTTP 请求的时候，它会检查 SSL 证书，我们可以使用 verify 参数控制是否检查此证书。其实如果不加 verify 参数的话，默认是 True，会自动验证。

前面我们提到过，12306 的证书没有被官方 CA 机构信任，会出现证书验证错误的结果。我们现在访问它，都可以看到一个证书问题的页面，如图所示：

现在我们用 requests 来测试一下：

import requests

response = requests.get('https://www.12306.cn')
print(response.status_code)

# 运行结果：
requests.exceptions.SSLError: ("bad handshake: Error([('SSL routines', 'tls_process_server_certificate', 'certificate verify failed')],)",)

这里提示一个错误 SSLError，表示证书验证错误。所以，如果请求一个 HTTPS 站点，但是证书验证错误的页面时，就会报这样的错误，那么如何避免这个错误呢？很简单，把 verify 参数设置为 False 即可。相关代码如下：

import requests

response = requests.get('https://www.12306.cn', verify=False)
print(response.status_code)

# 运行结果：
/usr/local/lib/python3.6/site-packages/urllib3/connectionpool.py:852: InsecureRequestWarning: Unverified HTTPS request is being made. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings
  InsecureRequestWarning)
200

不过我们发现报了一个警告，它建议我们给它指定证书。我们可以通过设置忽略警告的方式来屏蔽这个警告：

import requests
from requests.packages import urllib3

urllib3.disable_warnings()
response = requests.get('https://www.12306.cn', verify=False)
print(response.status_code)

或者通过捕获警告到日志的方式忽略警告：

import logging
import requests

logging.captureWarnings(True)
response = requests.get('https://www.12306.cn', verify=False)
print(response.status_code)

当然，我们也可以指定一个本地证书用作客户端证书，这可以是单个文件（包含密钥和证书）或一个包含两个文件路径的元组：

import requests

response = requests.get('https://www.12306.cn', cert=('/path/server.crt', '/path/key'))
print(response.status_code)

当然，上面的代码是演示实例，我们需要有 crt 和 key 文件，并且指定它们的路径。注意，本地私有证书的 key 必须是解密状态，加密状态的 key 是不支持的。

（五）代理设置

对于某些网站，在测试的时候请求几次，能正常获取内容。但是一旦开始大规模爬取，对于大规模且频繁的请求，网站可能会弹出验证码，或者跳转到登录认证页面，更甚者可能会直接封禁客户端的 IP，导致一定时间段内无法访问。

那么，为了防止这种情况发生，我们需要设置代理来解决这个问题，这就需要用到 proxies 参数。可以用这样的方式设置：

import requests

proxies = {
    
    
  "http": "http://10.10.1.10:3128",
  "https": "http://10.10.1.10:1080",
}

requests.get("https://www.taobao.com", proxies=proxies)

当然，直接运行这个实例可能不行，因为这个代理可能是无效的，请换成自己的有效代理试验一下。

若代理需要使用 HTTP Basic Auth，可以使用类似 http://user:password@host:port 这样的语法来设置代理，示例如下：

import requests

proxies = {
    
    
    "http": "http://user:[email protected]:3128/",
}
requests.get("https://www.taobao.com", proxies=proxies)

除了基本的 HTTP 代理外，requests 还支持 SOCKS 协议的代理。

首先，需要安装 socks 这个库：

pip3 install 'requests[socks]'

然后就可以使用 SOCKS 协议代理了，示例如下：

import requests

proxies = {
    
    
    'http': 'socks5://user:password@host:port',
    'https': 'socks5://user:password@host:port'
}
requests.get("https://www.taobao.com", proxies=proxies)

（六）超时设置

在本机网络状况不好或者服务器网络响应太慢甚至无响应时，我们可能会等待特别久的时间才可能收到响应，甚至到最后收不到响应而报错。为了防止服务器不能及时响应，应该设置一个超时时间，即超过了这个时间还没有得到响应，那就报错。这需要用到 timeout 参数。这个时间的计算是发出请求到服务器返回响应的时间。示例如下：

import requests

r = requests.get("https://www.taobao.com", timeout = 1)
print(r.status_code)

# 运行结果：
200

通过这样的方式，我们可以将超时时间设置为 1 秒，如果 1 秒内没有响应，那就抛出异常。

实际上，请求分为两个阶段，即连接（connect）和读取（read）。上面设置的 timeout 将用作连接和读取这二者的 timeout 总和。如果要分别指定，就可以传入一个元组：

r = requests.get('https://www.taobao.com', timeout=(5,11))

如果想永久等待，可以直接将 timeout 设置为 None，或者不设置直接留空，因为默认是 None。这样的话，如果服务器还在运行，但是响应特别慢，那就慢慢等吧，它永远不会返回超时错误的。其用法如下：

r = requests.get('https://www.taobao.com', timeout=None)

或直接不加参数：

r = requests.get('https://www.taobao.com')

（七）身份认证

在访问网站时，我们可能会遇到这样的认证页面，如下图所示。

此时可以使用 requests 自带的身份认证功能，示例如下：

import requests
from requests.auth import HTTPBasicAuth

r = requests.get('http://localhost:5000', auth=HTTPBasicAuth('username', 'password'))
print(r.status_code)

如果用户名和密码正确的话，请求时就会自动认证成功，会返回 200 状态码，如果认证失败，则返回 401 状态码。

当然，如果参数都传一个 HTTPBasicAuth 类，就显得有点烦琐了，所以 requests 提供了一个更简单的写法，可以直接传一个元组，它会默认使用 HTTPBasicAuth 这个类来认证。

所以上面的代码可以直接简写如下：

import requests

r = requests.get('http://localhost:5000', auth=('username', 'password'))
print(r.status_code)

此外，requests 还提供了其他认证方式，如 OAuth 认证，不过此时需要安装 oauth 包，安装命令如下：

pip3 install requests_oauthlib

使用 OAuth1 认证的方法如下：

import requests
from requests_oauthlib import OAuth1

url = 'https://api.twitter.com/1.1/account/verify_credentials.json'
auth = OAuth1('YOUR_APP_KEY', 'YOUR_APP_SECRET',
              'USER_OAUTH_TOKEN', 'USER_OAUTH_TOKEN_SECRET')
requests.get(url, auth=auth)

更多详细的功能可以参考 requests_oauthlib 的官方文档 https://requests-oauthlib.readthedocs.org/，此处不再赘述。

（八）Prepared Request

前面介绍 urllib 时，我们可以将请求表示为数据结构，其中各个参数都可以通过一个 Request 对象来表示。这在 requests 里同样可以做到，这个数据结构就叫 Prepared Request。我们用实例看一下：

url = 'http://httpbin.org/post'
data = {
    
    
    'name': 'germey'
}
headers = {
    
    
    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.116 Safari/537.36'
}
s = requests.Session()
req = requests.Request('POST', url, data=data, headers=headers)
prepped = s.prepare_request(req)
r = s.send(prepped)
print(r.text)

这里我们引入了 Request，然后用 url、data 和 headers 参数构造了一个 Request 对象，这时需要再调用 Session 的 prepare_request() 方法将其转换为一个 Prepared Request 对象，然后调用 send() 方法发送即可，运行结果如下：

{
    
    
  "args": {
    
    }, 
  "data": "", 
  "files": {
    
    }, 
  "form": {
    
    
    "name": "germey"
  }, 
  "headers": {
    
    
    "Accept": "*/*", 
    "Accept-Encoding": "gzip, deflate", 
    "Content-Length": "11", 
    "Content-Type": "application/x-www-form-urlencoded", 
    "Host": "httpbin.org", 
    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.116 Safari/537.36", 
    "X-Amzn-Trace-Id": "Root=1-60574a91-7b44c04c1feebbf3510589c0"
  }, 
  "json": null, 
  "origin": "111.44.230.246", 
  "url": "http://httpbin.org/post"
}

可以看到，我们达到了同样的 POST 请求效果。

有了 Request 这个对象，就可以将请求当作独立的对象来看待，这样在进行队列调度时会非常方便。后面我们会用它来构造一个 Request 队列。

本节讲解了 requests 的一些高级用法，这些用法在后面实战部分会经常用到，需要熟练掌握。更多的用法可以参考 requests 的官方文档：http://docs.python-requests.org/。

send()` 方法发送即可，运行结果如下：

{
    
    
  "args": {
    
    }, 
  "data": "", 
  "files": {
    
    }, 
  "form": {
    
    
    "name": "germey"
  }, 
  "headers": {
    
    
    "Accept": "*/*", 
    "Accept-Encoding": "gzip, deflate", 
    "Content-Length": "11", 
    "Content-Type": "application/x-www-form-urlencoded", 
    "Host": "httpbin.org", 
    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.116 Safari/537.36", 
    "X-Amzn-Trace-Id": "Root=1-60574a91-7b44c04c1feebbf3510589c0"
  }, 
  "json": null, 
  "origin": "111.44.230.246", 
  "url": "http://httpbin.org/post"
}

可以看到，我们达到了同样的 POST 请求效果。

有了 Request 这个对象，就可以将请求当作独立的对象来看待，这样在进行队列调度时会非常方便。后面我们会用它来构造一个 Request 队列。

本节讲解了 requests 的一些高级用法，这些用法在后面实战部分会经常用到，需要熟练掌握。更多的用法可以参考 requests 的官方文档：http://docs.python-requests.org/。