Python第三方requests库Response对象详解（4/6）

Response对象

requests.Response

用于表示从远程服务器收到的响应。

当你用request.get()、requests.post()等HTTP请求时，这些方法会返回一个Response对象，该对象包含了服务器返回的所有信息。

Response对象方法

1、json(**kwargs)

用于解析响应内容为JSON格式的方法。

它将响应内容解析为Python字典或列表，具体的数据结构取决于JSON内容的格式。

该方法的参数 **kwargs 允许你传递额外的参数，这些参数会传递给 json.loads() 函数，用于自定义 JSON 解析过程。这包括但不限于：

encoding: 指定 JSON 字符串的编码。默认为 None，表示自动检测编码。

cls: 用于指定一个自定义的 JSON 解码器类。

object_hook: 如果提供，它将被用于将 JSON 对象转换为 Python 对象。

parse_float, parse_int, parse_constant: 用于指定如何处理 JSON 中的浮点数、整数和特殊常量。

引发：如果响应内容不包含json格式内容将引发ValueError错误.

例：

import requests

url = 'https://jsonplaceholder.typicode.com/todos/1'

response = requests.get(url)

# 解析响应内容为 JSON

json_data = response.json()

# 输出解析后的数据

print("JSON Data:")

print(json_data)

# 获取特定键的值

title = json_data.get('title', 'N/A')

print("Title:", title)

输出：

JSON Data:

{'userId': 1, 'id': 1, 'title': 'delectus aut autem', 'completed': False}

Title: delectus aut autem

在这个例子中，response.json()方法将响应内容解析为JSON格式，返回一个对应的Python字典。然后，可以通过字典操作获取特定键的值。

请注意，如果响应的内容不是合法的JSON格式（必须整个response内容都是json格式），或者无法解析为字典或列表，response.json()方法可能会抛出json.JSONDecodeError异常。

2、iter_content(chunk_size=1, decode_unicode=False)

用于逐块迭代响应内容的方法。这个方法适用于处理大型响应内容，例如下载文件时。

当在请求上设置stream=True时，这可以防止内容一次性读取到内存中。

参数：

chunk_size：这个参数定义了每次迭代返回的数据块的大小（以字节为单位）。设置较小的chunk_size可以有效地处理大型文件，因为它允许你逐步加载文件而不会一次性加载整个文件到内存中。

decode_unicode：这个参数用于控制是否对字节数据进行解码成Unicode。如果设置为False，返回的数据将是原始的字节数据；如果设置为True，则requests将尝试将字节数据解码成Unicode。

示例：

import requests

url = ' https://tms.cheoa.cn/assets/images/login_bg_small.jpeg'

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

# 按块迭代响应内容

chunk_size = 1024  # 1KB

for chunk in response.iter_content(chunk_size=chunk_size, decode_unicode=False):

    # 处理每个数据块，这里只是简单地输出块大小

    print(f"Received chunk of size {len(chunk)} bytes")

# 关闭连接

response.close()

输出：

Received chunk of size 1024 bytes

Received chunk of size 1024 bytes

...略

Received chunk of size 1024 bytes

Received chunk of size 305 bytes

3、iter_lines(chunk_size=512, decode_unicode=None, delimiter=None)

用于按行迭代响应内容。

这个方法适用于处理文本响应，允许你逐行处理响应内容，而不必将整个响应加载到内存中。

当在请求上设置stream=True时，这可以防止内容一次性读取到内存中。

参数：

chunk_size: 这个参数定义了每次迭代返回的数据块的大小（以字节为单位）。设置较小的 chunk_size 可以有效地处理大型文本响应，因为它允许你逐步加载内容而不会一次性加载整个响应到内存中。

decode_unicode: 这个参数用于控制是否对字节数据进行解码成 Unicode。如果设置为 False，返回的数据将是原始的字节数据；如果设置为 True，则 requests 将尝试将字节数据解码成 Unicode。如果设置为 None（默认值），requests 将根据响应头中的编码信息自动解码。

delimiter: 这个参数用于指定行的分隔符。如果不提供分隔符，iter_lines 将使用默认的分隔符，即 '\n'。

注解

This method is not reentrant safe.

示例：

import requests

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

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

# 按行迭代响应内容

for line in response.iter_lines(chunk_size=512, decode_unicode=True):

    # 处理每行数据，这里只是简单地输出每行内容

    print(line)

# 关闭连接

response.close()

4、close()

用于关闭与响应相关的资源，例如网络连接（大多数情况下，不需要手动调用此方法）。

在requests库中，当你发送一个请求并收到响应后，Response对象会保持与服务器的连接打开，以便你能够获取响应的内容、头信息等。

通常情况下，requests库会在你访问Response对象的某些属性（如text、content）时自动调用close()方法。然而，为了确保及时释放资源，你也可以手动调用close()。

5、raise_for_status()

用于在发生HTTP错误时引发异常的方法。

它检查响应的状态码，如果状态码表明请求不成功（即在范围400到599之间），则引发requests.exceptions.HTTPError异常。

这个方法通常用于在发送请求后检查响应的状态，以确保请求成功完成。

例：

import requests

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

response = requests.get(url)

try:

    response.raise_for_status()

    print("Request was successful!")

    # 处理响应内容...

except requests.exceptions.HTTPError as err:

    print(f"HTTP error occurred: {err}")

    # 处理HTTP错误...

输出：

HTTP error occurred: 404 Client Error: Not Found for url: https://www.example.com/nonexistent_page

Response对象属性

Response对象属性主要包括4方面：

1、用不同形式获取响应信息：

        content（以字节形式提供响应体的二进制内容）

        raw（以未解码的原始二进制形式返回响应信息）

        text（以字符串形式返回响应信息）

2、获取或指定当前解码方式：encoding、rent_encoding

3、获取重定向相关：history、is_redirect、is_permanent_redirect、next、url

4、获取其他信息：headers、cookies、request、elapsed、links

——使用不同形式返回响应内容

1、content

返回：

content属性返回响应体的二进制内容，以字节形式提供。

会自动解码响应内容，尝试将字节转换为字符串，但这不一定是适当的，特别是在处理非文本文件时。

适用于获取二进制数据，例如图像、音频文件等。

适用场景：

当你需要处理二进制数据，如下载文件、图像等时，使用response.content是必要的，因为这可以确保你得到的是原始的、未经修改的数据。

例：使用content属性保存图片

import requests

from pathlib import Path

url = 'https://tms.cheoa.cn/assets/images/login_bg_small.jpeg'

response = requests.get(url)

# 检查请求是否成功

if response.status_code == 200:

    # 获取图片的二进制数据

    image_data = response.content

    

    # 保存图片到桌面

    desktop_path = Path.home() / 'Desktop'

    image_path = desktop_path / 'downloaded_image.jpg'

    with open(image_path, 'wb') as image_file:

        image_file.write(image_data)

    print(f'Image saved to: {image_path}')

else:

    print(f'Failed to download the image. Status code: {response.status_code}')

2、text

用于获取HTTP响应内容的文本形式，通常是字符串。

Response.text属性会根据服务器响应的字符集编码格式解码（如Content-Type：application/json;charset=UTF-8），若服务器未返回字符编码格式，则text属性会根据内容自动判断编码格式再进行解码。若你知道准确的编码格式应在调用text属性前先指定编码格式。

文本内容：

如果服务器返回的内容是文本（比如 HTML 页面、JSON 数据等），Response.text 将直接返回这些文本。

自动解码：

Response.text 会自动使用响应头中的字符集信息进行解码，尽可能地将响应内容解析成 Unicode 字符串。

处理非文本内容：

如果响应内容是二进制数据（比如图片、音频文件等），那么可以使用 Response.content 属性来获取二进制内容。

例：

import requests

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

response = requests.get(url)

# 使用 Response.text 获取文本内容

content_text = response.text

# 获取Content-Type属性

content_type = response.headers.get("Content-Type")

print(f"text:\n{content_text}")

print(f"状态码为: {response.status_code}")

print(f"响应编码格式为：{content_type}")

输出：

text:

<!doctype html>

<html>...略

状态码为: 200

响应编码格式为：text/html; charset=UTF-8

3、raw = None

使用raw需要在请求中设置stream=True。

Response对象的raw属性是一个io.BytesIO对象，它表示原始的HTTP响应体，以二进制形式提供。你可以使用它来逐块处理响应数据，通常用于处理大型文件或流数据。

content与raw属性对比：

content属性会自动解码响应内容，尝试将字节转换为字符串，但这不一定是适当的，特别是在处理非文本文件时，Response.raw不会自动解码响应内容，因此你需要手动处理或保存数据。

Response.content适用于文本或小型二进制数据，而Response.raw适用于大型二进制数据或需要逐块处理的场景。

例：使用raw保存图片

import requests

from pathlib import Path

url = 'https://tms.cheoa.cn/assets/images/login_bg_small.jpeg'

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

# 检查请求是否成功

if response.status_code == 200:

    # 获取图片的原始响应数据

    image_raw = response.raw

    

    # 保存图片到桌面

    desktop_path = Path.home() / 'Desktop'

    image_path = desktop_path / 'downloaded_image.jpg'

    with open(image_path, 'wb') as image_file:

        # 逐块写入图片数据

        for chunk in image_raw:

            image_file.write(chunk)

    print(f'Image saved to: {image_path}')

else:

    print(f'Failed to download the image. Status code: {response.status_code}')

例2：输出raw原始信息

import requests

response = requests.get("https://tms.cheoa.cn/assets/images/login_bg_small.jpeg", stream=True) # 下载图片

raw_data = response.raw.read()

# 输出原始二进制内容

print(response.content) # 输出：b'\xff\xd8\xff\xe1\x...略

注：此时若访问content和text属性都会输出空字符串。

——获取或设置编码方式

4、apparent_encoding

返回Response对象内容的字符编码。

使用chardet库来对响应内容进行猜测，它会分析响应内容的字节流，并尝试确定最可能的字符编码，这个方法通常能够提供相当准确的猜测，但并不能保证100%的准确性。

5、encoding = None

用于指示或获取响应内容的字符编码方式。

当你从服务器收到一个响应时，Response.encoding通常会根据响应的内容类型（比如Content-Type头部中的信息）自动设置为相应的字符编码。它告诉requests库在将响应内容解码为字符串时应该使用哪种字符编码。

通常情况下，如果服务器在响应中指定了字符编码方式（比如charset=utf-8），requests库 会根据这个指定的编码方式自动设置Response.encoding。如果没有指定字符编码，requests库则会尝试根据响应内容自动猜测编码，这可能不总是准确。

注意：

修改Response.encoding并不会重新解码已经接收到的响应内容。这个属性只影响后续对响应内容的解码。

例：

import requests

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

response = requests.get(url)

# 获取响应的字符编码

encoding = response.encoding

# 打印编码信息

print("Encoding:", encoding) # 输出：UTF-8

# 手动设置编码方式

response.encoding = 'utf-8'

——响应状态码相关属性

6、status_code = None

用于获取HTTP响应的状态码。HTTP状态码是服务器对请求的响应的一部分，提供了关于请求处理结果的信息。

状态码是一个整数数值

状态码：

1xx（Informational）： 接收的请求正在处理。

2xx（Successful）： 请求已成功被服务器接收、理解、并接受。

3xx（Redirection）： 需要后续操作才能完成这一请求。

4xx（Client Error）： 请求包含语法错误或无法完成请求。

5xx（Server Error）： 服务器在尝试处理请求时发生错误。

具体的状态码和其含义可以在HTTP协议规范中找到。一般来说，状态码以2开头表示成功，以4开头表示客户端错误，以5开头表示服务器错误。

示例：

import requests

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

response = requests.get(url)

print(f'Status Code: {response.status_code}') # 输出：Status Code: 200

7、reason = None

表示HTTP状态码的原因短语。

如，对于HTTP状态码200，其原因短语可能是"OK"。对于HTTP状态码404，原因短语可能是"Not Found"。

例：

import requests

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

response = requests.get(url)

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

print(f'Reason Phrase: {response.reason}')

输出：

Status Code: 200

Reason Phrase: OK

8、ok

如果status_code小于400，则返回True。

该属性检查响应的状态码是否在400和600之间，以查看是否存在客户端错误或服务器错误。如果状态码在200和400之间，则返回True。这不是一个检查，以查看响应码是否为200。

例：

import requests

url = 'https://yiyan.baidu.com/'

res = requests.get(url)

print(res.ok) # 输出：True

——获取重定向信息相关属性

9、history = None

属性包含了一个Response对象列表，这些对象代表了HTTP请求的重定向历史。

如果一个请求经历了一个或多个重定向，那么Response.history将包含每个重定向的响应，而最终的响应则Response对象本身。

每个重定向响应都是一个完整的Response对象，它包含了重定向请求的状态码、头部信息、内容等。

10、is_redirect

用于判断当前的HTTP响应是否是一个重定向响应。如果响应是重定向，is_redirect将返回True，否则返回False。

请注意：is_redirect属性仅检查响应的状态码是否是重定向相关的状态码之一（例如301、302、303、307、308），但不会执行实际的重定向。如果需要查看重定向的历史记录或处理重定向，请使用Response.history属性和allow_redirects=True选项。

例：

import requests

# 发送一个可能会重定向的请求

response = requests.get('http://example.com', allow_redirects=False)

# 检查是否是重定向

if response.is_redirect:

    print("The response is a redirect.")

else:

    print("The response is not a redirect.")

# 输出响应状态码

print("Status code:", response.status_code)

输出 ：The response is not a redirect.

Status code: 200

11、is_permanent_redirect

该属性用于检查HTTP响应是否表示一个永久重定向。

永久重定向通常使用HTTP状态码301 Moved Permanently来指示客户端所请求的资源已经被永久移动到了一个新的位置。当服务器返回状态码301时，客户端会被指示去访问一个新的URL，并且以后应该直接使用这个新的URL来访问相同的资源。

永久重定向通常用于指示一个资源被永久性地移动到了另一个位置，而客户端在接收到这个状态码后，会自动将该URL缓存，并在未来的请求中直接使用新的URL，从而避免再次请求旧的URL。这有助于搜索引擎等服务来更新其索引，将旧的URL替换为新的URL，以确保用户访问到最新的资源。

永久重定向的状态码是301，它与临时重定向的状态码302 Found有所不同。302状态码表示资源被暂时移动，客户端在接收到该状态码后会在以后的请求中继续使用原始URL。

例：

import requests

# 发送一个可能会进行永久重定向的请求

response = requests.get('http://example.com', allow_redirects=False)

# 检查是否是永久重定向

if response.is_permanent_redirect:

    print("The response is a permanent redirect (status code 301).")

else:

    print("The response is not a permanent redirect.")

# 输出响应状态码

print("Status code:", response.status_code)

在这个例子中，allow_redirects=False参数用于禁止requests库自动处理重定向，这样我们可以检查Response对象的属性来确定是否是永久重定向。

12、next

返回一个PreparedRequest，用于重定向链中的下一个请求(如果有重定向链的话)。

13、url = None

用于获取实际获取响应的URL。这个属性是一个字符串，表示最终响应所在的URL，可能会有重定向导致实际的URL与最初请求的URL不同。

示例：

import requests

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

response = requests.get(url)

# 获取实际响应的URL

actual_url = response.url

# 打印实际URL

print(f'Actual URL: {actual_url}')

输出：Actual URL: https://www.example.com/

——获取其他信息属性

14、headers = None

用于访问HTTP响应的头部信息。返回的headers是一个字典对象。

注意：

Response.headers返回的是不区分大小写的字典，这意味着大小写不敏感。这是为了方便使用，因为HTTP头部字段在规范中是不区分大小写的。

例：

import requests

# 发送HTTP GET请求

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

# 获取响应头部信息

headers = response.headers

# 输出所有响应头

print(headers)

# 获取特定头部信息

content_type = headers.get('content-type')

server = headers.get('server')

# 输出特定头部信息

print(f'Content-Type: {content_type}')

print(f'Server: {server}')

输出：

{'Content-Encoding': 'gzip',......略

Content-Type: text/html; charset=UTF-8

15、cookies = None

Response.cookies返回的是一个RequestsCookieJar对象，它可以被转化为字典，也可以按照需要进行其他处理。

当第一个请求获取了服务器的响应后，可以通过response.cookies获取返回的Cookie信息，然后在第二个请求中，我们可以使用这些Cookie信息作为参考传递给requests.get函数，以在后续请求中保持会话状态。

例如，可以使用dict()函数将RequestsCookieJar对象转换为字典：

cookies_dict = dict(response.cookies)

print("Cookies as dictionary:", cookies_dict)

例：

import requests

url = 'https://example.com'

response = requests.get(url)

# 使用前面获得的Cookie

cookies = response.cookies

# 添加新的Cookie值对

cookies.update({'session_id': '123456'})

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

url2 = 'https://example.com/some_endpoint'

response2 = requests.get(url2, headers=headers, cookies=cookies)

16、request = None

Response对象的request属性是一个指向生成当前响应的请求的PreparedRequest对象的引用。PreparedRequest对象包含有关原始请求的所有信息，包括请求方法、URL、标头、正文等。

示例：

import requests

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

response = requests.get(url)

# 获取原始请求的方法

request_method = response.request.method

# 获取原始请求的URL

request_url = response.request.url

# 获取原始请求的标头

request_headers = response.request.headers

# 获取原始请求的正文

request_body = response.request.body

# 打印相关信息

print(f'Request Method: {request_method}')

print(f'Request URL: {request_url}')

print(f'Request Headers: {request_headers}')

print(f'Request Body: {request_body}')

输出：

Request Method: GET

Request URL: https://www.example.com/

Request Headers: {'User-Agent': 'python-requests/2.31.0', 'Accept-Encoding': 'gzip, deflate, br, zstd', 'Accept': '*/*', 'Connection': 'keep-alive'}

Request Body: None

17、elapsed = None

用于获取从发送请求到接收响应所经过的时间。它返回一个timedelta对象。

从发送第一个字节到完成解析头信息。

在一些情况下 ，你可能更关心的是elspsed_time.total_seconds()，以获取总秒数。这对于监控请求的性能或确定请求是否符合预期的时间范围非常有用。

例：

import requests

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

response = requests.get(url)

# 获取请求的响应时间

elapsed_time = response.elapsed

# 打印响应时间信息

print("Response time:", elapsed_time)

print("Seconds:", elapsed_time.seconds)

print("Microseconds:", elapsed_time.microseconds)

输出：

Response time: 0:00:00.886308

Seconds: 0

Microseconds: 886308

18、links

Response.links 是 requests 库中用于获取响应中包含的链接头（Link Header）信息的属性。Link头是HTTP标头的扩展，通常用于指定资源之间的关系，如指向其他资源的链接、预加载资源等。

Response.links 返回一个字典，包含了响应中所有解析的链接头。每个链接头的关系类型（如 "next"、"prev"、"alternate" 等）都作为键，相应的链接信息则作为值。值是一个字典，其中包含链接的URL以及可能存在的其他参数，例如 rel 表示关系类型，url 表示链接的URL。

例：

import requests

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

response = requests.get(url)

if 'link' in response.headers:

    links = response.links

    # 打印链接头信息

    for rel, link in links.items():

        print(f"Relation Type: {rel}")

        print(f"URL: {link['url']}")

        print(f"Rel Attribute: {link['rel']}")

        print("---")

else:

    print("No 'Link' header found in the response.")