如何拦截生成器的第一个值并透明地从其余值中产生

Question

更新： 我已经开始 thread on python-ideas 来为此目的提出额外的语法或标准库函数（即指定 [=14= 发送的第一个值） ]).到目前为止 0 条回复... :/

如何使用 yield from 拦截子生成器的第一个生成值，并将其余迭代委托给后者？

例如，假设我们有一个任意的双向生成器 subgen，我们想将其包装在另一个生成器 gen 中。 gen 的目的是拦截 subgen 的第一个产生的值并委托生成的其余部分——包括发送的值、抛出的异常、.close() 等——到副发电机。

首先想到的可能是：

def gen():
    g = subgen()

    first = next(g)
    # do something with first...
    yield "intercepted"

    # delegate the rest
    yield from g

但这是错误的，因为当调用者 .send 得到第一个值后返回给生成器时，它将作为 yield "intercepted" 表达式的值结束，它被忽略，而 g 将接收 None 作为第一个 .send 值，作为 yield from.

语义的一部分

所以我们可能会考虑这样做：

def gen():
    g = subgen()

    first = next(g)
    # do something with first...
    received = yield "intercepted"
    g.send(received)

    # delegate the rest
    yield from g

但是我们在这里所做的只是将问题向后移了一步：我们一调用 g.send(received)，生成器就恢复执行，直到到达下一个 yield 语句才停止，其值成为 .send 调用的 return 值。所以我们还必须拦截并重新发送。然后再发送 that，然后再发送 that，依此类推……这样不行。

基本上，我要的是 yield from 可以自定义发送到生成器的第一个值的方法：

def gen():
    g = subgen()

    first = next(g)
    # do something with first...
    received = yield "intercepted"

    # delegate the rest
    yield from g start with received  # pseudocode; not valid Python

...但不必自己重新实现 yield from 的所有语义。也就是说，费力且难以维护的解决方案是：

def adaptor(generator, init_send_value=None):
    send = init_send_value
    try:
        while True:
            send = yield generator.send(send)
    except StopIteration as e:
        return e.value

这基本上是 yield from 的糟糕重新实现（它缺少对 throw、close 等的处理）。理想情况下，我想要更优雅、更少冗余的东西。

Answer 1

如果我理解了这个问题，我认为这行得通吗？意思是，我运行这个脚本并且它做了我预期的，即打印除了输入文件的第一行之外的所有内容。但是只要作为参数传递给 skip_first 函数的生成器可以迭代，它就应该可以工作。

def skip_first(thing):
    _first = True
    for _result in thing:
        if _first:
        _   first = False
            continue
        yield _result

inp = open("/var/tmp/test.txt")

for line in skip_first(inp):
    print(line, end="")

Answer 2

如果您尝试使用 yield from 将此生成器包装器实现为生成器函数，那么您的问题基本上可以归结为是否可以指定发送到“产生自”生成器的第一个值.它不是。

如果您查看 PEP 380 中 yield from 表达式的正式规范，您就会明白原因。该规范包含一段（异常复杂的）示例代码，其行为与 yield from 表达式相同。前几行是：

_i = iter(EXPR)
try:
    _y = next(_i)
except StopIteration as _e:
    _r = _e.value
else:
    ...

可以看到对迭代器做的第一件事就是在上面调用next()，基本上等同于.send(None)。没有办法跳过该步骤，并且每当使用 yield from 时，您的生成器将始终收到另一个 None。

我提出的解决方案是使用 class 而不是生成器函数来实现生成器协议：

class Intercept:
    def __init__(self, generator):
        self._generator = generator
        self._intercepted = False

    def __next__(self):
        return self.send(None)

    def send(self, value):
        yielded_value = self._generator.send(value)

        # Intercept the first value yielded by the wrapped generator and 
        # replace it with a different value.
        if not self._intercepted:
            self._intercepted = True

            print(f'Intercepted value: {yielded_value}')

            yielded_value = 'intercepted'

        return yielded_value

    def throw(self, type, *args):
        return self._generator.throw(type, *args)

    def close(self):
        self._generator.close()

__next__()、send()、throw()、close()在Python Reference Manual.

中有说明

class 包装传递给它的生成器，在创建时将模仿它的行为。它唯一改变的是生成器产生的第一个值在返回给调用者之前被一个不同的值替换。

我们可以使用生成两个值的示例生成器 f() 和一个将值发送到生成器直到生成器终止的函数 main() 来测试行为：

def f():
    y = yield 'first'
    print(f'f(): {y}')

    y = yield 'second'
    print(f'f(): {y}')

def main():
    value_to_send = 0
    gen = f()

    try:
        x = gen.send(None)

        while True:
            print(f'main(): {x}')

            # Send incrementing integers to the generator.
            value_to_send += 1
            x = gen.send(value_to_send)
    except StopIteration:
        print('main(): StopIteration')    
      
main()

当运行时，此示例将产生以下输出，显示哪些值到达生成器以及哪些值由生成器返回：

main(): first
f(): 1
main(): second
f(): 2
main(): StopIteration

通过将语句 gen = f() 更改为 gen = Intercept(f()) 来包装生成器 f()，产生以下输出，表明第一个产生的值已被替换：

Intercepted value: first
main(): intercepted
f(): 1
main(): second
f(): 2

由于对任何生成器 API 的所有其他调用都直接转发给包装生成器，因此它的行为应与包装生成器本身等效。

如何拦截生成器的第一个值并透明地从其余值中产生

How to intercept the first value of a generator and transparently yield from the rest

python

generator

yield-from