网上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 = 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