【一】什么是生成器

• Python中的生成器是一种特殊的迭代器
• 可以在需要时生成数据，而不必提前从内存中生成并存储整个数据集
• 通过生成器，可以逐个生成序列中的元素，而无需一次性生成整个序列

【二】生成器的创建方式

【1】列表推导式

# 列表生成式生成列表
num_list = [i for i in range(10)]
print(num_list)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 将列表的中括号变成小括号,变成元祖，生成的是一个生成器对象
num_list = (i for i in range(10))
print(num_list)
# <generator object <genexpr> at 0x000001D26E884270>

#可以利用for循环来打印生成器的每一个元素
num_list = (i for i in range(5))
for i in num_list:
    print(i)
# 0
# 1
# 2
# 3
# 4

【2】yield关键字

（1）yield关键字介绍

• 使用yield关键字定义一个生成器函数时，生成器函数中的yield语句会暂停函数执行并返回一个值，下一次调用该函数时会继续执行并返回下一个值

def add():
    yield 1
    yield 2
    yield 3


res = add()
print(next(res))  # 1
print(next(res))  # 2
print(next(res))  # 3


def add(i):
    while True:
        yield i


res = add(1)
print(next(res))  # 1
res = add(2)
print(next(res))  # 2
res = add(3)
print(next(res))  # 3

（2）yield关键字实例使用

def eater():
    print('开始吃饭 ovo ')
    while True:
        food = yield
        print(f'得到的食物是 :>>>> {food}, 开始吃饭喽 :>>>> {food}')


eater = eater()
print(eater.__next__())
print(eater.__next__())
# 开始吃饭 ovo
# None   yield中没有返回值
# 得到的食物是 :>>>> None, 开始吃饭喽 :>>>> None
# None   在生成器内部走了一圈回来又到了yield，但是yield没有返回值

#需要给生成器传值
eater = eater()
# 需要事先”初始化”一次，让函数挂起在food=yield，等待调用eater.send()方法为其传值
# eater.send(None)
# 等同于
next(eater)
eater.send('土豆丝')
eater.send('酸菜鱼')
# 开始吃饭 ovo
# 得到的食物是 :>>>> 土豆丝, 开始吃饭喽 :>>>> 土豆丝
# 得到的食物是 :>>>> 酸菜鱼, 开始吃饭喽 :>>>> 酸菜鱼

【三】装饰器 + 生成器

def outer(func):
    # func 我的生成器函数
    def inner(*args, **kwargs):
        # function得到的生成器对象
        function = func(*args, **kwargs)
        # 调用自己生成器向下走
        next(function)
        # 走回来的返回值返回出去
        return function

    return inner


@outer
def eater():
    print('开始吃饭 ovo ')
    while True:
        food = yield
        print(f'得到的食物是 :>>>> {food}, 开始吃饭喽 :>>>> {food}')


eater = eater()
eater.send('土豆丝')
eater.send('酸菜鱼')
# 开始吃饭 ovo 
# 得到的食物是 :>>>> 土豆丝, 开始吃饭喽 :>>>> 土豆丝
# 得到的食物是 :>>>> 酸菜鱼, 开始吃饭喽 :>>>> 酸菜鱼

【四】生成器内部修改可变数据类型

def outer(func):
    # func 我的生成器函数
    def inner(*args, **kwargs):
        # g 得到的生成器对象
        function = func(*args, **kwargs)
        # 调用自己生成器向下走
        next(function)
        # 走回来的返回值返回出去
        return function

    return inner


@outer
def eater():
    print('开始吃饭 ovo ')
    food_list = [] #定于一个空字典
    while True:
        food = yield
        food_list.append(food) #将获取的元素一个一个加到列表中
        print(f'得到的食物是 :>>>> {food}, 开始吃饭喽 :>>>> {food}')
        print(food_list)


eater = eater()
eater.send('土豆丝')
eater.send('酸菜鱼')
# 开始吃饭 ovo 
# 得到的食物是 :>>>> 土豆丝, 开始吃饭喽 :>>>> 土豆丝
# ['土豆丝']
# 得到的食物是 :>>>> 酸菜鱼, 开始吃饭喽 :>>>> 酸菜鱼
# ['土豆丝', '酸菜鱼']

【五】yield+next详解

• 若函数体包含yield关键字，再调用函数，并不会执行函数体代码，得到的返回值即生成器对象

def my_range(start, stop, step=1):
    print('start...')
    while start < stop:
        yield start
        start += step
    print('end...')


res = my_range(0, 3)
print(g) # <generator object my_range at 0x0000019958788430>

• 生成器内置有__iter__和__next__方法，所以生成器本身就是一个迭代器

def my_range(start, stop, step):
    print('start...')
    while start < stop:
        yield start
        start += step
    print('end...')


res = my_range(0, 10, 2)
print(res)  # <generator object my_range at 0x00000171824A4270>
print(res.__iter__)  # <method-wrapper '__iter__' of generator object at 0x0000012CE8CA5BD0>
print(res.__next__)  # <method-wrapper '__next__' of generator object at 0x0000012CE8CA5BD0>
print(res.__next__())
print(res.__next__())
print(next(res))
print(next(res))
print(next(res))
print(next(res))
# start...
# 0
# 2
# 4
# 6
# 8
# end...
# Traceback (most recent call last):
#   File "D:\Python\pythonProject\pythonProject1\demo7.py", line 383, in <module>
#     print(next(res))
# StopIteration

#在函数内部加上异常捕获
def init_iter(func):
    def inner(*args, **kwargs):
        try:
            generator = func(*args, **kwargs)
            next(generator)
            return generator
        except StopIteration:
            pass

    return inner


def range_(start, stop, step):
    while start < stop:
        yield start
        start += step


# for 循环内部做了异常捕获
for i in range_(0, 5, 1):
    print(i)


def my_range(start, stop, step):
    def range_(start, stop, step):
        while start < stop:
            yield start
            start += step

    res = range_(start, stop, step)
    while True:
        try:
            print(res.__next__())
        except StopIteration:
            break


res = my_range(start=1, stop=5, step=1)											

【六】生成器的特点

• 节约内存
• 迭代到下一次的调用时，所使用的参数都是第一次所保留下的
• 在整个所有函数调用的参数都是第一次所调用时保留的，而不是新创建的