Python异步处理中的asyncwith和asyncfor⽤法说明本⽂翻译⾃Python的开发者指南。
⽹上async with和async for的中⽂资料⽐较少，我把PEP 492中的官⽅陈述翻译⼀下。
异步上下⽂管理器”async with”
异步上下⽂管理器指的是在enter和exit⽅法处能够暂停执⾏的上下⽂管理器。
为了实现这样的功能，需要加⼊两个新的⽅法：__aenter__和__aexit__。这两个⽅法都要返回⼀个 awaitable类型的值。
异步上下⽂管理器的⼀种使⽤⽅法是:
class AsyncContextManager:
async def __aenter__(self):
await log('entering context')
async def __aexit__(self, exc_type, exc, tb):
await log('exiting context')
新语法
异步上下⽂管理器使⽤⼀种新的语法:
async with EXPR as VAR:
BLOCK
这段代码在语义上等同于：
mgr = (EXPR)
aexit = type(mgr).__aexit__
aenter = type(mgr).__aenter__(mgr)
exc = True
VAR = await aenter
try:
BLOCK
except:
if not await aexit(mgr, *_info()):
raise
else:
await aexit(mgr, None, None, None)
和常规的with表达式⼀样，可以在⼀个async with表达式中指定多个上下⽂管理器。
如果向async with表达式传⼊的上下⽂管理器中没有__aenter__和__aexit__⽅法，这将引起⼀个错误。如果在async def函数外⾯使⽤async with，将引起⼀个SyntaxError（语法错误）。
例⼦
使⽤async with能够很容易地实现⼀个数据库事务管理器。
async def commit(session, data):
...
async ansaction():
...
await session.update(data)
...
需要使⽤锁的代码也很简单：
async with lock:
...
⽽不是:
with (yield from lock):
...
异步迭代器 “async for”
⼀个异步可迭代对象（asynchronous iterable）能够在迭代过程中调⽤异步代码，⽽异步迭代器就是能够在next⽅法中调⽤异步代码。为了⽀持异步迭代：
1、⼀个对象必须实现__aiter__⽅法，该⽅法返回⼀个异步迭代器（asynchronous iterator）对象。
2、⼀个异步迭代器对象必须实现__anext__⽅法，该⽅法返回⼀个awaitable类型的值。
3、为了停⽌迭代，__anext__必须抛出⼀个StopAsyncIteration异常。
异步迭代的⼀个例⼦如下:
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):
...
新语法
通过异步迭代器实现的⼀个新的迭代语法如下：
async for TARGET in ITER:
BLOCK
else:
BLOCK2
这在语义上等同于:
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
使⽤异步迭代器能够在迭代过程中异步地缓存数据：
async for data in cursor:
...
这⾥的cursor是⼀个异步迭代器，能够从⼀个数据库中每经过N次迭代预取N⾏数据。
下⾯的语法展⽰了这种新的异步迭代协议的⽤法：
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类可以这样使⽤：
async for row in Cursor():
print(row)
which would be equivalent to the following code:
i = Cursor().__aiter__()
while True:
try:
await和async使用方法
row = await i.__anext__()
except StopAsyncIteration:
break
else:
print(row)
例⼦2
下⾯的代码可以将常规的迭代对象变成异步迭代对象。尽管这不是⼀个⾮常有⽤的东西，但这段代码说明了常规迭代器和异步迭代器之间的关系。
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）内部仍然是基于⽣成器的。因此在之前，下⾯两种写法没有本质的区别：
def g1():
yield from fut
return'spam'
和
def g2():
yield from fut
raise StopIteration('spam')
⾃从得到接受并成为协程的默认实现，下⾯这个例⼦将StopIteration包装成⼀个RuntimeError。
async def a1():
await fut
raise StopIteration('spam')
告知外围代码迭代已经结束的唯⼀⽅法就是抛出StopIteration。因此加⼊了⼀个新的异常类StopAsyncIteration。
由PEP 479的规定 , 所有协程中抛出的StopIteration异常都被包装在RuntimeError中。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。