Python yield 用法
参考:菜鸟教程 https://www.runoob.com/w3cnote/python-yield-used-analysis.html
如何生成斐波那契數列
斐波那契(Fibonacci)數列是一个非常简单的递归数列,除第一个和第二个数外,任意一个数都可由前两个数相加得到。用计算机程序输出斐波那契數列的前 N 个数是一个非常简单的问题,许多初学者都可以轻易写出如下函数:
清单 1. 简单输出斐波那契數列前 N 个数
def fab(max): n, a, b = 0, 0, 1 while n < max: print(b) a, b = b, a + b n = n + 1 fab(5)
结果没有问题,但有经验的开发者会指出,直接在 fab 函数中用 print 打印数字会导致该函数可复用性较差,因为 fab 函数返回 None,其他函数无法获得该函数生成的数列。
要提高 fab 函数的可复用性,最好不要直接打印出数列,而是返回一个 List。以下是 fab 函数改写后的第二个版本:
清单 2. 输出斐波那契數列前 N 个数第二版
def fab(max): n, a, b = 0, 0, 1 L = [] while n < max: L.append(b) a, b = b, a + b n = n + 1 return L for n in fab(5): print(n)
改写后的 fab 函数通过返回 List 能满足复用性的要求,但是更有经验的开发者会指出,该函数在运行中占用的内存会随着参数 max 的增大而增大,如果要控制内存占用,最好不要用 List
来保存中间结果,而是通过 iterable 对象来迭代。例如代码:
清单 3. 通过 iterable 对象来迭代
class Fab(object): def __init__(self, max): self.max = max self.n, self.a, self.b = 0, 0, 1 def __iter__(self): return self def next(self): if self.n < self.max: r = self.b self.a, self.b = self.b, self.a + self.b self.n = self.n + 1 return r raise StopIteration() fb = Fab(5) print(fb.next()) print(fb.next()) print(fb.next()) print(fb.next()) print(fb.next()) # print(fb.next()) #报错 StopIteration()
然而,使用 class 改写的这个版本,代码远远没有第一版的 fab 函数来得简洁。如果我们想要保持第一版 fab 函数的简洁性,同时又要获得 iterable 的效果,yield 就派上用场了:
清单 5. 使用 yield 的第四版
def fab(max): n, a, b = 0, 0, 1 while n < max: yield b # 使用 yield # print b a, b = b, a + b n = n + 1 print('第%s次执行'%n) fb = fab(5) print(fb.__next__()) for n in fab(5): print(n)
第四个版本的 fab 和第一版相比,仅仅把 print(b) 改为了 yield b,就在保持简洁性的同时获得了 iterable 的效果。调用第四版的 fab 和第二版的 fab 完全一致
总结:
简单地讲,yield 的作用就是把一个函数变成一个 generator,带有 yield 的函数不再是一个普通函数,Python 解释器会将其视为一个 generator。调用 fab(5) 不会执行 fab 函数,而是返回一个 iterable 对象!在 for 循环执行时,每次循环都会执行 fab 函数内部的代码,
执行到 yield b 时,fab 函数就返回一个迭代值,下次迭代时,代码从 yield b 的下一条语句继续执行,而函数的本地变量看起来和上次中断执行前是完全一样的,于是函数继续执行,直到再次遇到 yield。
也可以手动调用 fab(5) 的 next() 方法(因为 fab(5) 是一个 generator 对象,该对象具有 next() 方法),这样我们就可以更清楚地看到 fab 的执行流程:
清单 6. 执行流程
>>>f = fab(5) >>> f.next() 1 >>> f.next() 1 >>> f.next() 2 >>> f.next() 3 >>> f.next() 5 >>> f.next() Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration
当函数执行结束时,generator 自动抛出 StopIteration 异常,表示迭代完成。在 for 循环里,无需处理 StopIteration 异常,循环会正常结束。
我们可以得出以下结论:
一个带有 yield 的函数就是一个 generator,它和普通函数不同,生成一个 generator 看起来像函数调用,但不会执行任何函数代码,直到对其调用 next()(在 for 循环中会自动调用 next())才开始执行。
虽然执行流程仍按函数的流程执行,但每执行到一个 yield 语句就会中断,并返回一个迭代值,下次执行时从 yield 的下一个语句继续执行。看起来就好像一个函数在正常执行的过程中被 yield 中断了数次,每次中断都会通过 yield 返回当前的迭代值。
yield 的好处是显而易见的,把一个函数改写为一个 generator 就获得了迭代能力,比起用类的实例保存状态来计算下一个 next() 的值,不仅代码简洁,而且执行流程异常清晰。
如何判断一个函数是否是一个特殊的 generator 函数?可以利用 isgeneratorfunction 判断:
清单 7. 使用 isgeneratorfunction 判断函数是否是可迭代函数
>>>from inspect import isgeneratorfunction >>> isgeneratorfunction(fab) True
要注意区分 fab 和 fab(5),fab 是一个 generator function,而 fab(5) 是调用 fab 返回的一个 generator,好比类的定义和类的实例的区别:
return 的作用
在一个 generator function 中,如果没有 return,则默认执行至函数完毕,如果在执行过程中 return,则直接抛出 StopIteration 终止迭代。
案例:yield --->大文件读写(4G内存电脑读写10G文件怎么办??)
如果直接对文件对象调用 read() 方法,会导致不可预测的内存占用。好的方法是利用固定长度的缓冲区来不断读取文件内容。通过 yield,我们不再需要编写读文件的迭代类,就可以轻松实现文件读取:
def read_file(fpath): BLOCK_SIZE = 1024 with open(fpath, 'rb') as f: while True: block = f.read(BLOCK_SIZE) if block: yield block else: return def write_file(fpath,cn): with open(fpath, 'ab+') as f: f.write(cn) for cn in read_file("111.mp4"): write_file("222.mp4",cn)
案例:
案例1-每次next() 函数执行停到yield,下次如果有send则给停在此处的yield赋值,否则继续往下执行

def f(): print("ok") s=yield 6 print('------->',s) print("ok2") s2 = yield print("===========>",s2) # yield 111 gen=f() # print(gen) # next(gen) ret1=gen.__next__() print(ret1) ret2 =gen.send("xiong") ## 从第3行代码开始执行,s = "xiong" print(ret2) ret3 =gen.send("justin") ## 从第6行代码开始执行,s2 = "justin" print(ret3) ## 报错,StopIteration
案例2-yield吃饭点菜模型

def eater(name): print('%s 准备开始吃饭啦' %name) food_list=[] while True: food=yield food_list print('%s 吃了 %s' % (name,food)) food_list.append(food) g=eater('xiong') g.send(None) #对于表达式形式的yield,在使用时,第一次必须传None,g.send(None)等同于next(g) g.send('蒸羊羔') g.send('蒸鹿茸') g.send('蒸熊掌') g.send('烧素鸭') g.close() #关闭生成器,后面g.send() 会报错 # g.send('烧素鹅') # g.send('烧鹿尾')
注意:
对于表达式形式的yield,在使用时,第一次必须传None,g.send(None)等同于next(g)
案例3-生孩子模型

import time def test(): print("开始生孩子了。。。") yield "我" #第1次执行 __next__() 碰到一个yield 返回,函数保留到该状态 time.sleep(1) print("开始生儿子了。。。") #第2次执行 __next__() 碰到一个yield 返回,函数保留到该状态 yield "儿子" time.sleep(1) print("开始生孙子了。。。") #第3次执行 __next__() 碰到一个yield 返回,函数保留到该状态 sunzi = yield "孙子" print('接收到send发来的值--->',sunzi) time.sleep(1) yield print("开始生重孙子了。。。") #第4次执行 __next__() 碰到一个yield 返回,函数保留到该状态 yield "重孙子" res = test() print(res) #res 是一个生成器对象<generator object test at 0x00000174FBCF10A0> y1 = res.__next__() #开始生孩子了。。。 print(y1) # 我 y2 = next(res) #开始生儿子了。。。 print(y2) # 儿子 y3 = next(res) #开始生孙子了。。。 print(y3) #孙子 res.send('孙子生出来了没有?') #接收到send发来的值---> 孙子生出来了没有? next(res)