python爬虫-request模块

1. requests 中的请求方法

HTTP 请求方法:
requests.get(url, params=None, **kwargs)                # GET 请求
requests.post(url, data=None, json=None, **kwargs)      # POST 请求
requests.put(url, data=None, **kwargs)                  # PUT 请求
requests.patch(url, data=None, **kwargs)                # PATCH 请求
requests.head(url, **kwargs)                            # HEAD 请求
requests.options(url, **kwargs)                         # OPTIONS 请求
requests.delete(url, **kwargs)                          # DELETE 请求

# 以上所有请求均返回一个 requests.Response 对象

requests.request(method, url, **kwargs)
参数说明:

method:
      请求方法: "GET", "POST", "PUT", "PATCH", "HEAD", "OPTIONS", or "DELETE"

url:
      请求链接

params:
      URL查询参数, 拼接到 URL Query String 中, 一般用于 GET 请求,
      类型: 字典{name1:value1, ...}、
           元祖列表[(name1, value1), ...]、
           bytes/str([b]"name1=value1&name2=value2")。
      拼接后结果如: http://httpbin.org/get?name1=value1&name2=value2

data:
      发送到请求 Body 中的数据, 一般用于 POST/PUT 请求,
      类型: 字典{name1:value1, ...}, 元祖列表[(name1, value1), ...], bytes/str 或 文件流对象。

      如果是 字典/元祖列表, 则按照 form 表单格式拼接后发送到请求 Body 中,
      如: "name1=value1&name2=value2", 并且自动添加请求头:
      "Content-Type": "application/x-www-form-urlencoded"

      如果是 bytes/str, 则直接将内容发送到请求 Body 中, 并且不添加 Content-Type 请求头。

      如果是 文件流对象, 则把文件内容当做 bytes 直接发送到请求 Body 中, 发送完后需手动关闭文件流。

json:
      一个可被序列化为 JSON 字符串的 Python 对象（如 字典）, 一般用于 POST 请求,
      序列化后的 JSON 字符串发送到请求 Body 中, 并自动添加请求头:
      "Content-Type": "application/json"

headers:
      HTTP 请求头, 字典类型, 如: {"Header1": "Value1", "Header2": "Value2"}, 会覆盖现有的请求头。

cookies:
      添加到请求头中的 Cookies, 类型: 字典{name1:value1, ...} 或 CookieJar对象。
      如果传递的是 CookieJar 对象, 则从中提取适合该 URL 请求的 Cookie 添加到请求头中。
      添加的 Cookie 请求头示例:
      "Cookie": "name1=value1; name2=value2"
      响应中返回的 CookieJar 对象为 requests.cookies.RequestsCookieJar,
      继承自 requests.cookies.cookielib.CookieJar == http.cookiejar.CookieJar。

files:
      上传文件, 字典类型。
      一般作为 POST 提交 "multipart/form-data; boundary=xxx" 多部分编码 form 表单中的文件字段,
      可结合 data 参数同时上传 form 表单的 普通字段 和 文件字段。

      使用了该参数, 自动添加请求头:
          "Content-Type": "multipart/form-data; boundary=xxx"

      参数传值格式:
          {"field_name": file-like-objects}
          {"field_name": ("filename", fileobj)}
          {"field_name": ("filename", fileobj, "content_type")}
          {"field_name": ("filename", fileobj, "content_type", custom_headers)}
      说明:
          其中 fileobj 可以用 str/bytes 来代替要上传的文件内容;
          "filename"     表示显式地设置 该文件字段的 文件名;
          "content_type" 表示显式地设置 该文件字段的 文件类型;
          custom_headers 表示显式地设置 该文件字段的 请求头, 值为字典类型;
          可同时上传多个文件;
          打开的文件流需要手动关闭。

      参数传值示例:
          {"f1": open("aa.jpg", "rb")} 提交后表单字段值为: name=f1, filename=aa.jpg
          {"f1": open("aa.jpg", "rb"), "f2": open("bb.png", "rb")} 同时上传多个文件
          {"f1": ("bb.jpg", open("aa.jpg", "rb"))} 提交后表单字段值为: name=f1, filename=bb.jpg

auth:
      身份认证, 传递一个认证对象或元祖, 支持 Basic/Digest/Custom HTTP Auth。
      参数值传递格式:
          Basic Auth:  auth=requests.auth.HTTPBasicAuth("user", "pass")
                       或
                       auth=("user", "pass")
          Digest Auth: auth=requests.auth.HTTPDigestAuth("user", "pass")

      使用示例:
      resp = requests.get("https://httpbin.org/basic-auth/user/pass", auth=("user", "pass"))

timeout:
      超时时间, 单位为秒。类型为 float 或 元祖。
      如果传递一个 float 参数, 则表示服务器在 timeout 秒内没有应答, 则抛出超时异常。
      也可以传递一个包含 连接超时 和 读取超时 的元祖: (connect timeout, read timeout)

allow_redirects:
      是否允许重定向。类型为 bool 类型, 默认为 True。

proxies:
      URL 代理。类型为字典。使用示例:
      proxies = {
          "http": "http://10.10.1.10:3128",
          "https": "http://10.10.1.10:1080"
      }
      requests.get("http://example.org", proxies=proxies)

verify:
      是否验证证书。类型为 bool 或 str, 默认为 True。
      bool类型: 表示是否验证服务端的 TLS 证书。
      str 类型: CA_BUNDLE 文件的路径, 或者包含可信任 CA 证书文件的文件夹路径。

      目前各大网站基本有自己的ca证书，但是不排除有的网站为了节约网站建设开销并没有购买ca证书。
      又因为requests模块在发送网络请求的时候，默认会验证ca证书。如果当前网站没有ca证书，那么就会报错:requests.exceptions.SSLError
      如果出现上述错误，那么我们可以用verify关键字参数，在请求的时候不验证网站的ca证书
          response = requests.get( "url"，verify=False)
      如果加了verify=False这个关键字参数，使用requests模块发送请求的时候会给你弹出一个警告，警告你当前的请求可能不安全:InsecureRequestWarning
      这个警告对于后面的代码逻辑没有影响，有强迫症的可以考虑加入以下代码忽略警告:
        import urllib3
        urllib3.disable_warnings() 

stream:
      响应内容是否是流数据, 类型为 bool。如果是 False, 响应内容将被立即下载。

cert:
      客户端证书。类型为 str 或 tuple。
      str  类型: 指定一个本地证书文件(包含密钥和证书)用作客户端证书, 如 cert="client.pem"
      tuple类型: 一个包含两个文件路径的元组, 如 cert=("client.cert", "client.key")

实例：

import requests

if __name__ == '__main__':
    # UA伪装
    headers = {
        'User-Agent': '网页f12里找User-Agent这个字段复制过来'
    }
    url = 'https://www.bing.com/search?'
    # 处理url携带的参数：封装到字典中
    kw = input('enter a word:')
    param = {
        'q': kw
    }
    # 对指定的url发起的请求对应url是携带参数的，而且q请求过程中处理了参数
    resp = requests.get(url=url, params=param, headers=headers)
    print(resp.status_code)  # 响应头
    print(resp.headers)  # 响应头
    print(resp.cookies)  # 响应的 cookies
    print(resp.content.decode("utf-8"))  # 响应内容
    # print(resp.reason) # HTTP 响应状态吗对应的名称

    # fileName = kw + '.html'
    # with open(fileName, 'w', encoding='UTF-8') as fp:
    #     fp.write(page_text)
    # print(fileName, '保存成功！！！')

2. 响应对象: requests.Response

发出请求后，将返回一个 requests.Response 对象，包含了服务端对 HTTP 请求的响应。

Response 类的常用方法和字段：

close()
# 释放链接, 放回连接池。调用该方法后, raw 对象将不能访问。
# Note: 通常不需要显式地调用该方法。

status_code = None
# HTTP 响应状态码, 如: 200, 302, 404, 500
# 可以使用内置的状态码常量, 如: requests.codes.OK, requests.codes.NOT_FOUND

reason = None
# HTTP 响应状态吗对应的名称, 如: "OK", "Not Found"

ok
# 如果 status_code 小于 400, 则返回 True

raise_for_status()
# 抛出的 HTTPError, 如果发生 HTTPError, 将被存储。

url = None
# 响应的最终 URL 位置

headers = None
# 不区分大小写的响应头的字典。获取指定响应头的值: headers["header_name"]
# 例如 headers["content-encoding"] 和 headers["Content-Encoding"],
# 均返回 Content-Encoding 响应头对应的值

cookies = None
# 服务端响应中返回的 CookieJar 对象, 类型为 requests.cookies.RequestsCookieJar,
# 继承自 requests.cookies.cookielib.CookieJar == http.cookiejar.CookieJar
# 获取指定 cookie 的值: cookies.get("name") 或 cookies["name"]
# 获取所有 cookie 的值: cookies.items(), 返回 [(name, value), ...]

apparent_encoding
# 响应内容的表观编码, 由 chardet 库提供

content
# 字节类型的响应内容

text
# Unicode 表示的响应内容。
# 如果 Response.encoding 为 None, 将使用猜到的 chardet 解码。

json(**kwargs)
# 返回响应的 JSON 编码内容（如果有）

raw = None
# 响应的文件流对象（用于高级用法）, 使用该字段需要在请求时传递参数: stream=True

iter_content(chunk_size=1, decode_unicode=False)
# 遍历响应数据。需要在请求时添加参数 stream=True, 该方法可避免将较大的响应立即读取到内存中。
# chunk_size 为本次应该读取的最大字节数, 最后一次可能达不到该数量。
#
# chunk_size 必须为 int 或 None 类型。
#
# chunk_size 为 None 时。如果 stream=True, 将以达到接收到的块的大小读取数据。
# 如果 stream=False, 则将数据作为单个块返回。
#
# 如果 decode_unicode=True, 则将基于响应使用最佳的可以用编码对内容进行解码。

iter_lines(chunk_size=512, decode_unicode=None, delimiter=None)
# 遍历响应数据, 一次读取一行。需要在请求时添加参数 stream=True,
# 该方法可避免将较大的响应立即读取到内存中。
# Note: 此方法不是可重入的安全方法。

is_redirect
# 此响应是一个格式正确的 HTTP 重定向, 并且可能已经被自动处理, 则为 True

is_permanent_redirect
# 如果此响应是重定向的永久版本之一, 则为 True

history = None
# 请求的历史响应对象列表。任何重定向都将在此处结束。该列表从最早的请求到最新的请求进行排序。

next
# 如果有重定向请求, 则 next 为下一个请求返回的 PreparedRequest 对象

request = None
# 作为响应的 PreparedRequest 对象

links
# 返回响应的已解析头链接（如果有）

elapsed = None
# 从发送请求到响应到达之间经过的时间（以时间增量为单位, 如 0:00:00.306239）
# 类型为 <class 'datetime.timedelta'>
# 此属性专门用于测试发送请求到第一个字节与头解析之间所需要的时间。
# 此属性不会因为使用响应内容或 stream 参数值而受影响。

encoding = None
# 当访问 r.txt 时用于解码的编码格式

实例：

import requests

resp = requests.get("http://httpbin.org/get")

# 响应内容编码
print(resp.apparent_encoding)  # 返回一个 ascii (编码)

# 解码字节类型的响应内容
# resp的content(响应内容)按照(resp.apparent_encoding)的编码进行decode(解码)
print(resp.content.decode(resp.apparent_encoding))

# 直接使用已解码的响应内容
print(resp.text)

#请求中添加 Cookie

#请求中添加 Cookie
import requests

cookies = {"key1": "value1", "key2": "value2"}
resp = requests.get("http://httpbin.org/cookies", cookies=cookies)
print(resp.text)
'{"cookies": {"key1": "value1", "key2": "value2"}}'

自动保持会话: requests.Session
Session 对象能够跨请求保持某些参数（例如: 请求头）。它也会再同一个 Session 实例发出的所有请求之间保持 Cookies（自动保存/添加 Cookies）。
Session 请求期间使用 urllib3 的连接池功能，所以向同一个主机发送多个请求，底层的 TCP 链接将被重用，从而达到性能提升的效果。

清晰一点的回答：
使用 requests 模块的时候，是直接 requests.get() 或者 requests.post() 发送GET请求或POST请求；

当然也是可以带上 cookies 和 headers 的，但这都是一次性请求，你这次带着cookies信息，后面的请求还得带。

这时候 requests.session() 就派上用场了，它可以自动处理cookies，做状态保持。

Session 拥有的请求方法与 requests 相同，如: session.get()、session.post()、session.request() 等，其传入的参数格式也相同。

请求添加固定请求头 和 Cookies 保持:

import requests

# 创建会话对象
session = requests.Session()

# session 对象创建后, session.headers 和 session.cookies 均已有值, 直接添加数据即可。
# session.headers 类型为 requests.structures.CaseInsensitiveDict
# session.cookies 类型为 requests.cookies.RequestsCookieJar

# 添加固定请求头
session.headers.update({"User-Agent": "hello/world", "X-Test": "Test-Value"})
# 输出请求头
print(session.headers)

# 手动设置 Cookie 到 session 中
session.cookies.set("key1", "value1", domain="httpbin.org", path="/")

# 发送请求（响应中将会设置一个cookie: hello=world）
resp = session.get("http://httpbin.org/cookies/set/hello/world")
print(resp.text)

# 发出请求（将自动携带 固定请求头 和 Cookies）
resp = session.get("http://httpbin.org/cookies")
print(resp.text)

# 发出请求（将自动携带固定请求头和Cookies）
resp = session.get("http://httpbin.org/get")
print(resp.text)

# 关闭会话
session.close()

 

转自：https://blog.csdn.net/xietansheng/article/details/115558046