python中yield的用法以及和yield from的区别

看了大佬的博客很快就懂了。

这是原博客链接：https://blog.csdn.net/mieleizhi0522/article/details/82142856

由于最近接触了酷q机器人，搭建好了环境，配合NoneBot可以通过python代码自己写机器人功能。

NoneBot是基于asyncio的，所以先通过yield来学习一点python协程方面的知识。

 

yield

首先，先可以把yield看成“return”，return什么意思大家都知道吧，就是代表在程序中返回某个值，return所在的当前函数就停住了，不能往下再运行下去了。

然后先看下面代码：

def foo():
    print("starting...")
    while True:
        res = yield 4
        print("res:", res)
g = foo()
print(next(g))
print("*" * 20)
print(next(g))

这段代码输出的是如下：

starting...
4
********************
res: None
4

所以我们来一步一步分析程序：

1.程序开始执行之后，在foo函数中有yield关键字，所以foo函数并不会真的执行，而是先得到了一个生成器g（相当于我们创造出了一个对象）。

2.直到调用了next方法，这里我们先要知道在python中，next()返回的是迭代器的下一个项目，所以后面我们调用了next(g)方法，foo函数正式开始执行，先执行了foo函数中的print方法，然后就进入了while循环。

3.程序遇到yield关键字，然后我们现在把yield当成return，所以返回了一个4之后，程序就结束了，后面的给res赋值的操作并没有执行。此时的话第一个print(next(g))就执行完成了，所以输出了前两行的结果。

4.程序执行print("*"*20)，输出了20个*。

5.又开始执行下面的print(next(g))，这个时候和上面那个差不多，不过不同的是，这个时候是从刚才那个next程序停止的地方开始执行的，也就是接着上面return之后的操作，因为while函数里面其实是先return，再赋值给res，上面在return终止之后，就没有赋值给res，所以输出的就是res:None。

6.程序会继续在while里执行，又一次碰到yield，这个时候同样return出4，然后程序停止，print函数输出的4就是这次return的4。

 

所以到这里你可能就明白了yield和return的关系和区别了，带yield的函数是一个生成器，而不是一个函数，这个生成器有一个函数就是next函数，next就相当于"下一步"生成哪个书，这一次的next开始的地方是接着上一次的next停止的地方执行的，所以调用next的时候，生成器并不会从foo函数开始执行，只是接着上一步停止的地方开始，然后遇到yield后，return出要生成的数，然后到这步就停止结束了。

 

再看一下下面这个例子：

def foo():
    print("starting...")
    while True:
        res = yield 4
        print("res:", res)

g = foo()
print(next(g))
print("*" * 20)
print(g.send(7))

这里调用了一个g.send(7)函数，然后输出结果是：

starting...
4
********************
res: 7
4

 

先大致说一下send函数的概念：此时你应该注意到上面那个的紫色的字，还有上面那个res的值为什么是None，这个变成了7，到底为什么，这是因为，send是发送一个参数给res的，因为上面讲到，return的时候，并没有把4赋值给res，下次执行的时候只好继续执行赋值操作，只好赋值为None了，而如果用send的话，开始执行的时候，先接着上一次（return 4之后）执行，先把7赋值给了res,然后执行next的作用，遇见下一回的yield，return出结果后结束。

 

5.程序执行g.send(7)，程序会从yield关键字那一行继续向下运行，send会把7这个值赋值给res变量

6.由于send方法中包含next()方法，所以程序会继续向下运行执行print方法，然后再次进入while循环

7.程序执行再次遇到yield关键字，yield会返回后面的值后，程序再次暂停，直到再次调用next方法或send方法。

这就结束了，说一下，为什么用这个生成器，是因为如果用List的话，会占用更大的空间，比如说取0,1,2,3,4,5,6............1000

你可能会这样：

for n in range(1000):
    a=n

这个时候range(1000)就默认生成一个含有1000个数的list了，所以很占内存。

这个时候你可以用刚才的yield组合成生成器进行实现，也可以用xrange(1000)这个生成器实现

yield组合：

def foo(num):
    print("starting...")
    while num<10:
        num=num+1
        yield num
for n in foo(0):
    print(n)

输出：

starting...
1
2
3
4
5
6
7
8
9
10

 

 

yield from

关于区别可以看这篇博客：https://www.cnblogs.com/cnkai/p/7514828.html

前面的yield都是单一层次的生成器，并没有嵌套，如果是多个生成器嵌套会怎么样呢，下面是一个例子：

def fun_inner():
    i = 0
    while True:
        i = yield i


def fun_outer():
    a = 0
    b = 1
    inner = fun_inner()
    inner.send(None)
    while True:
        a = inner.send(b)
        b = yield a


if __name__ == '__main__':
    outer = fun_outer()
    outer.send(None)
    for i in range(5):
        print(outer.send(i))

这个例子在fun_outer()函数里面先调用了一次fun_inner()，这是一个容器，再嵌套外面的yield a，然后在main中调用了fun_outer()，给其send一个i进去，在两层嵌套的情况下，值的传递方式是，先把值传递给外层生成器，外层生成器再将值传递给外层生成器，内层生成器在将值反向传递给外层生成器，最终yield出结果。如果嵌套的层次更多，传递将会越麻烦。

输出结果如下：

0
1
2
3
4

然后我们用yield from来实现，代码明显少了很多。

def fun_inner():
    i = 0
    while True:
        i = yield i


def fun_outer():
    # a = 0
    # b = 1
    # inner = fun_inner()
    # inner.send(None)
    # while True:
    #     a = inner.send(b)
    #     b = yield a
    yield from fun_inner()


if __name__ == '__main__':
    outer = fun_outer()
    outer.send(None)
    for i in range(5):
        print(outer.send(i))