我正在尝试了解如何制作一个可等待的对象。来自 documentation 的定义状态:

An object with an __await__ method returning an iterator.

在该定义的指导下，我编写了示例代码:

import asyncio

async def produce_list():
        num = await Customer()
        print(num)

class Customer(object):

    def __await__(self):
        return iter([1, 2, 3, 4])

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

我预期的流程是:

1. 事件循环将控制权交给 produce_list()。 produce_list() 放弃对 num = await Customer() 的执行。
2. Customer() 被执行并返回一个迭代器。这是因为返回迭代器中的第一个值。 Q1: 不清楚为什么 num 本身没有成为迭代器。另外，这里 send 是做什么的？
3. 一旦到达迭代器的最后一个值。 num = 4 协程的执行继续到print(num)，并打印出值4。

我得到了什么:

---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
~/workspace/dashboard/so_question_await.py in <module>()
     16 
     17 loop = asyncio.get_event_loop()
---> 18 loop.run_until_complete(produce_list())

/usr/lib/python3.5/asyncio/base_events.py in run_until_complete(self, future)
    464             raise RuntimeError('Event loop stopped before Future completed.')
    465 
--> 466         return future.result()
    467 
    468     def stop(self):

/usr/lib/python3.5/asyncio/futures.py in result(self)
    291             self._tb_logger = None
    292         if self._exception is not None:
--> 293             raise self._exception
    294         return self._result
    295 

/usr/lib/python3.5/asyncio/tasks.py in _step(***failed resolving arguments***)
    239                 result = coro.send(None)
    240             else:
--> 241                 result = coro.throw(exc)
    242         except StopIteration as exc:
    243             self.set_result(exc.value)

~/workspace/dashboard/so_question_await.py in produce_list()
      5 
      6 async def produce_list():
----> 7         num = await Customer()
      8         print(num)
      9 

RuntimeError: Task got bad yield: 1

我在这里弄错了哪些概念？

最后我正在寻找一个使用迭代列表作为事件返回协程控制的示例。

最佳答案

__await__ 返回一个迭代器，因为协程的底层机制最初是基于 yield from 语法。在实践中，__await__ 返回 iter(some_future) 或 some_coroutine.__await__()。它可用于创建每次等待时产生不同值的对象。看这个简单的例子:

import asyncio
import random

class RandomProducer:

    def __await__(self):
        return self.producer().__await__()

    async def producer(self):
        sleep = random.random()
        value = random.randint(0, 9)
        return await asyncio.sleep(sleep, result=value)

async def main():
    producer = RandomProducer()
    while True:
        print(await producer)

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

回答您的意见:

Does every coroutine eventually ends up calling asyncio.sleep?

不，asyncio.sleep 实际上不是链的末端。在最底层，总是产生一个 future :协程链要求事件循环“当这个 future 有结果时请叫醒我”。在 asyncio.sleep 的情况下，它使用 loop.call_later 在给定时间后设置 future 的结果。循环提供了更多调度回调的方法:loop.call_at、loop.add_reader、loop.add_writer、loop.add_signal_handler等

An asyncio library such as aiohttp. I'm assuming there is some code somewhere that doesn't rely on existence of previous coroutines.

为了实现单线程并发，所有的 IO 操作最终都必须委托(delegate)给事件循环。 例如，aiohttp 依赖于 loop.create_connection协程到 manage the TCP connection .

关于python - 异步等待对象 - 基本示例，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/44810614/