python中函数和生成器的运行原理

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# author:love_cat

# python的函数是如何工作的

# 比方说我们定义了两个函数

def foo():
    bar()

def bar():
    pass

# 首先python解释器(python.exe)会用一个叫做PyEval_EvalFrameEx()的C语言函数去执行foo，所以python的代码是运行在C程序之上的
# 当运行foo函数时，会首先创建一个栈帧(stack frame),表示函数调用栈当中的某一帧，相当于一个上下文，函数要在对应的栈帧上运行。
# 正所谓python一切皆对象，栈帧也是一个对象
# python虽然是解释型语言，但在解释之前也要进行一次预编译，编译成字节码对象，然后在对应的栈帧当中运行

# 关于python的编译过程，我们可以是dis模块查看编译后的字节码是什么样子
import dis
print(dis.dis(foo))
# 程序运行结果
'''
11           0 LOAD_GLOBAL              0 (bar)
              2 CALL_FUNCTION            0
              4 POP_TOP
              6 LOAD_CONST               0 (None)
              8 RETURN_VALUE
None
'''
# 首先LOAD_GLOBAL,把bar这个函数给load进来
# 然后CALL_FUNCTION，调用bar函数的字节码
# POP_POP,从栈的顶端把元素打印出来
# LOAD_CONST,我们这里没有return，所以会把None给load进来
# RETURN_VALUE，把None给返回
'''
以上是字节码的执行过程
'''

# 过程就是：
'''
1.先预编译，得到字节码对象
2.python解释器去解释字节码
3.当解释到foo函数的字节码时，会为其创建一个栈帧
4.然后调用C函数PyEval_EvalFrameEx()在foo对应的栈帧上执行foo的字节码，参数就是foo对应的栈帧对象
5.当遇到CALL_FUNCTION,也就是在foo中执行到bar的字节码时，会继续为其创建一个栈帧
6.然后把控制权交给新创建的栈帧对象，在bar对应的栈帧中运行bar的字节码
'''

# 我们看到目前已经有两个栈帧了，这不是关键。关键所有的栈帧都分配在堆的内存上，而不是栈的内存上
# 堆内存有一个特点，如果你不去释放，那么它就一直待在那儿。这就决定了栈帧可以独立于调用者存在
# 即便调用者不存在，或者函数退出了也没有关系，因为它始终在内存当中。只要有指针指向它，我们就可以对它进行控制
# 这个特性决定了我们对函数的控制会相当精确。

# 我们可以改写这个函数
# 在此之前，我们要引用一个模块inspect，可以获取栈帧
import inspect

frame = None
def foo():
    bar()

def bar():
    global frame
    frame = inspect.currentframe()  # 将获取到的栈帧对象赋给全局变量

foo()
# 此时函数执行完毕，但是我们依然可以拿到栈帧对象
# 栈帧对象一般有三个属性
# 1.f_back,当前栈帧的上一级栈帧
# 2.f_code,当前栈帧对应的字节码
# 3.f_locals,当前栈帧所用的局部变量

print(frame.f_code)
print(frame.f_code.co_name)
'''
<code object bar at 0x000000000298C300>
bar
'''
# 可以看出，打印的是我们bar这个栈帧

# 之前说过，栈帧可以独立于调用方而存在
# 我们也可以拿到foo的栈帧,也就是bar栈帧的上一级栈帧
foo_frame = frame.f_back
print(foo_frame.f_code)
print(foo_frame.f_code.co_name)
'''
<code object foo at 0x000000000239C8A0>
foo
'''
# 我们依然可以拿到foo的栈帧

# 总结一下：就是有点像递归。遇见新的调用，便创建一个新的栈帧，一层层地创建，然后一层层地返回

关于类似于递归这个现象，我们可以看一张图

生成器的运行原理

# 我们之前说了，栈帧是分配在堆内存上的
# 正是因为如此，生成器才有实现的可能

# 我们定义一个生成器
def gen_func():
    yield 123
    name = "satori"
    yield 456
    age = 18
    return "i love satori"   # 注意在早期的版本中生成器是不允许有返回值的，但在后来的版本中，允许生成器具有返回值

# python解释之前，也进行预编译，在编译的过程中，发现有yield，就已经被标记为生成器了

如何实现的呢？实际上是对PyFrameObject做了一层封装

def gen_func():
    yield 123
    name = "satori"
    yield 456
    age = 18
    return "i love satori"

import dis
gen = gen_func()
print(dis.dis(gen))
'''
 10           0 LOAD_CONST               1 (123)
              2 YIELD_VALUE
              4 POP_TOP

 11           6 LOAD_CONST               2 ('satori')
              8 STORE_FAST               0 (name)

 12          10 LOAD_CONST               3 (456)
             12 YIELD_VALUE
             14 POP_TOP

 13          16 LOAD_CONST               4 (18)
             18 STORE_FAST               1 (age)

 14          20 LOAD_CONST               5 ('i love satori')
             22 RETURN_VALUE
None
'''

# 可以看到，结果中有两个yield，因为我们的函数中有两个yield
# 最后的LOAD_CONST后面的('i love satori')，表示我们的返回值
# 最后RETURN_VALUE

# 前面的图也解释了，gi_frame的f_lasti会记录最近的一次执行状态，gi_locals会记录当前的局部变量
print(gen.gi_frame.f_lasti)
print(gen.gi_frame.f_locals)
'''
-1
{}
'''
# 我们创建了生成器，但是还没有执行，所以值为-1，当前局部变量也为空

# 我们next一下
next(gen)
print(gen.gi_frame.f_lasti)
print(gen.gi_frame.f_locals)
'''
2
{}
'''
# 我们发现数字是2，所以指向第二行，YIELD_VALUE,yield的值就是123
# 此时局部变量依旧为空

# 继续next，会执行到第二个yield的位置
next(gen)
print(gen.gi_frame.f_lasti)
print(gen.gi_frame.f_locals)
'''
12
{'name': 'satori'}
'''
# 数字是12，所以指向第十二行，第二个YIELD_VALUE,yield的值就是456
# 此时name="satori"，被添加到了局部变量当中

# 因此到这里便更容易理解了，为什么生成器可以实现了。
# 因为PyGenObject对函数的暂停和前进，进行了完美的监督，有变量保存我最近一行代码执行到什么位置
# 再通过yield来暂停它，就实现了我们的生成器

# 跟函数一样，我们的生成器对象也是分配在堆内存当中的，可以像函数的栈帧一样，独立于调用者而存在
# 我们可以在任何地方去调用它，只要我们拿到这个栈帧对象，就可以控制它继续往前走
# 正是因为可以在任何地方控制它，才会有了协程这个概念，这是协程能够实现的理论基础
# 因为有了f_lasti，生成器知道下次会在什么地方执行，不像函数，必须要一次性运行完毕
# 以上就是生成器的运行原理