12

更新：我已经在 python-ideas 上启动了一个线程来为此目的提出额外的语法或 stdlib 函数（即指定发送的第一个值yield from）。到目前为止 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.sendyield 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调用的返回值. 所以我们还必须拦截并重新发送它。然后发送那个，然后再发送一次，依此类推......所以这行不通。

基本上，我要求的是一种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。理想情况下，我想要一些更优雅、更少冗余的东西。

4

2 回答 2

2

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

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

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

可以看到，对迭代器做的第一件事就是调用next()它，基本上相当于.send(None). 无法跳过该步骤，并且None无论何时yield from使用您的生成器都会收到另一个。

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

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 参考手册中有描述。

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

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

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

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

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

于 2020-12-24T12:19:52.713 回答
-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="")
于 2020-12-24T06:11:22.830 回答