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，就已经被标记为生成器了

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，生成器知道下次会在什么地方执行，不像函数，必须要一次性运行完毕

# 以上就是生成器的运行原理