python生成器

world_in_world

已于 2024-04-06 16:59:56 修改

阅读量88

点赞数

分类专栏： python面向对象文章标签： python

于 2023-01-05 12:08:32 首次发布

本文链接：https://blog.csdn.net/world_in_world/article/details/128560927

版权

python面向对象专栏收录该内容

4 篇文章 0 订阅

订阅专栏

我们学习完推导式之后，发现推导式就是在容器中使用一个for循环而已，为什么没有元组推导式？元组推导式的真名应该称为生成器表达式。

什么是生成器

生成器本质上就是一个迭代器，是定义迭代器的一种方式，是允许自定义逻辑的迭代器。生成器使用 generator 表示。

迭代器和生成器的区别

迭代器本身是系统内置的，无法重写内置的逻辑结构；而生成器是用户自定义的，可以重写逻辑结构。所以生成器就是一个迭代器，只是我们将自己写的迭代器叫做生成器以作区分。

创建方式

生成器有两种创建方式：

1、生成器表达式，就是“元组推导式”

2、生成器函数，就是使用def定义的函数，内部使用 yield关键字

生成器表达式

基本语法

from collections.abc import Iterator, Iterable
# 生成器表达式（元组推导式）
gen = (i * 2 for i in range(1, 11))  # gen 就是生成器
print(isinstance(gen, Iterable))  # 判断是否是迭代对象
print(isinstance(gen, Iterator))  # 判断是否是迭代器

生成器函数

生成器函数的定义其实和普通函数的定义一样，都要使用 def关键字来定义，唯一的要求就是要使用 yield关键字。

要注意，生成器函数就是一个函数，是使用了yield语句的函数，只不过生成器函数是用来定义生成器的。

yield关键字

yield这个关键字其实类似于return关键字，return关键字是在函数中使用，用来返回数据，yield关键字也是在函数中使用，用来返回数据，但是和return相比还有其它的不同之处。

yield和return

共同点

执行到对应语句的时候，就会返回对应的值。

不同点

return语句执行之后，就会跳出函数，return语句之后的所有作用域语句都不会执行，当再次调用函数时，整个函数又会重头执行。

yield语句执行之后，系统会记住跳出的位置，并跳出函数，当再次启动生成器时，就会从上一次函数跳出的地方继续往后执行。是不是和迭代器的取值有异曲同工之处？

yield的使用方法

第一种是在关键字后面直接添加状态值，这是推荐使用的方法；

第二种是将yield作为一个函数使用，就是在yield后面使用圆括号，在括号中填写返回的值。

生成器函数的基本使用

# 1、定义一个生成器函数
def myGen():
    print(1)
    yield 11

    print(2)
    yield 22

    print(3)
    yield 33

    print(4)

from collections.abs import Iterator
# 2、生成生成器对象
gen = myGen()  # 调用生成器函数（不会真正执行内部代码），返回一个生成器对象
res = isinstance(gen, Iterator)
print(res)  # 结果返回True，说明生成器本质上就是一个迭代器

# 3、启动生成器
print(next(gen))  # 调用next()或__next__()才能真正执行生成器函数内部代码
# print(gen.__next__())
"""
结果：
1
11
"""
print(next(gen))
"""
结果：
2
22
"""
print(next(gen))
"""
结果：
3
33
"""
print(next(gen))  # 必须返回一个状态值，否则报错StopIteration，此处没有可执行的yield语句
"""
结果：
4
Traceback (most recent call last):
  File "C:/daily documents/python_project/测试/test.py", line 68, in <module>
    print(next(gen))
StopIteration
"""

send的使用

send()是生成器的内置函数，send()类似于next()，也能启动生成器，返回生成器函数中的状态值。除此之外send()还能传送值。

实例

def myGen():
   print('-'*40)
   res = yield 100

   print(res, 'xxx')
   print('-'*40)
   res = yield 200

   print(res, 'yyy')
   print('-'*40)
   res = yield 300

   print(res, 'zzz')

gen = myGen()
# send()有一个参数，在第一次调用send()时，传递的数据必须是None，这是硬性语法，传入send()的参数是要传递给上一个yield语句作为状态值，即第一次调用g.send(None)

第一次调用

res = gen.send(None) print(res)

""" 结果： ---------------------------------------- 100 """

第一次调用执行了以下语句：

1 2	`print('-'*40)` `res = yield` `100`

执行到yield 100时，由于yield首次出现，之前没有出现过yield，所以按道理说send()是不能传入任何值的，但是send()规定必须传入一个参数，因此只能传入None，这是硬性语法。

这里注意，res = yield 100中的 res 此时没有任何意义。因为这个一条语句我们目前只执行了一半，即只执行了yield 100，还有 res 的赋值没有完成，所以现在的 res 没有任何意义。

第一次调用生成器，返回100，这个100则是语句yield 100返回的值。

第二次调用

res = next(gen)

print(res)

"""

结果：

None xxx

----------------------------------------

200

"""

第二次调用执行了以下语句：

res = yield 100

print(res, 'xxx')

print('-'*40)

res = yield 200

注意，生成器函数再次调用的时候，会从上一次yield返回值的地方开始执行，这里就是res = yield 100，但是该语句第二次调用的时候，只会执行一半即res 的赋值，因为另一半即yield 100在第一次调用的时候已经执行完毕，但是第二次调用使用的是next()，next()无法传送值，所以 res 就没有被赋值，打印 res 时返回None。

第三次调用

res = gen.send('第三次调用')

print(res)

"""

结果：

第三次调用 yyy

----------------------------------------

300

"""

第三次调用执行了以下语句：

res = yield 200

print(res, 'yyy')

print('-'*40)

res = yield 300

这次和第二次的调用基本相同，但是这次使用send()调用，所以传送了值'第三次调用'过去，即将值赋值给了res。

第四次调用

res = gen.send(None)

print(res)

"""

结果：

None zzz

StopIteration （报错）

"""

第四次调用执行了以下语句：

1 2	`res` `=` `yield` `300` `print(res,` `'zzz')`

由于没有可执行的yield语句，所以报错StopIteration。

可迭代对象的优化

如果需要制定一个容器供我们遍历使用，优先使用迭代器而不是容器这样的一个普通的可迭代对象。如果需要在一个循环中遍历一个容器供我们使用，但是这个容器中的值非常多，使得这个容器占据的内存空间非常大，导致程序运行非常慢，这个时候就需要使用迭代器或者生成器去遍历，迭代器每次遍历只占据当次遍历时的内存空间，因此非常的节省资源，所以这就是优先使用迭代器的理由。