yield与send实现协程操做

yield与send实现协程操做

以前咱们说过，在函数内部含有yield语句即称为生成器。

下面，咱们来看看在函数内部含有yield语句达到的效果。首先，咱们来看看如下代码：

def foo():
    while True:
        x = yield
        print("value:",x)

g = foo() # g是一个生成器
next(g) # 程序运行到yield就停住了,等待下一个next
g.send(1)  # 咱们给yield发送值1,而后这个值被赋值给了x，而且打印出来,而后继续下一次循环停在yield处
g.send(2)  # 同上
next(g)  # 没有给x赋值，执行print语句，打印出None,继续循环停在yield处

咱们都知道，程序一旦执行到yield就会停在该处,而且将其返回值进行返回。上面的例子中，咱们并无设置返回值，全部默认程序返回的是None。咱们经过打印语句来查看一下第一次next的返回值：

print(next(g))

####输出结果#####
None

　　正如咱们所说的，程序返回None。接着程序往下执行，可是并无看到next()方法。为何还会继续执行yield语句后面的代码呢？这是由于，send()方法具备两种功能：第一，传值，send()方法，将其携带的值传递给yield，注意，是传递给yield，而不是x,而后再将其赋值给x；第二，send()方法具备和next()方法同样的功能，也就是说，传值完毕后，会接着上次执行的结果继续执行，知道遇到yield中止。这也就为何在调用g.send()方法后，还会打印出x的数值。有了上面的分析，咱们能够很快知道，执行了send(1)后，函数被中止在了yield处，等待下一个next()的到来。程序往下执行，有遇到了send(2)，其执行流程与send(1)彻底同样。

　　有了上述的分析，咱们能够总结出send()的两个功能：1.传值；2.next()。

　　既然send()方法有和next同样的做用，那么咱们可不能够这样作：

 

def foo():
    while True:
        x = yield
        print("value:",x)

g = foo()
g.send(1) #执行给yield传值,这样行不行呢?

 

　　很明显，是不行的。

 

 

TypeError: can't send non-None value to a just-started generator

 

　　错误提示:不能传递一个非空值给一个未启动的生成器。

　　也就是说，在一个生成器函数未启动以前，是不能传递数值进去。必须先传递一个None进去或者调用一次next(g)方法，才能进行传值操做。至于为何要先传递一个None进去，能够看一下官方说法。

Because generator-iterators begin execution at the top of the
    generator's function body, there is no yield expression to receive
    a value when the generator has just been created.  Therefore,
    calling send() with a non-None argument is prohibited when the
    generator iterator has just started, and a TypeError is raised if
    this occurs (presumably due to a logic error of some kind).  Thus,
    before you can communicate with a coroutine you must first call
    next() or send(None) to advance its execution to the first yield
    expression.

View Code

　　问题就来，既然在给yield传值过程当中，会调用next()方法，那么是否是在调用一次函数的时候，是否是每次都要给它传递一个空值？有没有什么简便方法来解决這个问题呢？答案，装饰器！！看下面代码:

def deco(func):  # 装饰器:用来开启协程
    def wrapper():
        res = func()
        next(res)
        return res  # 返回一个已经执行了next()方法的函数对象
    return wrapper
@deco
def foo():
    pass

　　上面我yield是没有返回值的，下面咱们看看有返回值的生成器函数。

def deco(func):
    def wrapper():
        res = func()
        next(res)
        return res
    return wrapper
@deco
def foo():
    food_list = []
    while True:
        food = yield food_list  #返回添加food的列表
        food_list.append(food)
        print("elements in foodlist are:",food)
g = foo()
print(g.send('苹果'))
print(g.send('香蕉'))
print(g.send('菠萝'))
###########输出结果为######
elements in foodlist are: 苹果
['苹果']
elements in foodlist are: 香蕉
['苹果', '香蕉']
elements in foodlist are: 菠萝
['苹果', '香蕉', '菠萝']

　　分析：首先，咱们要清楚，在函数执行以前，已经执行了一次next()(装饰器的功能)，程序中止yield。接着程序往下执行，遇到g.send()，而后将其值传递给food，而后再将得到的food添加到列表food_list中。打印出food，再次循环程序停在yield。程序继续执行，又遇到g.send()，其过程与上面是如出一辙的。看看如下的程序执行流程，你可能会更清楚。

　　

　　这里咱们要明确一点，yield的返回值和传给yield的值是两码事！！

　　yiedl的返回值就至关于return的返回值，这个值是要被传递出去的,而send()传递的值，是要被yield接受，供函数内部使用的的，明确这一点很重要的。那么上面的打印，就应该打印出yield的返回值，而传递进去的值则本保存在一个列表中。

3、实例

"""模拟:grep -rl 'root' /etc"""
import os
def deco(func):  # 用来开启协程
    def wrapper(*args,**kwargs):
        res = func(*args,**kwargs)
        next(res)  # res.seng(None)
        return res
    return wrapper
@deco
def search(target):
    while True:
        PATH = yield
        g = os.walk(PATH)  # 获取PATH目录下的文件，文件夹
        for par_dir, _, files in g:  #迭代解包,取出当前目录路径和文件名
            for file in files:
                file_path = r'%s\%s' %(par_dir,file)  # 拼接文件的绝对路径
                target.send(file_path)  # 给下一个
@deco
def opener(target, pattern=None):
    while True:
        file_path = yield
        with open(file_path, encoding='utf-8') as f:
            target.send((file_path, f))  # 将文件路径和文件对象一块儿传递给下一个函数的yield，由于在打印路径时候，须要打印出文件路径，只有从这里传递下去
@deco
def cat(target):
    while True:
        filepath, f = yield # 这里接收opener传递进来的路径和文件对象
        for line in f:
            tag = target.send((filepath, line))  # 一样，也要传递文件路径,而且获取下一个函数grep的返回值，从而判断该文件是否重复读取了
            if tag:  # 若是为真，说明该文件读取过了，则执行退出循环
                break
@deco
def grep(target, pattern):
    tag = False
    while True:
        filepath, line = yield tag  # 接受两个值，而且设置返回值，這个返回值要传递给发送消息的send()，也就是cat()函数send
        tag = False
        if pattern in line:  # 若是待匹配字符串在该行
            target.send(filepath)   # 把文件路径传递给priter
            tag = True   # 设置tag
@deco
def printer():
    while True:
        filename = yield
        print(filename)

调用方式:

PATH1 = r'D:\CODE_FILE\python\test'
search(opener(cat(grep(printer(), 'root')))).send(PATH1)

输出结果:

######找出了含有'root'的全部文件#######
D:\CODE_FILE\python\test\a.txt
D:\CODE_FILE\python\test\test1\c.txt
D:\CODE_FILE\python\test\test1\test2\d.txt

程序分析:

 　　有了上面的基础，咱们来分析一下上述程序的执行。

　　每个函数以前都有一个@deco装饰器，这个装饰器用于开启协程。首先咱们定义了一个search()，其内部有关键字yield，则search()是一个生成器。也就是说，咱们能够经过send()给其传递一个值进去。search()函数的功能 是：获取一个文件的绝对路径，并将這个绝对路径经过send()方法，在传递给下个含有yield的函数，也就是下面的opener函数。opener的yield接受了search()传递进来的路径，并将其赋值给了file_path，而后咱们根据這个路径，打开了一个文件，获取了一个文件对象f。而后咱们在将這个文件对象send()给cat()函数，這个函数功能是读取文件中的内容，咱们根据逐行读取文件内容，将每次读取到的内容，在send()给下一个函数，也就是grep()，這个函数功能是实现过滤操做。咱们从上一个函数cat()接受到的每一行内容，在grep()函数里面进行过滤处理，若是有匹配到的过滤内容，那么咱们将就过滤到的文件传递给下一个函数print()，该函数主要是打印出文件路径。也许，上述的描述内容你没看懂，下面看看这个程序的流程图：

　　　　　　　　

　　根据上述流程，咱们很清楚知道，send()传递给下一个函数的值。可是上述代码存在一个问题：若是待过滤的字符在一个文件中存在多个，而在读取文件的时候，咱们是一行一行地读取，而后再传递给下一个函数。咱们的目的是：过滤出包好pattern的文件，若是一个文件存在多个一样的pattern，那么就会输出屡次一样的文件名。这无疑是浪费内存，要解决这中问题，咱们能够经过yield的返回值来控制，每次读取时候的条件。具体实施，看上述代码注释。