Python第三方requests库Session对象详解（2/6）_request.session

请求会话

        使用requests.Session对象可以在多个请求之间保持会话，其HTTP请求方法与requests的请求方法一致。

requests.Session类

        提供一种持久性的会话，允许在多个请求之间保持cookie、header和连接池等配置参数的共享，这样可以重用同一连接，而不是为每个请求创建一个新的连接。

例1：基本用法

import requests

# 创建一个 Session 对象

session = requests.Session()

# 设置共享的 headers

session.headers.update({'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'})

# 发送多个请求

url = 'https://www.example.com'

response1 = session.get(url)

response2 = session.post(url, data={'key': 'value'})

# 关闭 Session（可选）

session.close()

例2：作为上下文管理器

>>> with requests.Session() as s:

>>>     s.get('http://httpbin.org/get')

<Response [200]>

方法

——Session对象的HTTP请求方法

与requests的HTTP请求方法一样，唯一区别是Session对象提供了会话保持的功能

1、request(method, url, params=None, data=None, headers=None, cookies=None, files=None, auth=None, timeout=None, allow_redirects=True, proxies=None, hooks=None, stream=None, verify=None, cert=None, json=None)

同requests.Request()方法。

2、get(url, **kwargs)

同requests.get()方法。

3、POST(url, data=None, json=None, **kwargs)

同requests.POST()方法。

4、put(url, data=None, **kwargs)

同requests.put()方法。

5、patch(url, data=None, **kwargs)

同requests.patch()方法。

patch() 方法的主要作用包括：

局部更新资源: 使用 patch() 方法可以向服务器发送仅包含要更新的字段或属性的数据，而不是整个资源。这对于减少数据传输量和减轻服务器负担很有用。

避免冲突: 在多用户或多系统环境中，多个客户端可能尝试更新同一资源。使用 PATCH 方法，可以避免因为整个资源的替换而引起的冲突问题，只更新需要修改的部分。

减少网络负担: 相对于 PUT 方法，PATCH 方法通常传输的数据更少，因为它只包含要更新的字段。这可以减少网络负担，提高性能。

支持条件更新: 可以使用条件请求头（如 If-Match 或 If-None-Match）来控制是否执行更新，以增加更新的安全性和控制性。

6、delete(url, **kwargs)

同requests.delete()方法。

——其他方法

7、options(url, **kwargs)

用于发送HTTP OPTIONS请求。

OPTIONS请求用于获取目标资源的通信选项，例如，服务器支持的HTTP方法、支持的请求头字段等信息。

参数

url -- 请求的目标URL

**kwargs -- 可选的关键字参数

返回类型:requests.Response

例：

import requests

# 创建一个会话对象

session = requests.Session()

# 发送 OPTIONS 请求

response = session.options('https://login.jxemall.com/user-login/#/')

# 输出结果

print(f"Status Code: {response.status_code}")

print(f"Headers: {response.headers}")

输出 ：

Status Code: 200

Headers: {'Allow': 'OPTIONS, GET, HEAD, POST', 'Cache-Control': 'max-age=604800', 'Content-Type': 'text/html; charset=UTF-8', 'Date': 'Sat, 30 Dec 2023 05:04:59 GMT', 'Expires': 'Sat, 06 Jan 2024 05:04:59 GMT', 'Server': 'EOS (vny/044F)', 'Content-Length': '0'}

8、head(url, **kwargs)

HEAD 请求与 GET 请求类似，但是服务器只返回头部信息而不返回实际的资源内容。

这个方法通常用于获取资源的元数据，比如资源的大小、类型或者最后修改时间，而不需要获取整个资源内容。

例：

import requests

url = 'https://login.jxemall.com/user-login/#/login'

with requests.Session() as session:

    response = session.head(url)

    print(response.status_code)

    print(response.headers)

    # 其他处理响应头的操作

9、close()

关闭Session对象，这将关闭底层的TCP连接。

当你使用requests库中的Session对象时，它会在后台维护一个TCP连接，以便在多个请求之间复用。这可以提高性能，因为建立和关闭TCP连接是一个相对昂贵的操作。

需要注意的是，如果你不显式地关闭Session，Python的垃圾回收机制最终会释放相关的资源。但在某些情况下，例如在一个长时间运行的脚本或服务器中，手动关闭Session可能是一个好主意，以确保及时释放资源。

10、get_adapter(url)

用于获取与给定URL相关的适配器。适配器在requests库中是用来处理不同类型的URL和特定协议的类。

当你想获取与特定URL相关的适配器时，你可以使用get_adapter(url)方法。这个方法会返回一个与给定URL匹配的适配器实例，如果没有找到匹配的适配器，则会抛出一个InvalidSchema异常。

为什么需要不同的适配器

不同的适配器可能需要处理不同的底层连接和通信需求。例如，HTTPS需要加密处理，这通常中专门的适配器来处理。通过使用不同的适配器，requests库可以灵活地处理不同类型的连接和协议。

自定义和扩展

requests库允许你自定义或扩展适配器。这意味着你可以为特定的协议或使用场景创建自己的适配器，并通过Session.mount(prefix,adapter)方法将它挂载到会话上。这在处理非标准的HTTP协议或需要特殊处理的请求时非常有用。

例：获取指定网址相关的适配器

import requests  

  

# 创建一个Session对象  

s = requests.Session()  

  

# 获取与URL相关的适配器  

adapter = s.get_adapter('http://example.com')  

  

# 打印适配器的名称  

print(adapter.__class__.__name__) # 输出：HTTPAdapter

相关例1：用Session.adapters属性获取当前会话适配器

import requests

# 创建一个会话

session = requests.Session()

# 获取当前会话的传输适配器

adapter = session.adapters['http://']

# 打印传输适配器的信息

print(adapter)

输出：<requests.adapters.HTTPAdapter object at 0x00000291263B5420>

相关例2：如果你想要为所有的 HTTPS 请求使用一个自定义的适配器，你可以创建一个适配器实例，并将它挂载到 https:// 前缀上。

import requests

session = requests.Session()

adapter = MyCustomAdapter()

session.mount('https://', adapter)

# 现在所有发送到 https:// 的请求都会使用 MyCustomAdapter

response = session.get('https://example.com')

在这个例子中，MyCustomAdapter 需要是一个兼容 requests 库的适配器实现。这种灵活性使得 requests 库非常强大且可定制。

11、mount(prefix, adapter)

自定义的传输适配器。传输适配器负责处理底层的HTTP传输细节，例如连接池、重试机制等。

这个方法的作用是告诉requests库在发送特定前缀的请求时使用指定的适配器。

参数说明

prefix：

一个字符串，指定需要挂载适配器的URL前缀。例如，如果你想为所有以“https://”开头的请求使用自定义适配器，你可以将“https://”作为前缀。

adapter：

一个实现了requests.adapters.BaseAdapter接口的适配器对象。适配器负责实际的请求发送和响应处理。BaseAdapter是适配器需要实现的基本接口，以确保适配器与requests库兼容。

例：

import requests

# 创建一个会话

session = requests.Session()

# 注册自定义的传输适配器

adapter = requests.adapters.HTTPAdapter(max_retries=3)

session.mount('http://', adapter)

session.mount('https://', adapter)

# 使用会话发送请求

url = 'http://www.example.com'

response = session.get(url)

print(response.text)

——预备一个requests请求对象方法

12、merge_environment_settings(url, proxies, stream, verify, cert)

用于将环境相关的设置与请求特定的设置合并，以便发送请求时使用。

参数说明：

url: 请求的目标 URL。这个参数用于在合并设置时考虑 URL 相关的信息。

proxies: 一个字典类型，表示代理服务器的配置。这个参数允许你为请求设置代理服务器。

stream: 一个布尔值，指示请求是否应该以流式方式处理响应内容。

verify: 一个布尔值或字符串。如果是布尔值 True，表示验证 SSL 证书；如果是字符串，表示路径到一个 CA Bundle 文件，用于验证 SSL 证书。

cert: 一个元组，包含 SSL 证书文件和私钥文件的路径。用于客户端的证书验证。

方法作用：

merge_environment_settings 方法用于合并会话级别的环境设置（例如代理，SSL 验证等）和请求特定的设置，以确保在发送请求时使用正确的设置。

它会根据传递的参数（proxies, stream, verify, cert 等）和当前会话级别的设置，生成一个字典，包含了合并后的请求设置信息。这个字典通常用于最终发送请求时，确保使用了正确的环境设置。

返回类型:dict

示例：

import requests

# 创建一个会话对象

session = requests.Session()

# 准备请求的环境设置

url = 'https://api.example.com'

proxies = {

    'http': 'http://user:password@proxy.example.com:8080',

    'https': 'https://user:password@proxy.example.com:8080'

}

stream = True

verify = '/path/to/ca_bundle.pem'

cert = ('/path/to/client_cert.pem', '/path/to/client_key.pem')

# 获取合并后的设置

merged_settings = session.merge_environment_settings(

    url=url,

    proxies=proxies,

    stream=stream,

    verify=verify,

    cert=cert

)

# 使用合并后的设置发送请求

response = session.get(url, **merged_settings)

说明：response = session.get(url, **merged_settings) 其中的**的作用

 在Python中，** 是一种特殊的语法，用于解包字典（Dictionary Unpacking）。在函数调用时，** 允许将字典中的键值对作为参数传递给函数。在你提到的代码中，**merged_settings 就是将 merged_settings 字典中的键值对解包作为关键字参数传递给 session.get 方法。

具体来说，如果 merged_settings 字典包含了类似 {'param1': 'value1', 'param2': 'value2'} 这样的键值对，那么 session.get 方法将会接收到类似 param1='value1', param2='value2' 这样的关键字参数。

这种语法的好处在于，它可以使代码更简洁、可读，而不需要手动一个个地将字典中的值提取出来传递给函数。

13、prepare_request(request)

用于将一个 PreparedRequest 对象准备好，以便发送到服务器。PreparedRequest 是一个表示预备请求的对象，其中包含了所有用于发送请求的信息，如 URL、HTTP 方法、请求头、请求体等。

返回类型:requests.PreparedRequest

示例：

import requests

url = 'https://api.example.com/resource'

headers = {'User-Agent': 'my-app'}

# 创建一个 PreparedRequest 对象

prepped_request = requests.Request('GET', url, headers=headers)

# 创建一个 Session 对象

with requests.Session() as session:

    # 使用 Session 对象的 prepare_request 方法准备请求

    request_to_send = session.prepare_request(prepped_request)

    # 发送请求

    response = session.send(request_to_send)

    # 处理响应

    print(response.status_code)

    print(response.text)

14、send(request, **kwargs)

发送一个预备好的PreparedRequest.示例同prepare_request(request)。

返回类型:requests.Response

——处理重定向相关方法

15、get_redirect_target(resp)

参数为一个response对象，方法返回重定向的URL，如果响应不是重定向，则返回None。

例：

import requests  

  

s = requests.Session()  

  

# 发送一个请求，假设服务器返回一个重定向响应  

resp = s.get('http://example.com')  

  

# 获取原始的重定向目标URL  

original_target = s.get_redirect_target(resp)  

  

# 打印原始的重定向目标URL  

print(original_target)

16、rebuild_auth(prepared_request, response)

主要作用是在发生身份验证失败时重新构建身份验证信息，并且更新 PreparedRequest 对象，以便下一次尝试发送请求时使用新的身份验证信息。

参数说明：

prepared_request: 要重新构建身份验证信息的 PreparedRequest 对象。

response: 上一次请求的响应对象，用于获取有关身份验证失败的详细信息。

主要作用：

身份验证重建: 当发生身份验证失败（例如 401 Unauthorized）时，rebuild_auth 方法用于重新构建身份验证信息。

更新 PreparedRequest: 重新构建身份验证信息后，PreparedRequest 对象会被更新，以便包含新的身份验证信息。

重新发送请求: 重新构建身份验证信息后，你可以使用 Session 对象的 send 方法重新发送请求，以尝试使用新的身份验证信息获取授权。

请注意，这个方法通常在发生身份验证失败时才会用到。在正常情况下，Session 对象会自动处理身份验证，无需手动调用 rebuild_auth 方法。

示例：

import requests

from requests.auth import HTTPBasicAuth

url = 'https://api.example.com/resource'

username = 'your_username'

password = 'your_password'

# 创建一个 Session 对象

with requests.Session() as session:

    # 创建一个 PreparedRequest 对象

    prepped_request = requests.Request('GET', url)

    # 添加 HTTP 基本身份验证信息到 PreparedRequest

    prepped_request = prepped_request.prepare()

    prepped_request.auth = HTTPBasicAuth(username, password)

    try:

        # 发送请求

        response = session.send(prepped_request)

        # 处理响应

        print(response.status_code)

        print(response.text)

    except requests.exceptions.HTTPError as e:

        # 如果身份验证失败，重新构建身份验证信息

        if e.response.status_code == 401:

            session.rebuild_auth(prepped_request, e.response)

            # 重新发送请求

            response = session.send(prepped_request)

            print(response.status_code)

            print(response.text)

17、rebuild_method(prepared_request, response)

用于在遇到 HTTP 重定向时重新构建请求的 HTTP 方法。

18、rebuild_proxies(prepared_request, proxies)

 在 requests 库的 Session 对象中，rebuild_proxies(prepared_request, proxies) 方法的主要作用是在发生重定向时重新构建代理信息，以便在重定向请求中使用新的代理。

返回类型:dict

19、resolve_redirects(resp, req, stream=False, timeout=None, verify=True, cert=None, proxies=None, yield_requests=False, **adapter_kwargs)

用于处理重定向链并返回所有请求的响应对象。这个方法主要用于实现自定义的重定向逻辑。

参数说明：

resp: 第一个请求的响应对象，通常是初始请求的响应。

req: 初始请求对象。

stream: 是否使用流式传输，默认为 False。

timeout: 超时时间，默认为 None。

verify: 是否进行 SSL 证书验证，默认为 True。

cert: 客户端证书，默认为 None。

proxies: 代理设置，可以是字典或者 False，默认为 None。

yield_requests: 是否返回请求对象列表，默认为 False。

adapter_kwargs: 传递给适配器的其他参数。

返回值：

如果 yield_requests 为 False，返回包含所有响应对象的列表。

如果 yield_requests 为 True，返回包含所有请求对象和响应对象元组的列表。

主要作用：

处理重定向链: 该方法会根据重定向链依次发送请求，并返回每个请求的响应对象。可以用于手动处理重定向逻辑。

返回请求对象列表（可选）: 如果设置 yield_requests 为 True，方法还会返回每个请求对象和响应对象的元组列表，方便在处理逻辑中获取请求对象的详细信息。

参数

1、auth = None

类型：requests.auth.AuthBase 类的实例或 None。

用途：指定请求时要使用的认证信息。可以是 requests.auth.HTTPBasicAuth、requests.auth.HTTPDigestAuth 等认证类的实例。

2、cert = None

类型：元组 (cert, key) 或字符串。

用途：指定用于 SSL 客户端认证的证书文件和私钥文件。例如，('/path/to/client_cert.pem', '/path/to/client_key.pem')。

3、cookies = None

类型：http.cookiejar.CookieJar 对象或字典。

用途：指定会话使用的初始 Cookies。可以是 http.cookiejar.CookieJar 类的实例，也可以是字典形式的 Cookies。

4、headers = None

类型：字典。

用途：指定会话的默认请求头信息。可以在创建会话后使用 session.headers 进一步修改。

5、hooks = None

钩子函数

类型：字典。

用途：指定在请求的不同阶段触发的钩子函数。例如，可以使用 'response' 钩子在收到响应后执行自定义操作。

例：

import requests

# 创建一个会话对象

session = requests.Session()

# 定义一个回调函数

def my_hook(response, *args, **kwargs):

    print("My custom hook!")

# 注册回调函数到 'response' 事件

session.hooks['response'].append(my_hook)

# 发送请求

response = session.get('https://httpbin.org/get')

6、max_redirects = None

用于设置或获取 Session 对象的最大重定向次数。

默认情况下，max_redirects 的值是 30，即 Session 对象默认允许最多 30 次重定向。你可以根据实际需求设置不同的值，或者将其设置为 None，表示无限制地允许重定向。

请注意，在实际应用中，设置过大的最大重定向次数可能导致无限循环的问题，因此建议谨慎设置。默认情况下，requests 库提供了合理的默认值。

类型：整数。

用途：指定在发生重定向时最多允许的重定向次数。默认为 30。

例：

import requests

with requests.Session() as session:

# 获取当前最大重定向

    max_redirects = session.max_redirects

    print(f"Current max redirects: {max_redirects}") # 输出：Current max redirects: 30

# 设置最大重定向次数为5

session.max_redirects = 5

# 无限制地允许重定向

session.max_redirects = None

7、params = None

用于设置或获取在请求中包含的查询字符串参数。这个属性允许你在 Session 对象级别上设置默认的查询字符串参数，这些参数将在发送请求时自动包含在 URL 中。

params（URL 参数）：

类型：字典。

用途：指定会话中所有请求的默认 URL 参数。这些参数将被添加到每个请求的 URL 中。

例：

import requests

with requests.Session() as session:

    current_params = session.params

# 获取当前查询字符串参数

    print(f"Current params: {current_params}") # 输出：{}

# 设置查询字符串参数

# 这些参数会在发送请求时自动添加到 URL 中。

session.params = {'param1': 'value1', 'param2': 'value2'}

# 发送请求时，在请求级别上覆盖部分查询字符串参数

response = session.get('http://example.com', params={'param2': 'new_value'})

在这个例子中，param2 在请求级别上被覆盖为新的值，而 param1 仍然使用 Session 级别的默认值。

8、proxies = None

proxies属性允许你为会话设置代理，以便在请求中使用代理服务器。

例：

import requests

# 创建一个会话

session = requests.Session()

# 配置代理

proxies = {

    'http': 'http://your_http_proxy',

    'https': 'http://your_https_proxy',

}

# 将代理配置应用于会话

session.proxies = proxies

# 现在，session将使用指定的代理发送请求

response = session.get('http://www.example.com')

print(response.text)

值得注意的是，requests库的Session对象中的proxies属性是一个字典，用于配置不同协议（如http和https）的代理。如果你只需要为所有协议配置相同的代理，可以简化为一个代理URL，而无需使用字典。例如：

# 配置统一的代理

proxy_url = 'http://your_proxy'

9、stream = None

stream属性是一个布尔值（默认为False），用于指示是否启用流式传输。当stream属性设置为True时，requests会尝试下载大文件或流式传输数据而不一次性将整个响应内容加载到内存中。这对于处理大文件或通过网络流式传输数据时非常有用，因为它可以节省内存并提高性能。

示例：

import requests

# 创建一个会话

session = requests.Session()

# 发送带有流式传输的GET请求

url = 'http://www.example.com/large_file.zip'

response = session.get(url, stream=True)

# 检查响应状态码

if response.status_code == 200:

    # 打开文件并逐块写入

    with open('large_file.zip', 'wb') as file:

        for chunk in response.iter_content(chunk_size=128):

            file.write(chunk)

    print('下载完成')

else:

    print('下载失败，状态码:', response.status_code)

10、trust_env = None

它是一个布尔值，用于指示是否信任系统环境变量。当trust_env为True时，requests会从系统环境变量中获取代理配置、SSL证书等信息，以及其他与网络请求相关的配置。

默认情况下，trust_env属性是True，这意味着requests库将自动检测和使用系统环境变量中的配置。如果你希望手动配置代理、SSL证书等，可以将trust_env属性设置为False，然后通过Session对象的其他属性手动配置这些信息。

例：

import requests

# 创建一个不信任系统环境变量的会话

session = requests.Session()

session.trust_env = False

# 手动配置代理

proxies = {

    'http': 'http://your_http_proxy',

    'https': 'http://your_https_proxy',

}

session.proxies = proxies

# 发送带有代理的GET请求

url = 'http://www.example.com'

response = session.get(url)

print(response.text)

11、verify = None

它用于指定是否验证服务器的SSL证书。SSL证书用于确保你与服务器之间的通信是加密的，防止中间人攻击等安全问题。默认情况下，verify属性是True，表示requests库会验证服务器的SSL证书。

如果你不想验证SSL证书，可以将verify属性设置为False。这在一些特殊情况下可能会用到，但要注意，禁用SSL证书验证可能会带来安全风险，因为它使你容易受到中间人攻击。

例：

import requests

# 创建一个会话并禁用SSL证书验证

session = requests.Session()

session.verify = False

# 发送不验证SSL证书的GET请求

url = 'https://www.example.com'

response = session.get(url)

print(response.text)