1. # 因为yield是生成一个生成器并且自动管理上下文,所以gen()函数内的count total average每次调用时
    2. # 都会保留上次的值, 直到程序结束或者return
    3. def gen():
    4. count = 0
    5. total = 0
    6. average = 0
    7. while 1:
    8. new_sum = yield average
    9. count += 1
    10. total += new_sum
    11. average = total / count
    12. def pro_gen():
    13. yield from gen()
    14. def main():
    15. average = pro_gen()
    16. next(average)
    17. res = average.send(10)
    18. print(res)
    19. res = average.send(40)
    20. print(res)
    21. res = average.send(100)
    22. print(res)
    23. main()
    24. # 以下是输出
    25. # 10.0
    26. # 25.0
    27. # 50.0

    yield from 后面加上一个生成器后,就实现了生成的嵌套。
    当然实现生成器的嵌套,并不是一定必须要使用yield from,而是使用yield from可以让我们避免让我们自己处理各种料想不到的异常,而让我们专注于业务代码的实现。
    如果自己用yield去实现,那只会加大代码的编写难度,降低开发效率,降低代码的可读性。既然Python已经想得这么周到,我们当然要好好利用起来。
    讲解它之前,首先要知道这个几个概念

    1、调用方:调用委派生成器的客户端(调用方)代码 2、委托生成器:包含yield from表达式的生成器函数 3、子生成器:yield from后面加的生成器函数

    1. def gen():
    2. count = 0
    3. total = 0
    4. average = 0
    5. while 1:
    6. new_sum = yield average
    7. if not new_sum:
    8. break
    9. count += 1
    10. total += new_sum
    11. average = total / count
    12. return count, total, average
    13. def pro_gen():
    14. # 只有子生成器要结束(return)了,yield from左边的变量才会被赋值,后面的代码才会执行。
    15. while 1:
    16. count, total, average = yield from gen()
    17. print("计算完毕!!\n总共传入 {} 个数值, 总和:{},平均数:{}".format(count, total, average))
    18. def main():
    19. average = pro_gen()
    20. next(average)
    21. res = average.send(10)
    22. print(res)
    23. res = average.send(40)
    24. print(res)
    25. average.send(None) # 结束协程
    26. res = average.send(10) # 由于上一协程已经结束,将重开一协程
    27. print(res)
    28. average.send('')
    29. main()
    30. """
    31. 10.0
    32. 25.0
    33. 计算完毕!!
    34. 总共传入 2 个数值, 总和:50,平均数:25.0
    35. 10.0
    36. 计算完毕!!
    37. 总共传入 1 个数值, 总和:10,平均数:10.0
    38. """