网上async with和async for的中文资料比较少，我把pep 492中的官方陈述翻译一下。
异步上下文管理器”async with”
异步上下文管理器指的是在enter和exit方法处能够暂停执行的上下文管理器。
为了实现这样的功能，需要加入两个新的方法：__aenter__ 和__aexit__。这两个方法都要返回一个 awaitable类型的值。
异步上下文管理器的一种使用方法是:
|
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 = truevar = await aentertry: blockexcept: if not await aexit(mgr, *sys.exc_info()): raiseelse: 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: blockelse: block2 |
这在语义上等同于:
|
1
2
3
4
5
6
7
8
9
10
11
12
|
iter = (iter)iter = type(iter).__aiter__(iter)running = truewhile running: try: target = await type(iter).__anext__(iter) except stopasynciteration: running = false else: blockelse: 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 valueasync 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
