python async with和async for的使用

时间:2022-08-29 17:12:48

网上async with和async for的中文资料比较少,我把pep 492中的官方陈述翻译一下。

异步上下文管理器”async with”

异步上下文管理器指的是在enter和exit方法处能够暂停执行的上下文管理器。

为了实现这样的功能,需要加入两个新的方法:__aenter__ 和__aexit__。这两个方法都要返回一个 awaitable类型的值。

异步上下文管理器的一种使用方法是:

python" id="highlighter_191645">
?
1
2
3
4
5
6
class asynccontextmanager:
  async def __aenter__(self):
    await log('entering context')
 
  async def __aexit__(self, exc_type, exc, tb):
    await log('exiting context')

新语法

异步上下文管理器使用一种新的语法:

?
1
2
async with expr as var:
  block

这段代码在语义上等同于:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
mgr = (expr)
aexit = type(mgr).__aexit__
aenter = type(mgr).__aenter__(mgr)
exc = true
 
var = await aenter
try:
  block
except:
  if not await aexit(mgr, *sys.exc_info()):
    raise
else:
  await aexit(mgr, none, none, none)

和常规的with表达式一样,可以在一个async with表达式中指定多个上下文管理器。

如果向async with表达式传入的上下文管理器中没有__aenter__ 和__aexit__方法,这将引起一个错误 。如果在async def函数外面使用async with,将引起一个syntaxerror(语法错误)。

例子

使用async with能够很容易地实现一个数据库事务管理器。

?
1
2
3
4
5
6
7
async def commit(session, data):
  ...
 
  async with session.transaction():
    ...
    await session.update(data)
    ...

需要使用锁的代码也很简单:

?
1
2
async with lock:
  ...

而不是:

?
1
2
with (yield from lock):
  ...

异步迭代器 “async for”

一个异步可迭代对象(asynchronous iterable)能够在迭代过程中调用异步代码,而异步迭代器就是能够在next方法中调用异步代码。为了支持异步迭代:

1、一个对象必须实现__aiter__方法,该方法返回一个异步迭代器(asynchronous iterator)对象。
2、一个异步迭代器对象必须实现__anext__方法,该方法返回一个awaitable类型的值。
3、为了停止迭代,__anext__必须抛出一个stopasynciteration异常。

异步迭代的一个例子如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
class asynciterable:
  def __aiter__(self):
    return self
 
  async def __anext__(self):
    data = await self.fetch_data()
    if data:
      return data
    else:
      raise stopasynciteration
 
  async def fetch_data(self):
    ...

新语法

通过异步迭代器实现的一个新的迭代语法如下:

?
1
2
3
4
async for target in iter:
  block
else:
  block2

这在语义上等同于:

?
1
2
3
4
5
6
7
8
9
10
11
12
iter = (iter)
iter = type(iter).__aiter__(iter)
running = true
while running:
  try:
    target = await type(iter).__anext__(iter)
  except stopasynciteration:
    running = false
  else:
    block
else:
  block2

把一个没有__aiter__方法的迭代对象传递给 async for将引起typeerror。如果在async def函数外面使用async with,将引起一个syntaxerror(语法错误)。

和常规的for表达式一样, async for也有一个可选的else 分句。.

例子1

使用异步迭代器能够在迭代过程中异步地缓存数据:

?
1
2
async for data in cursor:
  ...

这里的cursor是一个异步迭代器,能够从一个数据库中每经过n次迭代预取n行数据。

下面的语法展示了这种新的异步迭代协议的用法:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class cursor:
  def __init__(self):
    self.buffer = collections.deque()
 
  async def _prefetch(self):
    ...
 
  def __aiter__(self):
    return self
 
  async def __anext__(self):
    if not self.buffer:
      self.buffer = await self._prefetch()
      if not self.buffer:
        raise stopasynciteration
    return self.buffer.popleft()

接下来这个cursor 类可以这样使用:

?
1
2
3
4
5
6
7
8
9
10
11
12
async for row in cursor():
  print(row)
which would be equivalent to the following code:
 
i = cursor().__aiter__()
while true:
  try:
    row = await i.__anext__()
  except stopasynciteration:
    break
  else:
    print(row)

例子2

下面的代码可以将常规的迭代对象变成异步迭代对象。尽管这不是一个非常有用的东西,但这段代码说明了常规迭代器和异步迭代器之间的关系。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class asynciteratorwrapper:
  def __init__(self, obj):
    self._it = iter(obj)
 
  def __aiter__(self):
    return self
 
  async def __anext__(self):
    try:
      value = next(self._it)
    except stopiteration:
      raise stopasynciteration
    return value
 
async for letter in asynciteratorwrapper("abc"):
  print(letter)

为什么要抛出stopasynciteration?

协程(coroutines)内部仍然是基于生成器的。因此在pep 479之前,下面两种写法没有本质的区别:

?
1
2
3
def g1():
  yield from fut
  return 'spam'

?
1
2
3
def g2():
  yield from fut
  raise stopiteration('spam')

自从 pep 479 得到接受并成为协程 的默认实现,下面这个例子将stopiteration包装成一个runtimeerror。

?
1
2
3
async def a1():
  await fut
  raise stopiteration('spam'

告知外围代码迭代已经结束的唯一方法就是抛出stopiteration。因此加入了一个新的异常类stopasynciteration。

pep 479的规定 , 所有协程中抛出的stopiteration异常都被包装在runtimeerror中。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持服务器之家。

原文链接:https://blog.csdn.net/tinyzhao/article/details/52684473