Python 3.x 对于每个交替迭代，Co例程都返回None

我有一段代码，如下所示：

#!/bin/python3

import math
import os
import random
import re
import sys
import logging


def consumer():
    while True:
        x = yield
        print(x)

def producer(n):
    for _ in range(n):
        x = int(input())
        yield x


def rooter():
    logging.info("Running the rooter")
    while True:
        value = (yield)
        yield math.sqrt(value)


def squarer():
    logging.info("Running the squarer")
    while True:
        value = (yield)
        print("from squarer: {}".format(value))
        yield value * value


def accumulator():
    logging.info("Running the accumulator.")
    running_total = 0
    while True:
        value = (yield)
        running_total += value
        yield running_total


def pipeline(prod, workers, cons):
    logging.info("workers: {}".format(workers))
    for num in prod:
        for i, w in enumerate(workers):
            num = w.send(num)
        cons.send(num)
    for worker in workers:
        worker.close()
    cons.close()

if __name__ == '__main__':
    order = input().strip()
    m = int(input())

    prod = producer(m)

    cons = consumer()
    next(cons)

    root = rooter()
    next(root)

    accumulate = accumulator()
    next(accumulate)

    square = squarer()
    next(square)

    pipeline(prod, eval(order), cons)

样本输入

[square, accumulate]
3  <- Number of inputs coming further

1  <- actual inputs
2
3

但是到了

10

（

1

和

3

的平方和），而实际上它应该是

14

（

1

，

2

，

3

）

因此，基本上输入

2

丢失（它是输入行中的第二个）。 在进一步调试时，我发现每一次交替迭代都是如此，而不仅仅是这里提供的输入

我无法解释发生了什么事。如果有帮助的话，共同例程

squarer

就是在第二次迭代中返回

None

的那一个。

---

非常感谢您的帮助。

我找到了解决方法

在

管道

函数中使用co例程后，我们将其初始化，因此代码如下：我已在asterix中标记了

下一行（w）

，以供参考

#!/bin/python3

import math
import os
import random
import re
import sys
import logging


def consumer():
    while True:
        x = yield
        print(x)

def producer(n):
    for _ in range(n):
        x = int(input())
        yield x


def rooter():
    logging.info("Running the rooter")
    while True:
        value = (yield)
        yield math.sqrt(value)


def squarer():
    logging.info("Running the squarer")
    while True:
        value = (yield)
        print("from squarer: {}".format(value))
        yield value * value


def accumulator():
    logging.info("Running the accumulator.")
    running_total = 0
    while True:
        value = (yield)
        running_total += value
        yield running_total


def pipeline(prod, workers, cons):
    logging.info("workers: {}".format(workers))
    for num in prod:
        for i, w in enumerate(workers):
            num = w.send(num)
            **next(w)**
        cons.send(num)
    for worker in workers:
        worker.close()
    cons.close()

if __name__ == '__main__':
    order = input().strip()
    m = int(input())

    prod = producer(m)

    cons = consumer()
    next(cons)

    root = rooter()
    next(root)

    accumulate = accumulator()
    next(accumulate)

    square = squarer()
    next(square)

    pipeline(prod, eval(order), cons)

如文中所述，生成函数的

产生

通过正常的
下一次
调用恢复时，始终为
None
。因此，当显式地使
产生
时，在这种情况下，它将立即准备好处理下一个输入。
请提供一个简明的问题示例。。。这当前需要运行时的未知输入，并显示pdb。请立即检查@阁楼
#!/bin/python3

import math
import os
import random
import re
import sys
import logging


def consumer():
    while True:
        x = yield
        print(x)

def producer(n):
    for _ in range(n):
        x = int(input())
        yield x


def rooter():
    logging.info("Running the rooter")
    while True:
        value = (yield)
        yield math.sqrt(value)


def squarer():
    logging.info("Running the squarer")
    while True:
        value = (yield)
        print("from squarer: {}".format(value))
        yield value * value


def accumulator():
    logging.info("Running the accumulator.")
    running_total = 0
    while True:
        value = (yield)
        running_total += value
        yield running_total


def pipeline(prod, workers, cons):
    logging.info("workers: {}".format(workers))
    for num in prod:
        for i, w in enumerate(workers):
            num = w.send(num)
            **next(w)**
        cons.send(num)
    for worker in workers:
        worker.close()
    cons.close()

if __name__ == '__main__':
    order = input().strip()
    m = int(input())

    prod = producer(m)

    cons = consumer()
    next(cons)

    root = rooter()
    next(root)

    accumulate = accumulator()
    next(accumulate)

    square = squarer()
    next(square)

    pipeline(prod, eval(order), cons)