生成器

生成器介绍

【一】生成器与yield

  • 若函数体包含yield关键字，再调用函数，并不会执行函数体代码，得到的返回值即生成器对象
>>> def my_range(start,stop,step=1):
...     print('start...')
...     while start < stop:
...         yield start
...         start+=step
...     print('end...')
... 
>>> g=my_range(0,3)
>>> g
<generator object my_range at 0x104105678>
  • 生成器内置有__iter__ 和 __next__ 方法
    • 所以生成器本身就是一个迭代器
>>> g.__iter__
<method-wrapper '__iter__' of generator object at 0x1037d2af0>
>>> g.__next__
<method-wrapper '__next__' of generator object at 0x1037d2af0>
  • 因而我们可以用 next(生成器) 触发生成器所对应函数的执行
>>> next(g) # 触发函数执行直到遇到yield则停止,将yield后的值返回，并在当前位置挂起函数
start...
0
>>> next(g) # 再次调用next(g)，函数从上次暂停的位置继续执行，直到重新遇到yield...
1
>>> next(g) # 周而复始...
2
>>> next(g) # 触发函数执行没有遇到yield则无值返回，即取值完毕抛出异常结束迭代
end...
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
  • 既然生成器对象属于迭代器
    • 那么必然可以使用for循环迭代
  • 如下：
>>> for i in countdown(3):
...     print(i)
... 
countdown start
3
2
1
Done!

  • 有了yield关键字

    • 我们就有了一种自定义迭代器的实现方式。

    • yield可以用于返回值,但不同于return

      • 函数一旦遇到return就结束了

      • 而yield可以保存函数的运行状态挂起函数，用来返回多次值

【二】yield表达式应用

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

>>> def eater():
...     print('Ready to eat')
...     while True:
...         food=yield
...         print('get the food: %s, and start to eat' %food)
...

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

>>> g=eater() # 得到生成器对象
>>> g
<generator object eater at 0x101b6e2b0>

>>> next(e) # 需要事先”初始化”一次，让函数挂起在food=yield，等待调用g.send()方法为其传值
Ready to eat

>>> g.send('包子')
get the food: 包子, and start to eat
    
>>> g.send('鸡腿')
get the food: 鸡腿, and start to eat

针对表达式形式的yield

​ 生成器对象必须事先被初始化一次，让函数挂起在food=yield的位置

​ 等待调用g.send()方法为函数体传值

g.send(None)等同于next(g)。

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

def init(func):
    def wrapper(*args,**kwargs):
        g=func(*args,**kwargs)
        next(g)
        return g
    return wrapper

@init
def eater():
    print('Ready to eat')
    while True:
        food=yield
        print('get the food: %s, and start to eat' %food)

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

  • 即变量名=yield 值的形式
>>> def eater():
...     print('Ready to eat')
...     food_list=[]
...     while True:
...         food=yield food_list
...         food_list.append(food)
... 
>>> e=eater()
>>> next(e)
Ready to eat
[]
>>> e.send('蒸羊羔')
['蒸羊羔']
>>> e.send('蒸熊掌')
['蒸羊羔', '蒸熊掌']
>>> e.send('蒸鹿尾儿')
['蒸羊羔', '蒸熊掌', '蒸鹿尾儿']

生成器详解

【一】什么是生成器？

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

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

  • 使用列表推导式或使用yield关键字。
    • 使用列表推导式时，可以将列表推导式的方括号改为圆括号，即可创建一个生成器。
    • 使用yield关键字定义一个生成器函数时，生成器函数中的yield语句会暂停函数执行并返回一个值，下一次调用该函数时会继续执行并返回下一个值。

【三】示例：

def my_generator():
    yield 1
    yield 2
    yield 3

g = my_generator()
print(next(g))  # 输出：1
print(next(g))  # 输出：2
print(next(g))  # 输出：3

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

【四】生成器的优点

  • 包括节省内存、提高效率，适用于处理大数据集的场景。
  • 但是需要注意，一旦生成器函数执行完成，就无法再次调用该函数，会引发StopIteration异常。
  • 生成器不可以直接修改元素，只能生成下一个元素。
  • 总之，生成器是Python中非常有用的语言特性之一，它能够优化Python代码的内存使用和执行效率，并且可以非常高效地处理大数据集。

生成器原理

【一】引言

  • 通过列表生成式，我们可以直接创建一个列表。
  • 但是，受到内存限制，列表容量肯定是有限的。
  • 而且
    • 创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。
  • 所以
    • 如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？
    • 这样就不必创建完整的list，从而节省大量的空间。
  • 在Python中，这种一边循环一边计算的机制，称为生成器：generator。

【二】生成器创建方法

（1）列表生成式的 [] 改成 ()
L = [x * 2 for x in range(5)]

print(L)
# [0, 2, 4, 6, 8]
（2）将[]改成()
G = (x * 2 for x in range(5))

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

【三】小结

  • 生成器是这样一个函数，它记住上一次返回时在函数体中的位置。
  • 对生成器函数的第二次（或第 n 次）调用跳转至该函数中间，而上次调用的所有局部变量都保持不变。
  • 生成器不仅“记住”了它数据状态
    • 生成器还“记住”了它在流控制构造（在命令式编程中，这种构造不只是数据值）中的位置。

【四】生成器的特点

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

__EOF__

本文作者：Chimengmeng
本文链接：https://www.cnblogs.com/dream-ze/p/17457638.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！
posted @ 2023-06-05 14:10  Chimengmeng  阅读(57)  评论(0)  编辑  收藏  举报