请选择 进入手机版 | 继续访问电脑版

北南南北论坛

 找回密码
 立即注册
查看: 18|回复: 0

Python 生成器原理详解

[复制链接]

563

主题

950

帖子

2694

积分

金牌会员

Rank: 6Rank: 6

积分
2694
发表于 2017-12-22 10:10:29 | 显示全部楼层 |阅读模式
这篇文章是对 500 Lines or Less 一书中高效爬虫一章的部分翻译,原文:How Python Generators Work。建议结合《流畅的 Python》食用。

在掌握 Python 生成器之前,你必须了解常规 Python 函数的工作原理。通常,当一个 Python 函数调用子程序(subroutine)时,这个子程序将一直持有控制权,只有当子程序结束(返回或者抛出异常)后,控制权才还给调用者:

  1. >>> def foo():
  2. ...     bar()
  3. ...
  4. >>> def bar():
  5. ...     pass
复制代码

标准的 Python 解释器是用 C 写的。解释器用一个叫做 PyEval_EvalFrameEx 的 C 函数来执行 Python 函数。它接受一个 Python 的堆栈帧(stack frame)对象,并在这个堆栈帧的上下文中执行 Python 字节码。这是 foo 的字节码:

  1. >>> import dis
  2. >>> dis.dis(foo)
  3.   2           0 LOAD_GLOBAL              0 (bar)
  4.               3 CALL_FUNCTION            0 (0 positional, 0 keyword pair)
  5.               6 POP_TOP
  6.               7 LOAD_CONST               0 (None)
  7.              10 RETURN_VALUE
复制代码

foo 函数将 bar 加载到堆栈中并调用它,然后从堆栈中弹出返回值,最后加载并返回 None。

当 PyEval_EvalFrameEx 遇到 CALL_FUNCTION 字节码的时候,它会创建一个新的 Python 堆栈帧,然后用这个新的帧作为参数递归调用 PyEval_EvalFrameEx 来执行 bar。

Python 的堆栈帧是分配在堆内存中的,理解这一点非常重要!Python 解释器是个普通的 C 程序,所以它的堆栈帧就是普通的堆栈。但是它操作的 Python 堆栈帧是在堆上的。除了其他惊喜之外,这意味着 Python 的堆栈帧可以在它的调用之外存活。(FIXME: 可以在它调用结束后存活)。要以交互方式查看,请从 bar 内保存当前帧:

  1. >>> import inspect
  2. >>> frame = None
  3. >>> def foo():
  4. ...     bar()
  5. ...
  6. >>> def bar():
  7. ...     global frame
  8. ...     frame = inspect.currentframe()
  9. ...
  10. >>> foo()
  11. >>> # The frame was executing the code for 'bar'.
  12. >>> frame.f_code.co_name
  13. 'bar'
  14. >>> # Its back pointer refers to t
  15. >>> def bar():
  16. ...     global frame
  17. ...     frame = inspect.currentframe()he frame for 'foo'.
  18. >>> caller_frame = frame.f_back
  19. >>> caller_frame.f_code.co_name
  20. 'foo'
复制代码
1.png
现在这项技术被用到了 Python 生成器(generator)上——使用代码对象和堆栈帧这些相同的组件来产生奇妙的效果。

这是一个生成器函数(generator function):

  1. >>> def gen_fn():
  2. ...     result = yield 1
  3. ...     print('result of yield: {}'.format(result))
  4. ...     result2 = yield 2
  5. ...     print('result of 2nd yield: {}'.format(result2))
  6. ...     return 'done'
  7. ...
复制代码
当 Python 将 gen_fn 编译为字节码时,它会看到 yield 语句,然后知道 gen_fn 是个生成器函数,而不是普通函数。它会设置一个标志来记住这个事实:

  1. >>> # The generator flag is bit position 5.
  2. >>> generator_bit = 1 << 5
  3. >>> bool(gen_fn.__code__.co_flags & generator_bit)
  4. True
复制代码

当你调用一个生成器函数时,Python 会看到生成器标志,实际上并不运行该函数,而是创建一个生成器(generator):

  1. >>> gen = gen_fn()
  2. >>> type(gen)
  3. <class 'generator'>
复制代码

Python 生成器封装了一个堆栈帧和一个对生成器函数代码的引用,在这里就是对 gen_fn 函数体的引用:

  1. >>> gen.gi_code.co_name
  2. 'gen_fn'
复制代码

调用 gen_fn 产生的所有生成器都指向同一个代码对象,但是每个都有自己的堆栈帧。这个堆栈帧并不存在于实际的堆栈上,它在堆内存上等待着被使用

2.png
堆栈帧有个 “last instruction”(FIXME: translate this or not?) 指针,指向最近执行的那条指令。刚开始的时候 last instruction 指针是 -1,意味着生成器尚未开始:

  1. >>> gen.gi_frame.f_lasti
  2. -1
复制代码
当我们调用 send 时,生成器达到第一个 yield 处然后暂停执行。send 的返回值是 1,这是因为 gen 把 1 传给了 yield 表达式:

  1. >>> gen.send(None)
  2. 1
复制代码
现在生成器的指令指针(instruction pointer)向前移动了 3 个字节码,这些是编译好的 56 字节的 Python 代码的一部分:

  1. >>> gen.gi_frame.f_lasti
  2. 3
  3. >>> len(gen.gi_code.co_code)
  4. 56
复制代码
生成器可以在任何时候被任何函数恢复执行,因为它的堆栈帧实际上不在堆栈上——它在堆(内存)上。生成器在调用调用层次结构中的位置不是固定的,它不需要遵循常规函数执行时遵循的先进后出顺序。生成器被是被解放了的,它像云一样浮动。

我们可以将 “hello” 发送到这个生成器中,它会成为 yield 表达式的值,然后生成器会继续执行,直到产出(yield)了 2:

  1. >>> gen.send('hello')
  2. result of yield: hello
  3. 2
复制代码
现在这个生成器的堆栈帧包含局部变量 result:

  1. >>> gen.gi_frame.f_locals
  2. {'result': 'hello'}
复制代码
从 gen_fn 创建的其他生成器将具有自己的堆栈帧和局部变量。

当我们再次调用 send 时,生成器将从它第二个 yield 处继续执行,然后以产生特殊异常 StopIteration 结束:

  1. >>> gen.send('goodbye')
  2. result of 2nd yield: goodbye
  3. Traceback (most recent call last):
  4.     File "<input>", line 1, in <module>
  5. StopIteration: done
复制代码
异常有一个值,它是那个生成器的返回值:字符串 “done”。
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则


手机版|北南南北论坛  

GMT+8, 2018-1-24 07:47 , Processed in 0.073542 second(s), 32 queries .

© 2001-2016 VxWorks6 Inc.

快速回复 返回顶部 返回列表