17_Python生成器案例

案例一：聊天机器人

def chat_robot():
    """
    聊天机器人
    :return:
    """
    # 这个变量存储的是机器人给用户的响应信息;
    response = ''
    while True:
        #response :机器人给用户的响应信息
        #receive： 接收用户 给 机器人传来的消息
        receive = yield response

        if 'age' in receive:
            response = 'Name confidentiality'

        elif 'name' in receive:
            response= "I'm robot Sir"

        elif receive.endswitch(' s?'):
            response = receive.rstrip(' s?')

        else:
            response = "I don't understand!"
#实例化 Robot是生成器
Robot = chat_robot()
#调用next方法，遇到yield 停止
next(Robot)

while True:
    send_date = input("[User]>>:")
    if send_date == 'q' or send_date =='quit':
        print("goodbye")
        break
    ## 将用户输入的send_date传送到yield 前的receive
    response = Robot.send(send_date)
    print('[Robot>>:]',response)

案例二、生产者，消费者模型

生产者消费者模型当中有两大类重要的角色，一个是生产者（负责造数据的任务），另一个是消费者（接收造出来的数据进行进一步的操作）。

1. 为什么要使用生产者消费者模型？

在并发编程中，如果生产者处理速度很快，而消费者处理速度比较慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个等待的问题，就引入了生产者与消费者模型。让它们之间可以不停的生产和消费。

2. 实现生产者消费者模型三要素：

1、生产者

2、消费者

3、队列（或其他的容哭器，但队列不用考虑锁的问题）

3. 什么时候用这个模型？

程序中出现明显的两类任务，一类任务是负责生产，另外一类任务是负责处理生产的数据的（如爬虫）

4. 用该模型的好处？

1、实现了生产者与消费者的解耦和

2、平衡了生产力与消费力，就是生产者一直不停的生产，消费者可以不停的消费，因为二者不再是直接沟通的，而是跟队列沟通的。

import time
import random

cacheList = []
cacheListLen =5

def is_full():
    """
    判断缓冲区队列是否已经满了
    :return:
    """
    return len(cacheList)==cacheListLen

def Producer(name):   ##生产者
    while True:
        if not is_full():
            print("生产者【%s】正在生成游戏机..."%(name))
            time.sleep(random.random())
            print("【%s】已经生产游戏机完成"%(name))

            cacheList.append('游戏机')
        else:
            print('生产足够多了...')
            yield

def Consumer(name):   ##消费者
    print('[%s]正准备购买游戏机'%(name))
    while True:
        item =yield
        print('[%s]购买游戏机成功'%(name))

producer =Producer("小高")
next(producer)

consumers = [Consumer("消费者%s"%(i+1)) for i in range(10)]

for consumer in consumers:
    if not cacheList:
        print("目前商店没有游戏库存...")
    else:
        if not is_full():
            next(producer)
        else:
            item = cacheList.pop(0)
            next(consumer)
            consumer.send(item)

三、基于0库存的生产者消费者模型

"""
传统的生产者-消费者模型是一个线程写消息，一个线程取消息，通过锁机制控制队列和等待，但一不小心就可能死锁。
现在改用协程(yield)，生产者生产消息后，直接通过yield跳转到消费者开始执行，待消费者执行完毕后，切换回生产者继续生产，效率极高。
"""
import random
import  time
def Consumer(name):
    """消费者"""
    goods = ["电视", "手机", '电脑']
    # buy_name = input("请输入购买物品:")
    buy_name = random.choice(goods)  
    print("[%s]需要购买%s" %(name, buy_name))
    while True:
        # 将yield后面的buy_name发送给生产者, 生产者获取生产的信息
        game  = yield buy_name
        print("[%s]购买%s成功" %(name, game))

def Produder(name):
    """生产者"""
    # []生成一个列表， 列表里面是10个生成器(Consumer)
    # ()生成一个生成器， 列表里面是10个生成器(Consumer)
    consumers = (Consumer("消费者%s" %(i+1)) for i in range(10))
    for consumer in consumers:
        # next方法的返回值就是Consumer里面yield后面跟的值;
        buy_name = next(consumer)
        print("工程师[%s]正在生产%s" %(name, buy_name))
        time.sleep(1)
        print("工程师[%s]生产%s成功" % (name, buy_name))
        # 爬虫中返回的内容是的内容;
        # 将生产好的数据发送给消费者
        consumer.send(buy_name)
def main():
    Produder("高梦飞")
main()

四、基于yield计算平均值

ef averager():
    total=0.0
    count=0
    average=None
    all_items=[]
    while True:
        new_item = yield average,all_items
        all_items.append(int(new_item))
        total += new_item
        count +=1
        average= total/count

def main():
    Averager= averager()
    next(Averager)
    while True:
        new_num= input("请输入球平均值的数：")
        if new_num =='q' :
            print('程序执行结束...')
            break
        average,all_items =Averager.send(int(new_num))
        print(all_items,"的平均值为：",average)

main()