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

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

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

yield

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

然后先看下面代码：

deffoo():print("starting...")whileTrue:

res= yield 4

print("res:", res)

g=foo()print(next(g))print("*" * 20)print(next(g))

这段代码输出的是如下：

starting...4

********************res: None4

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

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出要生成的数，然后到这步就停止结束了。

再看一下下面这个例子：

deffoo():print("starting...")whileTrue:

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组合：

deffoo(num):print("starting...")while num<10:

num=num+1

yieldnumfor n infoo(0):print(n)

输出：

starting...1

2

3

4

5

6

7

8

9

10

yield from

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

deffun_inner():

i=0whileTrue:

i= yieldideffun_outer():

a=0

b= 1inner=fun_inner()

inner.send(None)whileTrue:

a=inner.send(b)

b= yieldaif __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出结果。如果嵌套的层次更多，传递将会越麻烦。

输出结果如下：

01

2

3

4

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

deffun_inner():

i=0whileTrue:

i= yieldideffun_outer():#a = 0

#b = 1

#inner = fun_inner()

#inner.send(None)

#while True:

#a = inner.send(b)

#b = yield a

yield fromfun_inner()if __name__ == '__main__':

outer=fun_outer()

outer.send(None)for i in range(5):print(outer.send(i))