__await__ 方法必须返回迭代器，因为 await 表达式底层依赖可等待对象协议，该协议要求 __await__ 返回支持 __next__() 和 throw() 的迭代器实例，而非任意可迭代对象或协程。

为什么 __await__ 方法必须返回迭代器

python 的 await 表达式底层依赖的是「可等待对象」（awaitable）协议，而该协议的唯一硬性要求是对象实现 __await__ 方法，且该方法**必须返回一个迭代器（iterator）**——不是任意可迭代对象（如 list、generator expression），也不是协程对象，而是真正支持 .__next__() 和 .throw() 的迭代器实例。

常见错误是直接在 __await__ 里 return [awaitable] 或 yield from some_coro，这会导致 TypeError: Object X can't be used in 'await' expression。

实操建议：

• __await__ 内部应调用 iter() 包装一个生成器函数，或直接返回一个自定义迭代器类实例
• 若逻辑简单（如立即完成），可用 return iter([result])；但注意：单元素 list 不是迭代器，必须显式调用 iter()
• 若需异步等待某个 IO 操作，应在生成器中 yield 一次（表示让出控制权），并在恢复后返回结果

如何用生成器函数实现最小可行的 awaitable

最轻量的方式是把 __await__ 实现为一个生成器函数，并用 return 提前结束（Python 3.3+ 支持生成器中 return value，其值会作为 StopIteration.value 被 await 捕获）。

示例：

class Delay:     def __init__(self, seconds):         self.seconds = seconds 
def __await__(self):     # 这是一个生成器函数，返回的是 generator iterator     yield  # 模拟一次挂起（实际中可对接 loop.call_later 等）     return f"done after {self.seconds}s"
使用
import asyncio async def main(): res = await Delay(1) print(res)  # "done after 1s"
asyncio.run(main()) 
关键点：

 yield 是必需的——没有它，函数就不是生成器，返回的是普通函数对象，不满足 awaitable 协议
 return 值会被 await 提取为表达式结果；若没 return，则默认为 None 
这个生成器本身不处理事件循环调度，只是“假装”挂起；真实场景中需在 yield 前注册回调或调用 loop.create_future() 

如何对接事件循环：用 Future 驱动自定义 awaitable
如果希望你的 awaitable 真正参与事件循环调度（比如延迟执行、等待文件描述符就绪），不能只靠 yield，而应返回一个迭代器，其 __next__ 方法返回一个 Future 对象（或其它 awaitable），再由解释器自动 await 它。
更稳妥的做法是：在 __await__ 中返回一个包装了 Future 的迭代器。标准库中 asyncio.Future.__await__ 就是这么做的。
实操建议：

不要手动 await 其它协程，而是把控制权交还给事件循环：让 __await__ 返回的迭代器在每次 .__next__() 时返回一个 Future 
使用 asyncio.get_event_loop().create_future() 创建 future，并在适当时机 .set_result() 或 .set_exception() 
确保该 future 最终被事件循环驱动完成；否则 await 会永远挂起

简化版示意（不推荐直接用于生产，仅说明原理）：
class SleepLike:     def __init__(self, delay):         self.delay = delay 
def __await__(self):     loop = asyncio.get_event_loop()     fut = loop.create_future()     loop.call_later(self.delay, fut.set_result, None)     # 返回一个迭代器，第一次 next() 就 yield 这个 future     return (lambda: fut).__await__()

注意：fut.__await__() 返回的是一个迭代器，所以最后一行等价于 return fut.__await__() —— 这正是复用标准 awaitable 协议的正确方式。
容易被忽略的细节：__await__ 不该抛异常，也不该被多次调用
__await__ 方法本身不应抛出异常（如 RuntimeError 或 ValueError），因为一旦抛出，await 表达式会直接失败，而不是进入等待流程。更隐蔽的问题是：同一个 awaitable 实例的 __await__ 可能被多次调用（例如在 await x 失败重试时，或某些调试器中），但它返回的迭代器**不可重用**——迭代器耗尽后再次 .__next__() 会抛 StopIteration。
这意味着：

每次 await 都应触发一次新的 __await__() 调用，返回新迭代器；不能缓存并复用旧迭代器
不要在 __await__ 中做带副作用的初始化（如启动线程、打开 socket），除非你明确允许重复执行
若需状态管理（如“已开始”“已完成”），状态应放在 awaitable 实例上，而非迭代器内部

最安全的模式，就是让 __await__ 总是返回一个新生成器或新迭代器实例——Python 自带的生成器函数天然满足这点。