1.生成器 #本质就是迭代器

1.1 生成器的构建方式

在python中有三种方式来创建生成器：

1.通过生成器函数

2.通过生成器推导式

3.python内置函数或者模块提供

1.2 生成器函数

我们先来研究通过生成器函数构建生成器。

def func():
    print(11)
    return 22

ret = func()
print(ret)
# 运行结果:
11
22

将函数中的return换成yield，这样func就不是函数了，而是一个生成器函数

def func():
    print(11)
    yield 22

我们这样写没有任何的变化,这是为什么呢? 我们来看看函数名加括号获取到的是什么?

def func():
    print(11)
    yield 22

ret = func()
print(ret)

# 运行结果:
<generator object func at 0x000001A575163888>

当我们调用函数的时候函数体里的代码会进行执行,当执行到yield的关键字的时候,发现我们是想声明一个生成器.程序就会返回一个生成器给我们

生成器的本质就是迭代器.迭代器如何取值，生成器就如何取值。所以我们可以直接执行next()或**_ _ next _ _()**方法来执行以下生成器

def func():
     print("111")
     yield 222

gener = func() # 这个时候函数不会执⾏. 而是获取到生成器
ret = next(gener) # 这个时候函数才会执行  推荐使用next()
#ret = gener.__next__() # 这个时候函数才会执行
print(ret)  # 并且yield会将func生产出来的数据 222 给了 ret。  

结果:
111
222

并且我的生成器函数中可以写多个yield。

def func():
    print(11)
    yield 22
    print(33)
    yield 44

print(func().__next__())    #启动了一个生成器
print(func().__next__())    #启动了另一个生成器

# 运行结果:
11
22
11
22

def func():
    print("111")
    yield 222
    print("333")
    yield 444

gener = func()
ret = gener.__next__()
print(ret)
ret2 = gener.__next__()
print(ret2)
ret3 = gener.__next__()
# 最后⼀个yield执⾏完毕. 再次__next__()程序报错   StopIteration异常
print(ret3)

当程序运行完最后一个yield,那么后面继续运行next()程序会报错，一个yield对应一个next，next超过yield数量，就会报错，与迭代器一样。

yield与return的区别：

return一般在函数中只设置一个，他的作用是终止函数，并且给函数的执行者返回值。

yield在生成器函数中可设置多个，他并不会终止函数，next会获取对应yield生成的元素。

应用场景：

我们来看一下这个需求：老男孩向楼下卖包子的老板订购了10000个包子.包子铺老板非常实在，一下就全部都做出来了　

def eat():
    lst = []
    for i in range(1,10000):
        lst.append('包子'+str(i))
    return lst

e = eat()
print(e)

这样做没有问题，但是我们由于学生没有那么多，只吃了2000个左右，剩下的8000个，就只能占着一定的空间，放在一边了。如果包子铺老板效率够高，我吃一个包子，你做一个包子，那么这就不会占用太多空间存储了，完美。

def eat():
    for i in range(1,10000):
        yield '包子'+str(i)

e = eat()
for i in range(200):
    next(e)

这两者的区别:

第一种是直接把包子全部做出来，占用内存。

第二种是吃一个生产一个，非常的节省内存，而且还可以保留上次的位置。

def eat():
    for i in range(1,10000):
        yield '包子'+str(i)

e = eat()
for i in range(200):
    next(e)
for i in range(300):
    next(e)
# 多次next包子的号码是按照顺序记录的。

1.3 send 方法（了解）

接下来我们再来认识一个新的东西,send方法

# next只能获取yield生成的值，但是不能传递值。
def gen(name):
    print(f'{name} ready to eat')
    while 1:
        food = yield
        print(f'{name} start to eat {food}')

g = gen('alex')
next(g)
next(g)
next(g)

# 而使用send这个方法是可以的。
def gen(name):
    print(f'{name} ready to eat')
    while 1:
        food = yield 222
        print(f'{name} start to eat {food}')

g = gen('alex')
next(g)  # 第一次必须用next让指针停留在第一个yield后面
# 与next一样，可以获取到yield的值
ret = g.send('骨头')
print(ret)

结果:
alex ready to eat
alex start to eat 骨头
222

def gen(name):
    print(f'{name} ready to eat')
    while 1:
        food = yield
        print(f'{name} start to eat {food}')

g = gen('alex')
next(g)
# 还可以给上一个yield发送值
g.send('骨头')
g.send('狗粮')
g.send('香肠')

send和next()区别:

相同点：

send 和 next()都可以让生成器对应的yield向下执行一次。

都可以获取到yield生成的值。

不同点：

第一次获取yield值只能用next不能用send（可以用send(None) ）。

send可以给上一个yield置传递值。

1.4 yield from

在python3中提供一种可以直接把可迭代对象中的每一个数据作为生成器的结果进行返回

# 对比yield 与 yield from
def func():
    lst = ['卫龙','老冰棍','北冰洋','牛羊配']
    yield lst
g = func()
print(g)
print(next(g))  # 只是返回一个列表

结果:
<generator object func at 0x0000018C18AB94F8>
['卫龙', '老冰棍', '北冰洋', '牛羊配']

def func():
    lst = ['卫龙','老冰棍','北冰洋','牛羊配']
    yield from lst
g = func()
print(g)
# 他会将这个可迭代对象(列表)的每个元素当成迭代器的每个结果进行返回。
print(next(g))
print(next(g))
print(next(g))
print(next(g))

结果:
<generator object func at 0x00000213E7D194F8>
卫龙
老冰棍
北冰洋
牛羊配

'''
yield from ['卫龙','老冰棍','北冰洋','牛羊配']
等同于：
    yield '卫龙'
    yield '老冰棍'
    yield '北冰洋'
    yield '牛羊配'

1.5 yield from 小坑

def func():
    lst1 = ['卫龙', '老冰棍', '北冰洋', '牛羊配']
    lst2 = ['馒头', '花卷', '豆包', '大饼']
    yield from lst1
    yield from lst2

g = func()
for i in g:
    print(i)

结果:
卫龙
老冰棍
北冰洋
牛羊配
馒头
花卷
豆包
大饼

巴特西

百万年薪python之路 -- 生成器