通过生成器yield实现单线程的情况下实现并发运算效果（异步IO的雏形）

一、协程：

1、生成器只有在调用时才会生成相应的数据

2、调用方式有 " str__next__.()   str.send() "，

3、并且每调用一次就产生一个值调用到最后一个值后会报错

4、报错可用try和except做异常处理

 

注意：

next：是直接调用yield，并不会传值。

send：是调用并直接传值给yield。

 #!/usr/bin/env python
 # -*- coding:utf8 -*-
 # Author:Dong Ye

 '''
 定义两个模型：
 一个是生产包子的。（生成器）
 另一个是吃包子的。（迭代器）

 这段功能实现了异步IO的雏形，也是一个简单的协程处理方式。
 协程的特点：实际是串行方式分开执行的，但由于运行效果快，给人的感觉像是并行。
 因此，协程也叫作：单线程下的并行执行效果。
 协程是包含在线程里的一个单位，线程时进程的一个单位。
 例如：enginx在异步单线程下，比多线程要快好多倍，也就是这种效果。
 '''

 import time

 #吃包子的
 def consumer(name):
     print('%s 准备吃包子了！' % name)
     while True:
         baozi = yield
         print("包子[%s]来了。被[%s]吃了！" %(baozi,name))

 #生产包子的
 def producer(name):
     #先定义2个协程（消费者）#将函数变成生成器
     c1 = consumer('A')   #2个消费者
     c2 = consumer('B')   #相当于2个协程（进程，线程，协程）
     #开始调用生成器初始化（准备吃包子）
     c1.__next__()     #开始调用生成器，只有next的时候才会到yield进行下一个操作
     c2.__next__()
     print('老子开始吃包子拉！')
     #循环的次数，每次循环都会传值给生成器（产生什么样的包子）
     for i in range(10):
         time.sleep(1)
         print("做了一个包子，分2半，一人一半")
         c1.send(i) #包子的类型
         c2.send(i)

 producer("alex")

 '''
 #手动做包子：
 c = consumer("dy")
 c.__next__()
 #c.__next__()

 b1 = "韭菜馅"
 c.send(b1)     #调用+传值
 #c.__next__()  #只调用，不传值
 '''

 显示结果:
 A 准备吃包子了！
 B 准备吃包子了！
 老子开始吃包子拉！
 做了一个包子，分2半，一人一半  #任务1
 包子[0]来了。被[A]吃了！      #任务2
 包子[0]来了。被[B]吃了！      #任务3
 做了一个包子，分2半，一人一半
 包子[1]来了。被[A]吃了！
 包子[1]来了。被[B]吃了！
 做了一个包子，分2半，一人一半
 包子[2]来了。被[A]吃了！
 包子[2]来了。被[B]吃了！
 做了一个包子，分2半，一人一半
 包子[3]来了。被[A]吃了！
 包子[3]来了。被[B]吃了！
 做了一个包子，分2半，一人一半
 包子[4]来了。被[A]吃了！
 包子[4]来了。被[B]吃了！
 做了一个包子，分2半，一人一半
 包子[5]来了。被[A]吃了！
 包子[5]来了。被[B]吃了！
 做了一个包子，分2半，一人一半
 包子[6]来了。被[A]吃了！
 包子[6]来了。被[B]吃了！
 做了一个包子，分2半，一人一半
 包子[7]来了。被[A]吃了！
 包子[7]来了。被[B]吃了！
 做了一个包子，分2半，一人一半
 包子[8]来了。被[A]吃了！
 包子[8]来了。被[B]吃了！
 做了一个包子，分2半，一人一半
 包子[9]来了。被[A]吃了！
 包子[9]来了。被[B]吃了！

协程的示例