Python生成器详解

广告位

生成器和法代器的功能非常相似,它也会提供 __next__() 方法,这意味着程序同样可调用内置的 next(…

生成器和法代器的功能非常相似,它也会提供 __next__() 方法,这意味着程序同样可调用内置的 next() 函数来获取生成器的下一个值,也可使用 for 循环来遍历生成器。

生成器与迭代器的区别在于,迭代器通常是先定义一个迭代器类,然后通过创建实例来创建迭代器;而生成器则是先定义一个包含 yield 语句的函数,然后通过调用该函数来创建生成器。

生成器是一种非常优秀的语法,Python 使用生成器可以让程序变得很优雅。

创建生成器

创建生成器需要两步操作:

  1. 定义一个包含 yield 语句的函数。
  2. 调用第 1 步创建的函数得到生成器。

下面程序使用生成器来定义一个差值递增的数列。程序先定义了一个包含 yield 语句的函数:

  def test(val, step):      print("--------函数开始执行------")      cur = 0      # 遍历0~val      for i in range(val):          # cur添加i*step          cur += i * step          yield cur

上面函数与前面介绍的普通函数的最大区别在于 yield cur 这行,如果将这行代码改为 print(cur),那么这个函数就显得比较普通了,该函数只是简单地遍历区间,并将循环计数器乘以 step 后添加到 cur 变量上,该数列中两个值之间的差值会逐步递增。

如果将上面的 yield cur 语句改为 print(cur, end =''),执行 test(10, 2) 函数将会看到如下输出结果:

——–函数开始执行——
0 2 6 12 20 30 42 56 72 90

yield cur 语句的作用有两点:

  1. 每次返回一个值,有点类似于 return 语句。
  2. 冻结执行,程序每次执行到 yield 语句时就会被暂停。

在程序被 yield 语句冻结之后,当程序再次调用 next() 函数获取生成器的下一个值时,程序才会继续向下执行。

需要指出的是,调用包含 yield 语句的函数并不会立即执行,它只是返回一个生成器。只有当程序通过 next() 函数调用生成器或遍历生成器时,函数才会真正执行。

保留上面函数中的 yield cur 语句,执行如下语句:

  # 执行函数,返回生成器  t = test(10, 2)  print('=================')  # 获取生成器的第一个值  print(next(t)) # 0,生成器“冻结”在yield处  print(next(t)) # 2,生成器再次“冻结”在yield处

运行上面代码,可以看到如下输出结果:

=================
——–函数开始执行——
0
2

从上面的输出结果不难看出,当程序执行 t = test(10, 2) 调用函数时,程序并未开始执行 test() 函数;当程序第一次调用 next(t) 时,test() 函数才开始执行。

Python 2.x 不使用 next() 函数来获取生成器的下一个值,而是直接调用生成器的 next() 方法。也就是说,在 Python 2.x 中应该写成 t.next()。

当程序调用 next(t) 时,生成器会返回 yield cur 语句返回的值(第一次返回 0),程序被“冻结”在 yield 语句处,因此可以看到上面生成器第一次输出的值为 0。

当程序第二次调用 next(t) 时,程序的“冻结”被解除,继续向下执行,这一次循环计数器 i 变成 1,在执行 cur += i * step 之后,cur 变成 2 ,生成器再次返回 yield cur 语句返回的值(这一次返回 2),程序再次被“冻结”在该 yield 语句处,因此可以看到上面生成器第二次输出的值为 2。

程序可使用 for 循环来遍历生成器,相当于不断地使用 next() 函数获取生成器的下一个值。例如如下代码:

  for ele in t:  print(ele, end=' ')

运行上面循环代码,会生成如下输出结果:

6 12 20 30 42 56 72 90

由于前面两次调用 next() 函数已经获取了生成器的前两个值,因此此处循环时第一次输出的值就是 6。

此外,程序可使用 list() 函数将生成器能生成的所有值转换成列表,也可使用 tuple() 函数将生成器能生成的所有值转换成元组。例如如下代码:

  #再次创建生成器  t = test(10, 1)  #将生成器转换成列表  print (list (t))  #再次创建生成器  t = test(10, 3)  #将生成器转换成元组  print(tuple(t))

运行上面代码,可以看到如下输出结果:

——–函数开始执行——
[0 , 1 , 3, 6 , 10 , 15 , 21 , 28 , 36 , 45] ——–函数开始执行——
(0 , 3 , 9 , 18 , 30 , 45 , 63 , 84 , 108, 135)

系统学习本教程的读者应该知道,前面章节还介绍过使用 for 循环来创建生成器(将 for 表达式放在圆括号里)。可见,Python 主要提供了以下两种方式来创建生成器:

  1. 使用 for 循环的生成器推导式。
  2. 调用带 yield 语句的生成器函数。

生成器是 Python 的一个特色功能,在其他语言中往往没有对应的机制,因此很多 Python 开发者对生成器机制不甚了解。但实际上生成器是一种非常优秀的机制,以我们实际开发的经验来看,使用生成器至少有以下几个优势:

  • 当使用生成器来生成多个数据时,程序是按需获取数据的,它不会一开始就把所有数据都生成出来,而是每次调用 next() 获取下一个数据时,生成器才会执行一次,因此可以减少代码的执行次数。比如前面介绍的示例,程序不会一开始就把生成器函数中的循环都执行完成,而是每次调用 next() 时才执行一次循环体。
  • 当函数需要返回多个数据时,如果不使用生成器,程序就需要使用列表或元组来收集函数返回的多个值,当函数要返回的数据量较大时,这些列表、元组会带来一定的内存开销。如果使用生成器就不存在这个问题,生成器可以按需、逐个返回数据。
  • 使用生成器的代码更加简洁。

生成器的方法

当生成器运行起来之后,开发者还可以为生成器提供值,通过这种方式让生成器与“外部程序”动态地交换数据。

为了实现生成器与“外部程序” 动态地交换数据,需要借助于生成器的 send() 方法,该方法的功能与前面示例中所使用的 next() 函数的功能非常相似,它们都用于获取生成器所生成的下一个值,并将生成器“冻结”在 yield 语句处;但 send() 方法可以接收一个参数,该参数值会被发送给生成器函数。

在生成器函数内部,程序可通过 yield 表达式来获取 send() 方法所发送的值,这意味着此时程序应该使用一个变量来接收 yield 语句的值。如果程序依然使用 next() 函数来获取生成器所生成的下一个值,那么 yield 语句返回 None。

对于上面详细的描述,归纳起来就是两句话:

  1. 外部程序通过 send() 方法发送数据。
  2. 生成器函数使用 yield 语句接收收据。

另外,需要说明的是,只有等到生成器被“冻结”之后,外部程序才能使用 send() 方法向生成器发送数据。获取生成器第一次所生成的值,应该使用 next() 函数;如果程序非要使用 send() 方法获取生成器第一次所生成的值,也不能向生成器发送数据,只能为该方法传入 None 参数。

下面程序示范了向生成器发送数据。该程序会依次生成每个整数的平方值,但外部程序可以向生成器发送数据,当生成器接收到外部数据之后会生成外部数据的平方值:

  def square_gen(val):      i = 0      out_val = None      while True:          # 使用yield语句生成值,使用out_val接收send()方法发送的参数值          out_val = (yield out_val ** 2) if out_val is not None else (yield i ** 2)          # 如果程序使用send()方法获取下一个值,out_val会获取send()方法的参数          if out_val is not None : print("====%d" % out_val)          i += 1    sg = square_gen(5)  # 第一次调用send()方法获取值,只能传入None作为参数  print(sg.send(None))  # 0  print(next(sg))  # 1  print('--------------')  # 调用send()方法获取生成器的下一个值,参数9会被发送给生成器  print(sg.send(9))  # 81  # 再次调用next()函数获取生成器的下一个值  print(next(sg))  # 9

该程序与前面的简单生成器程序的区别就在于第 6 行代码,这行代码在 yield 语句(yield 语句被放在 if 表达式中,整个表达式只会运回一个 yield 语句)的左边放了一个变量,该变量就用于接受生成器 send() 方法所发送的值。

上面程序第一次使用生成器的 send() 方法来获取生成器的下一个值,因此只能为 send() 方法传入 None 作为参数。程序执行到第 9 行代码,由于此时 out_val 为 None ,因此程序执行 yield i**2(生成器返回 0),程序被“冻结”。注意,当程序被“冻结” 时,程序还未对 out_val 变量赋值,因此看到第一次获取生成器的值为 0 。

通过上面的执行过程不难看出,生成器根本不能获取第一次调用 send() 方法发送的参数值,这就是 Python 要求生成器第一次调用 send() 方法时只能发送 None 参数的原因。

接下来程序调用 next(sg) 获取生成器的下一个值,程序从“冻结”处(对 out_val 赋值)向下执行。由于此处调用 next() 函数获取生成器的下一个值,因此 out_val 被赋值为 None,所以程序执行 yield i**2(生成器返回 1),程序再次被“冻结”。

接下来程序调用 sg.send(9) 获取生成器的下一个值,程序从“冻结”处(对 out_val 赋值)向下执行。由于此处调用 send(9) 方法获取生成器的下一个值,因此 out_val 被赋值为 9,所以程序执行 yield out_val**2(生成器返回 81),程序再次被“冻结”。因此看到本次获取生成器的值为 81。

程序再次调用 next(sg) 获取生成器的下一个值,程序从“冻结”处(对 out_val 赋值)向下执行。由于此处调用 next() 函数获取生成器的下一个值,因此 out_val 被赋值为 None,所以程序执行 yield i**2(此时 i 己经递增到 3,因此生成器返回 9),程序再次被“冻结”。因此看到本次获取生成器的值为 9。

运行上面程序,可以看到如下输出结果:

0
1
————–
====9
81
9

此外,生成器还提供了如下两个常用方法:

  1. close():该方法用于停止生成器。
  2. throw():该方法用于在生成器内部(yield 语句内)引发一个异常。

例如,在程序中增加如下代码:

  # 让生成器引发异常  sg.throw(ValueError)

运行上面代码,将看到如下输出结果:

Traceback (most recent call last):
  File "C:UsersmengmaDesktop1.py", line 21, in <module>
    sg.throw(ValueError)
  File "C:UsersmengmaDesktop1.py", line 6, in square_gen
    out_val = (yield out_val ** 2) if out_val is not None else (yield i ** 2)
ValueError

从上面的输出结果可以看到,在程序调用生成器的 throw() 方法引发异常之后,程序就会在 yield 语句中引发该异常。

将上面的 sg.throw(ValueError) 代码注释掉,为程序增加如下两行代码来示范 stop() 方法的用法。在程序调用 stop() 方法关闭生成器之后,程序就不能再去获取生成器的下一个值,否则就会引发异常。

  # 关闭生成器  sg.close()  print(next(sg)) # StopIteration

运行上面代码,可以看到如下输出结果:

Traceback (most recent call last):
  File "C:UsersmengmaDesktop1.py", line 24, in <module>
    print(next(sg)) # StopIteration
StopIteration

关于作者: Python基础入门教程

为您推荐

广告位

发表评论