python---aiohttp库

python—aiohttp库

1. 什么事aiohttp

官方网址：https://docs.aiohttp.org/en/stable/

用于asyncio和Python的异步HTTP客户端/服务器

2. 安装

pip install aiohttp

3. ClientSession()

Session封装了一个连接池（connector instance），默认支持keepalives。除非您在应用程序的生命周期内连接到大量未知数量的不同服务器，否则建议您在应用程序的生命周期内使用单个会话以从连接池中受益。

官网：https://docs.aiohttp.org/en/stable/client_reference.html#aiohttp.ClientSession

尝试获取一个网页。例如: 查询 http://httpbin.org/get：

import aiohttp
import asyncio

async def main():
    async with aiohttp.ClientSession() as session:
        async with session.get('http://httpbin.org/get') as resp:
            print(resp.status)
            print(await resp.text())

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

"""
输出结果:
200
{
  "args": {}, 
  "headers": {
    "Accept": "*/*", 
    "Accept-Encoding": "gzip, deflate", 
    "Host": "httpbin.org", 
    "User-Agent": "Python/3.9 aiohttp/3.7.4.post0", 
    "X-Amzn-Trace-Id": "Root=1-60cc4c30-434e940475efbdd66ca265fd"
  }, 
  "origin": "117.39.38.140", 
  "url": "http://httpbin.org/get"
}
"""

import aiohttp
import asyncio

async def fetch(client):
    async with client.get('http://python.org') as resp:
        assert resp.status == 200
        return await resp.text()

async def main():
    async with aiohttp.ClientSession() as client:
        html = await fetch(client)
        print(html)

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

现在， 我们有一个名为session的ClientSession和一个名为resp的ClientResponse对象。 我们可以从响应中获取我们需要的所有信息。ClientSession.get() ，coroutine的强制参数 是一个 HTTP url（str或 class: yarl.URL实例）。

发送 post 请求，可以使用ClientSession.post()协程：

session.post('http://httpbin.org/post', data=b'data')

其他 HTTP 方法也可用：

session.put('http://httpbin.org/put', data=b'data')
session.delete('http://httpbin.org/delete')
session.head('http://httpbin.org/get')
session.options('http://httpbin.org/get')
session.patch('http://httpbin.org/patch', data=b'data')

注意：

不要为每个请求创建一个会话。很可能您需要每个应用程序一个会话来执行所有请求。

更复杂的情况可能需要每个站点一个会话，例如一个用于 Github，另一个用于 Facebook API。无论如何，为每个请求创建一个会话是一个非常糟糕的主意。

一个会话内部包含一个连接池。连接重用和保持连接（默认情况下均处于启用状态）可能会提高总体性能。

会话上下文管理器的使用不是强制性的，但是在这种情况下应该调用 await session.close() 方法，

例如:

session = aiohttp.ClientSession()
async with session.get('...'):
    # ...
await session.close()

3.1 ClientSession() 参数

aiohttp.ClientSession(
    *, connector=None, loop=None, cookies=None,
    headers=None, skip_auto_headers=None, auth=None, 
    json_serialize=json.dumps, version=aiohttp.HttpVersion11, 
    cookie_jar=None, read_timeout=None, conn_timeout=None, 
    timeout=sentinel, raise_for_status=False, connector_owner=True, 
    auto_decompress=True, read_bufsize=2 ** 16, requote_redirect_url=False, 
    trust_env=False, trace_configs=None)

3.2 客户端超时

默认情况下，aiohttp 使用总共300 秒（5 分钟）的超时时间，这意味着整个操作应该在 5 分钟内完成。

该值可以被会话的超时参数覆盖（以秒为单位）：

timeout = aiohttp.ClientTimeout(total=60)
async with aiohttp.ClientSession(timeout=timeout) as session:
    ...

对于像这样的请求，超时可以被覆盖 ClientSession.get()：

async with session.get(url, timeout=timeout) as resp:
    ...

• aiohttp.ClientTimeout( * , total = None , connect = None , sock_connect = None , sock_read = None )

  客户端超时设置的数据类。有关使用示例，请参阅超时。

  • total 整个请求的总秒数。float，None默认。

  • connect 从池中获取连接的最大秒数。时间包括为新连接建立连接或在超过池连接限制时等待池中的空闲连接。对于纯套接字连接建立时间使用 sock_connect.float，None默认。

  • sock_connect连接到新连接的对等点的最大秒数，不是从池中给出的。另见connect。float，None默认。

  • sock_read从对等方读取部分数据的最大秒数。float，None默认。

3.3 连接器

连接器是 aiohttp 客户端 API 的传输

TCPConnector用于常规TCP 套接字（支持HTTP和 HTTPS方案）。

class aiohttp.TCPConnector(*, ssl=None, verify_ssl=True, fingerprint=None, use_dns_cache=True, ttl_dns_cache=10, family=0, ssl_context=None, local_addr=None, resolver=None, keepalive_timeout=sentinel, force_close=False, limit=100, limit_per_host=0, enable_cleanup_closed=False, loop=None)

用于通过TCP套接字处理HTTP和HTTPS 的连接器。

最常见的交通工具。当您不知道要使用哪种连接器类型时，请使用TCPConnector实例。

TCPConnector继承自BaseConnector.

param ssl:
SSL 验证模式. None 用于默认SSL检查
(ssl.create_default_context() ), False用于跳过 SSL 证书验证， aiohttp.Fingerprint用于指纹验证，ssl.SSLContext用于自定义 SSL 证书验证。取代verify_ssl、ssl_context和 指纹参数。

Parameters:
verify_ssl (bool) –对HTTPS请求执行 SSL 证书验证 （默认启用）。可能会被禁用以跳过对具有无效证书的站点的验证,2.3 版后已弃用：将verify_ssl传递给ClientSession.get()等。

limit (int) – 同时连接的总数。如果limit是 None连接器没有限制（默认值：100）。

force_close (bool) – 在连接释放后关闭底层套接字（可选）。

用法：

connector = aiohttp.TCPConnector(limit=50)
async with aiohttp.ClientSession(connector=connector) as session:
    ...

4. 请求方法参数

4.1 url传参

您通常希望在 URL 的查询字符串中发送某种数据。如果您手动构建 URL，则此数据将作为 URL 中问号后的键/值对给出，例如httpbin.org/get?key=val. Requests 允许您dict使用 params关键字参数将这些参数作为 提供。例如，如果您想传递 key1=value1和key2=value2到httpbin.org/get，您可以使用以下代码：

params = {'key1': 'value1', 'key2': 'value2'}
async with session.get('http://httpbin.org/get',
                       params=params) as resp:
    expect = 'http://httpbin.org/get?key1=value1&key2=value2'
    assert str(resp.url) == expect

注意：

在发送请求之前，aiohttp内部执行URL规范化。

规范化通过IDNA编解码器对主机部分进行编码，并对路径和查询部分应用重请求。

例如URL('http://example.com/путь/%30?a=%31') 转换为 URL('http://example.com/%D0%BF%D1%83%D1%82%D1%8C/0?a=1').

如果服务器接受精确表示并且不重新引用 URL 本身，则有时规范化是不可取的。

要禁用规范化，请使用 encoded=True URL 构造参数：

await session.get(
 URL('http://example.com/%30', encoded=True))

4.2 响应内容和状态码

我们可以读取服务器响应的内容及其状态码。再次考虑 GitHub 时间线：

async with session.get('https://api.github.com/events') as resp:
    print(resp.status)
    print(await resp.text())

打印出类似的东西：

200
'[{"created_at":"2015-06-12T14:06:22Z","public":true,"actor":{...

aiohttp自动解码来自服务器的内容。您可以为该text()方法指定自定义编码：

await resp.text(encoding='windows-1251')

4.3 二进制响应内容

对于非文本请求，您还可以以字节形式访问响应正文：

print(await resp.read())
b'[{"created_at":"2015-06-12T14:06:22Z","public":true,"actor":{...

gzip和deflate传输编码会自动为您解码。

您可以启用brotli传输编码支持，只需安装 brotlipy。

4.4 JSON 请求

所有的会话的请求方法，如request()， ClientSession.get()，ClientSesssion.post()等接受 JSON参数：

async with aiohttp.ClientSession() as session:
    async with session.post(url, json={'test': 'object'})

默认情况下，会话使用 python 的标准json模块进行序列化。但是可以使用不同的 serializer. ClientSession接受json_serialize 参数：

import ujson

async with aiohttp.ClientSession(
        json_serialize=ujson.dumps) as session:
    await session.post(url, json={'test': 'object'})

4.5 JSON 响应内容

还有一个内置的 JSON 解码器，以防您处理 JSON 数据：

async with session.get('https://api.github.com/events') as resp:
    print(await resp.json())

如果 JSON 解码失败，json()将引发异常。可以为json()调用指定自定义编码和解码器功能。

注意：

上述方法将整个响应体读入内存。如果您计划读取大量数据，请考虑使用下面记录的流式响应方法

官网：https://docs.aiohttp.org/en/stable/client_quickstart.html

5. 客户端代码示例：

import aiohttp
import asyncio

async def main():
    async with aiohttp.ClientSession() as session:
        async with session.get('http://python.org') as response:

            print("Status:", response.status)
            print("Content-type:", response.headers['content-type'])

            html= await response.text()
            print("Body:", html[:15], "...")

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

"""
输出结果:
Status: 200
Content-type: text/html; charset=utf-8
Body: <!doctype html> ...
"""

6. aiohttp 请求生命周期

为什么 aiohttp 客户端 API 是这样的？

第一次使用 aiohttp 时，会发现执行一个简单的 HTTP 请求不是一个步骤，而是最多三个步骤：

async with aiohttp.ClientSession() as session:
    async with session.get('http://python.org') as response:
        print(await response.text())

当看其他库（例如非常流行的requests，其中“hello world”如下所示）时，发现很简单便捷：

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

1）那么为什么 aiohttp 片段如此冗长呢？

由于 aiohttp 是异步的，因此其 API 旨在充分利用非阻塞网络操作。在这样的代码中，请求将阻塞三次，并且是透明的，而 aiohttp 为事件循环提供了三个切换上下文的机会：

• 执行 时.get()，两个库都会向远程服务器发送 GET 请求。对于 aiohttp，这意味着异步 I/O，在这里用一个async with 标记，可保证它不仅不会阻塞，而且它是干净的完成。
• response.text在请求中执行时，您只需读取一个属性。调用.get()已经以阻塞方式预加载并解码了整个响应负载。aiohttp 在.get()执行时仅加载头文件，让您决定在第二个异步操作中支付加载主体的成本。因此使用await response.text()
• async with aiohttp.ClientSession()进入块时不执行 I/O，但在它结束时，它将确保所有剩余资源都正确关闭。同样，这是异步完成的，必须如此标记。会话也是一种性能工具，因为它为您管理一个连接池，允许您重用它们而不是在每次请求时打开和关闭一个新连接。您甚至可以通过传递连接器对象来管理池大小。

2）使用会话作为最佳实践

requests 库实际上也提供了一个会话系统。事实上，它可以让你做到：

with requests.Session() as session:
    response = session.get('http://python.org')
    print(response.text)

这不是默认行为，也不是在文档的早期宣传。正因为如此，大多数用户会在性能上受到影响，但可以迅速开始黑客攻击。对于请求，这是一个可以理解的权衡，因为它的目标是“人类的 HTTP”，并且在这种情况下，简单性始终比性能更重要。

但是，如果使用 aiohttp，则选择异步编程，这是一种进行相反权衡的范式：为了更好的性能而更加冗长。因此库的默认行为反映了这一点，鼓励您从一开始就使用高性能的最佳实践。

6.1 如何使用 ClientSession

默认情况下，该aiohttp.ClientSession对象将拥有一个最多具有 100 个连接的连接器，将其余连接放入队列中。这是一个相当大的数字，这意味着您必须同时连接到一百个不同的服务器（而不是页面！），然后才能考虑您的任务是否需要调整资源。

事实上，您可以将会话对象描绘为用户启动和关闭浏览器：每次要加载新选项卡时都这样做是没有意义的。

因此，您应该重用会话对象并从中发出许多请求。对于大多数脚本和中等大小的软件，这意味着您可以创建单个会话，并在程序的整个执行过程中重复使用它。您甚至可以将会话作为函数中的参数传递。例如，典型的“hello world”：

import aiohttp
import asyncio

async def main():
    async with aiohttp.ClientSession() as session:
        async with session.get('http://python.org') as response:
            html = await response.text()
            print(html)

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

可以变成这样：

import aiohttp
import asyncio

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    async with aiohttp.ClientSession() as session:
        html = await fetch(session, 'http://python.org')
        print(html)

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

在更复杂的代码库中，您甚至可以创建一个中央注册表来保存代码中任何位置的会话对象，或者创建一个Client包含对它的引用的更高级别的类。

什么时候创建多个会话对象呢？当您想要更精细的资源管理时，就会出现这种情况：

• 您希望通过通用配置对连接进行分组。例如：会话可以设置为其持有的所有连接共享的 cookie、标头、超时值等。
• 您需要多个线程并希望避免在它们之间共享可变对象。
• 您希望多个连接池受益于不同的队列并分配优先级。例如：一个会话从不使用队列并且用于高优先级请求，另一个会话具有较小的并发限制和很长的队列，用于非重要请求。

这只是冰山一角，后续再继续学习更新。。。