【一】什么是生成器？#

Python中的生成器是一种特殊的迭代器，可以在需要时生成数据，而不必提前从内存中生成并存储整个数据集。
通过生成器，可以逐个生成序列中的元素，而无需一次性生成整个序列。
生成器在处理大数据集时，具有节省内存、提高效率的特点。

【二】生成器有两种创建方式#

【1】列表推导式#

使用列表推导式时，可以将列表推导式的方括号改为圆括号，即可创建一个生成器。

1
# 列表生成式生成列表
2
start_list = [x * 2 for x in range(5)]
3

4
print(start_list)
5
# [0, 2, 4, 6, 8]
6

7
# 将列表改成元祖，看起来像元祖推导式，其实是一个生成器对象
8
G = (x * 2 for x in range(5))
9

10
print(G)
11
# <generator object <genexpr> at 0x000001873491CC80>
12

13
# 生成器对象可以强转成列表
14
print(list(G))
15
# [0, 2, 4, 6, 8]

怎么打印出生成器的每一个元素呢？
- 如果要一个一个打印出来，可以通过 next() 函数获得生成器的下一个返回值
生成器保存的是算法
- 每次调用 next(G) ，就计算出 G 的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出 StopIteration 的异常。
- 当然，这种不断调用 next() 实在是太变态了，正确的方法是使用 for 循环，因为生成器也是可迭代对象。
- 所以，我们创建了一个生成器后，基本上永远不会调用 next() ，而是通过 for 循环来迭代它，并且不需要关心 StopIteration 异常。

1
# 将列表改成元祖，看起来像元祖推导式，其实是一个生成器对象
2
G = (x * 2 for x in range(5))
3

4
# 生成器本身就是一种迭代器 ， 可以for 遍历生成器对象
5
for i in G:
6
    print(i)
7

8
# 0
9
# 2
10
# 4
11
# 6
12
# 8

【2】yield关键字#

（1）yield关键字介绍#

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

1
def my_generator():
2
    yield 1
3
    yield 2
4
    yield 3
5

6
g = my_generator()
7
print(next(g))  # 输出：1
8
print(next(g))  # 输出：2
9
print(next(g))  # 输出：3

在上面的代码中，my_generator()是一个生成器函数，通过yield关键字逐个生成值。
在调用该函数时，会得到一个生成器对象。
通过调用next()函数，可以逐个返回生成器中的值。

（2）yield关键字使用#

在函数内可以采用表达式形式的yield

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

可以拿到函数的生成器对象持续为函数体send值

1
# 定义生成器
2
def eater():
3
    print('开始吃饭 ovo ')
4
    while True:
5
        food = yield
6
        print(f'得到的食物是 :>>>> {food}, 开始吃饭喽 :>>>> {food}')
7

8

9
# 得到生成器对象
10
food_eater = eater()
11

12
# 需要事先”初始化”一次，让函数挂起在food=yield，等待调用food_eater.send()方法为其传值
13

14
# food_eater.send(None)
15
# 等同于
16
next(food_eater)
17

18
# 开始吃饭 ovo
19

20
food_eater.send('包子')
21
# 得到的食物是 :>>>> 包子, 开始吃饭喽 :>>>> 包子
22

23
food_eater.send('鸡腿')
24
# 得到的食物是 :>>>> 鸡腿, 开始吃饭喽 :>>>> 鸡腿

编写装饰器来完成为所有表达式形式yield对应生成器的初始化操作

1
# 定义初始化装饰器
2
def init(func):
3
    def wrapper(*args, **kwargs):
4
        g = func(*args, **kwargs)
5
        next(g)
6
        return g
7

8
    return wrapper
9

10

11
# 定义生成器 并 使用装饰器初始化
12
@init
13
def eater():
14
    print('开始吃饭 ovo ')
15
    while True:
16
        food = yield
17
        print(f'得到的食物是 :>>>> {food}, 开始吃饭喽 :>>>> {food}')
18

19

20
print("得到生成器对象之前")
21
# 得到生成器对象
22
food_eater = eater()
23
print("得到生成器对象之后")
24

25
# 得到生成器对象之前
26
# 开始吃饭 ovo
27
# 得到生成器对象之后
28

29
food_eater.send('包子')
30
# 得到的食物是 :>>>> 包子, 开始吃饭喽 :>>>> 包子
31

32
food_eater.send('鸡腿')
33
# 得到的食物是 :>>>> 鸡腿, 开始吃饭喽 :>>>> 鸡腿

表达式形式的yield也可以用于返回多次值

1
def eater():
2
    print('开始做饭 ovo ')
3
    food_list = []
4
    while True:
5
        food = yield food_list
6
        food_list.append(food)
7
        print(f"做饭喽 :>>>> {food_list}")
8

9

10
# 得到生成器对象
11
food_eater = eater()
12

13
next(food_eater)
14
# 开始做饭 ovo
15

16
food_eater.send('包子')
17
# 做饭喽 :>>>> ['包子']
18

19
food_eater.send('鸡腿')
20
# 做饭喽 :>>>> ['包子', '鸡腿']

【三】yield+next详解#

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

1
def my_range(start, stop, step=1):
2
    print('start...')
3
    while start < stop:
4
        yield start
5
        start += step
6
    print('end...')
7

8

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

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

1
def my_range(start, stop, step=1):
2
    print('start...')
3
    while start < stop:
4
        yield start
5
        start += step
6
    print('end...')
7

8

9
g = my_range(0, 3)
10
print(g)  # <generator object my_range at 0x00000179B0912A40>
11
print(g.__iter__)  # <method-wrapper '__iter__' of generator object at 0x000002AFE95A8430>
12
print(g.__next__)  # <method-wrapper '__next__' of generator object at 0x000002AFE95A8430>
13

14
# 生成方式一
15
g_iter = iter(g)
16
print(g_iter)  # <generator object my_range at 0x00000288EAEE22D0>
17
# start...
18
print(next(g_iter))
19
# 0
20
print(next(g_iter))
21
# 1

1
def my_range(start, stop, step=1):
2
    print('start...')
3
    while start < stop:
4
        yield start
5
        start += step
6
    print('end...')
7

8

9
g = my_range(0, 3)
10
print(g)  # <generator object my_range at 0x00000179B0912A40>
11
print(g.__iter__)  # <method-wrapper '__iter__' of generator object at 0x000002AFE95A8430>
12
print(g.__next__)  # <method-wrapper '__next__' of generator object at 0x000002AFE95A8430>
13

14
# 生成方式二
15
print(next(g))
16
# start...
17
print(next(g))
18
# 0
19
print(next(g))
20
# 1

next原理详解

1
def my_range(start, stop, step=1):
2
    print('start...')
3
    while start < stop:
4
        yield start
5
        start += step
6
    print('end...')
7

8

9
g = my_range(0, 3)
10
print(g)  # <generator object my_range at 0x00000179B0912A40>
11
print(g.__iter__)  # <method-wrapper '__iter__' of generator object at 0x000002AFE95A8430>
12
print(g.__next__)  # <method-wrapper '__next__' of generator object at 0x000002AFE95A8430>
13

14

15
# 触发函数执行直到遇到yield则停止,将yield后的值返回，并在当前位置挂起函数
16
print(f"第一次 :>>>> {next(g)}")
17
# start...
18
# 第一次 :>>>> 0
19

20
# 再次调用next(g)，函数从上次暂停的位置继续执行，直到重新遇到yield...
21
print(f"第二次 :>>>> {next(g)}")
22
# 第二次 :>>>> 1
23

24
# 周而复始...
25
print(f"第三次 :>>>> {next(g)}")
26
# 第三次 :>>>> 2
27
# end...
28

29
print(f"第四次 :>>>> {next(g)}")
30
'''
31
Traceback (most recent call last):
32
  File "E:\PythonProjects\生成器.py", line 33, in <module>
33
    print(f"第四次 :>>>> {next(g)}")
34
StopIteration
35
'''

【四】生成器的特点#

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

音乐

音乐

【一】什么是生成器？#

【二】生成器有两种创建方式#

【1】列表推导式#

【2】yield关键字#

（1）yield关键字介绍#

（2）yield关键字使用#

【三】yield+next详解#

【四】生成器的特点#

支持与分享

音乐

Python高级之生成器

【一】什么是生成器？#

【二】生成器有两种创建方式#

【1】列表推导式#

【2】yield关键字#

（1）yield关键字介绍#

（2）yield关键字使用#

【三】yield+next详解#

【四】生成器的特点#

支持与分享