技术文章 > 头条 > 正文

你真的了解Python执行原理么?

FXL

一、Python运行环境初始化

在看怎么执行之前,先要简单的说明一下python的运行时环境初始化。python中有一个解释器状态对象PyInterpreterState用于模拟进程(后面简称进程对象),另外有一个线程状态对象PyThreadState模拟线程(后面简称线程对象)。

(推荐教程:Python入门教程

python中的PyInterpreterState结构通过一个链表链接起来,用于模拟操作系统多进程。进程对象中有一个指针指向线程集合,线程对象则有一个指针指向其对应的进程对象,这样线程和进程就关联了起来。当然,还少不了一个当前运行线程对象_PyThreadState_Current用来维护当前运行的线程。

1、进程线程初始化

python中调用PyInitialize()函数来完成运行环境初始化。在初始化函数中,会创建进程对象interp以及线程对象并在进程对象和线程对象建立关联,并设置当前运行线程对象为刚创建的线程对象。接下来是类型系统初始化,包括int,str,bool,list等类型初始化,这里留到后面再慢慢分析。然后,就是另外一个大头,那就是系统模块初始化。

进程对象interp中有一个modules变量用于维护所有的模块对象,modules变量为字典对象,其中维护(name, module)对应关系,在python中对应着sys.modules。

2、模块初始化

系统模块初始化过程会初始化 __builtin__, sys, __main__, site等模块。在python中,模块对象是以PyModuleObject结构体存在的,除了通用的对象头部,其中就只有一个字典字段md_dict。模块对象中的md_dict字段存储的内容是我们很熟悉的,比如__name__, __doc__等属性,以及模块中的方法等。

在__builtin__模块初始化中,md_dict中存储的内容就包括内置函数以及系统类型对象,如len,dir,getattr等函数以及int,str,list等类型对象。正因为如此,我们才能在代码中直接用len函数,因为根据LEGB规则,我们能够在__builtin__模块中找到len这个符号。几乎同样的过程创建sys模块以及__main__模块。创建完成后,进程对象interp->builtins会被设置为__builtin__模块的md_dict字段,即模块对象中的那个字典字段。而interp->sysdict则是被设置为sys模块的md_dict字段。

sys模块初始化后,其中包括前面提到过的modules以及path,version,stdin,stdout,maxint等属性,exit,getrefcount,_getframe等函数。注意这里是设置了基本的sys.path(即python安装目录的lib路径等),第三方模块的路径是在site模块初始化的时候添加的。

需要说明的是,__main__模块是个特殊的模块,在我们写第一个python程序时,其中的__name__ == "__main__"中的__main__指的就是这个模块名字。当我们用python xxx.py运行python程序时,该源文件就可以当作是名为__main__的模块了,而如果是通过其他模块导入,则其名字就是源文件本身的名字,至于为什么,这个在后面运行一个python程序的例子中会详细说明。

其中还有一点要说明的是,在创建__main__模块的时候,会在模块的字典中插入("__builtins__", __builtin__ module)对应关系。在后面可以看到这个模块特别重要,因为在运行时栈帧对象PyFrameObject的f_buitins字段就会被设置为__builtin__模块,而栈帧对象的locals和globals字段初始会被设置为__main__模块的字典。

另外,site模块初始化主要用来初始化python第三方模块搜索路径,我们经常用的sys.path就是这个模块设置的了。它不仅将site-packages路径加到sys.path中,还会把site-packages目录下面的.pth文件中的所有路径加入到sys.path中。

下面是一些验证代码,可以看到sys.modules中果然有了__builtin__, sys, __main__等模块。此外,系统的类型对象都已经位于__builtin__模块字典中。

In [13]: import sys

In [14]: sys.modules['__builtin__'].__dict__['int']
Out[14]: int

In [15]: sys.modules['__builtin__'].__dict__['len']
Out[15]: <function len>

In [16]: sys.modules['__builtin__'].__dict__['__name__']
Out[16]: '__builtin__'

In [17]: sys.modules['__builtin__'].__dict__['__doc__']
Out[17]: "Built-in functions, exceptions, and other objects.\n\nNoteworthy: None is the `nil' object; Ellipsis represents `...' in slices."

In [18]: sys.modules['sys']
Out[18]: <module 'sys' (built-in)>

In [19]: sys.modules['__main__']
Out[19]: <module '__main__' (built-in)>

好了,基本工作已经准备妥当,接下来可以运行python程序了。有两种方式,一种是在命令行下面的交互,另外一种是以python xxx.py的方式运行。在说明这两种方式前,需要先介绍下python程序运行相关的几个结构。

3、Python运行相关数据结构

python运行相关数据结构主要由PyCodeObject,PyFrameObject以及PyFunctionObject。其中PyCodeObject是python字节码的存储结构,编译后的pyc文件就是以PyCodeObject结构序列化后存储的,运行时加载并反序列化为PyCodeObject对象。PyFrameObject是对栈帧的模拟,当进入到一个新的函数时,都会有PyFrameObject对象用于模拟栈帧操作。

PyFunctionObject则是函数对象,一个函数对应一个PyCodeObject,在执行def test():语句的时候会创建PyFunctionObject对象。可以这样认为,PyCodeObject是一种静态的结构,python源文件确定,那么编译后的PyCodeObject对象也是不变的;而PyFrameObject和PyFunctionObject是动态结构,其中的内容会在运行时动态变化。

PyCodeObject对象

python程序文件在执行前需要编译成PyCodeObject对象,每一个CodeBlock都会是一个PyCodeObject对象,在Python中,类,函数,模块都是一个Code Block,也就是说编译后都有一个单独的PyCodeObject对象,因此,一个python文件编译后可能会有多个PyCodeObject对象,比如下面的示例程序编译后就会存在2个PyCodeObject对象,一个对应test.py整个文件,一个对应函数test。

#示例代码test.py
def test():
    print "hello world"

if __name__ == "__main__":
    test()

PyFrameObject对象

python程序的字节码指令以及一些静态信息比如常量等都存储在PyCodeObject中,运行时显然不可能只是操作PyCodeObject对象,因为有很多内容是运行时动态改变的,比如下面这个代码test2.py,虽然1和2处的字节码指令相同,但是它们执行结果显然是不同的,这些信息显然不能在PyCodeObject中存储,这些信息其实需要通过PyFrameObject也就是栈帧对象来获取。

PyFrameObject对象中有locals,globals,builtins三个字段对应local,global,builtin三个名字空间,即我们常说的LGB规则,当然加上闭包,就是LEGB规则。一个模块对应的文件定义一个global作用域,一个函数定义一个local作用域,python自身定义了一个顶级作用域builtin作用域,这三个作用域分别对应PyFrameObject对象的三个字段,这样就可以找到对应的名字引用。

比如test2.py中的1处的i引用的是函数test的局部变量i,对应内容是字符串“hello world”,而2处的i引用的是模块的local作用域的名字i,对应内容是整数123(注意模块的local作用域和global作用域是一样的)。需要注意的是,函数中局部变量的访问并不需要去访问locals名字空间,因为函数的局部变量总是不变的,在编译时就能确定局部变量使用的内存位置。

#示例代码test2.py
i = 123      
def test():
  i = 'hello world'
  print i #1

test()
print i #2

PyFunctionObject对象

PyFunctionObject是函数对象,在创建函数的指令MAKE_FUNCTION中构建。PyFunctionObject中有个func_code字段指向该函数对应的PyCodeObject对象,另外还有func_globals指向global名字空间,注意到这里并没有使用local名字空间。调用函数时,会创建新的栈帧对象PyFrameObject来执行函数,函数调用关系通过栈帧对象PyFrameObject中的f_back字段进行关联。

最终执行函数调用时,PyFunctionObject对象的影响已经消失,真正起作用的是PyFunctionObject的PyCodeObject对象和global名字空间,因为在创建函数栈帧时会将这两个参数传给PyFrameObject对象。

4、Python程序运行过程浅析

说完几个基本对象,现在回到之前的话题,开始准备执行python程序。两种方式交互式和直接python xxx.py虽然有所不同,但最终归于一处,就是启动虚拟机执行python字节码。这里以python xxx.py方式为例,在运行python程序之前,需要对源文件编译成字节码,创建PyCodeObject对象。这个是通过PyAST_Compile函数实现的,至于具体编译流程,这就要参看《编译原理》那本书了,这里暂时当做黑盒好了,因为单就编译这部分而言,一时半会也说不清楚(好吧,其实是我也没有学好编译原理)。

编译后得到PyCodeObject对象,然后调用PyEval_EvalCode(co, globals, locals)函数创建PyFrameObject对象并执行字节码了。注意到参数里面的co是PyCodeObject对象,而由于运行PyEval_EvalCode时创建的栈帧对象是Python创建的第一个PyFrameObject对象,所以f_back为NULL,而且它的globals和locals就是__main__模块的字典对象。如果我们不是直接运行,而是导入一个模块的话,则还会将python源码编译后得到的PyCodeObject对象保存到pyc文件中,下次加载模块时如果这个模块没有改动过就可以直接从pyc文件中读取内容而不需要再次编译了。

执行字节码的过程就是模拟CPU执行指令的过程一样,先指向PyFrameObject的f_code字段对应的PyCodeObject对象的co_code字段,这就是字节码存储的位置,然后取出第一条指令,接着第二条指令...依次执行完所有的指令。python中指令长度为1个字节或者3个字节,其中无参数的指令长度是1个字节,有参数的指令长度是3个字节(指令1字节+参数2字节)。

python虚拟机的进程,线程,栈帧对象等关系如下图所示:

54f9e8cc9ffaf3a20d5c4b5b5d1db79.png

二、Python程序运行实例说明

程序猿学习一门新的语言往往都是从hello world开始的,一来就跟世界打个招呼,因为接下来就要去面对程序语言未知的世界了。我学习python也是从这里开始的,只是以前并不去深究它的执行原理,这回是逃不过去了。看看下面的栗子。

#示例代码test3.py
i = 1
s = 'hello world'

def test():
    k = 5
    print k
    print s

if __name__ == "__main__":
    test()

这个例子代码不多,不过也涉及到python运行原理的方方面面(除了类机制那一块外,类机制那一块还没有理清楚,先不理会)。那么按照之前部分说的,执行python test3.py的时候,会先初始化python进程和线程,然后初始化系统模块以及类型系统等,然后运行python程序test3.py。

每次运行python程序都是开启一个python虚拟机,由于是直接运行,需要先编译为字节码格式,得到PyCodeObject对象,然后从字节码对象的第一条指令开始执行。因为是直接运行,所以PyCodeObject也就没有序列化到pyc文件保存了。下面可以看下test3.py的PyCodeObject,使用python的dis模块可以看到字节码指令。

In [1]: source = open('test3.py').read()

In [2]: co = compile(source, 'test3.py', 'exec')

In [3]: co.co_consts
Out[3]: 
(1,
 'hello world',
 <code object test at 0x1108eaaf8, file "run.py", line 4>,
 '__main__',
 None)

In [4]: co.co_names
Out[4]: ('i', 's', 'test', '__name__')

In [5]: dis.dis(co) ##模块本身的字节码,下面说的整数,字符串等都是指python中的对象,对应PyIntObject,PyStringObject等。
  1           0 LOAD_CONST               0 (1) # 加载常量表中的第0个常量也就是整数1到栈中。
              3 STORE_NAME               0 (i) # 获取变量名i,出栈刚刚加载的整数1,然后存储变量名和整数1到f->f_locals中,这个字段对应着查找名字时的local名字空间。

  2           6 LOAD_CONST               1 ('hello world') 

              9 STORE_NAME               1 (s)  #同理,获取变量名s,出栈刚刚加载的字符串hello world,并存储变量名和字符串hello world的对应关系到local名字空间。

  4          12 LOAD_CONST               2 (<code object test at 0xb744bd10, file "test3.py", line 4>)
             15 MAKE_FUNCTION            0   #出栈刚刚入栈的函数test的PyCodeObject对象,以code object和PyFrameObject的f_globals为参数创建函数对象PyFunctionObject并入栈
             18 STORE_NAME               2 (test)  #获取变量test,并出栈刚入栈的PyFunctionObject对象,并存储到local名字空间。

  9          21 LOAD_NAME                3 (__name__) ##LOAD_NAME会先依次搜索local,global,builtin名字空间,当然我们这里是在local名字空间能找到__name__。
             24 LOAD_CONST               3 ('__main__')
             27 COMPARE_OP               2 (==)  ##比较指令
             30 JUMP_IF_FALSE           11 (to 44) ##如果不相等则直接跳转到44对应的指令处,也就是下面的POP_TOP。因为在COMPARE_OP指令中,会设置栈顶为比较的结果,所以需要出栈这个比较结果。当然我们这里是相等,所以接着往下执行33处的指令,也是POP_TOP。
             33 POP_TOP             

 10          34 LOAD_NAME                2 (test) ##加载函数对象
             37 CALL_FUNCTION            0  ##调用函数
             40 POP_TOP                     ##出栈函数返回值
             41 JUMP_FORWARD             1 (to 45) ##前进1步,注意是下一条指令地址+1,也就是44+1=45
        >>   44 POP_TOP             
        >>   45 LOAD_CONST               4 (None) 
             48 RETURN_VALUE     #返回None


In [6]: dis.dis(co.co_consts[2])  ##查看函数test的字节码
  5           0 LOAD_CONST               1 (5)
              3 STORE_FAST               0 (k) #STORE_FAST与STORE_NAME不同,它是存储到PyFrameObject的f_localsplus中,不是local名字空间。

  6           6 LOAD_FAST                0 (k) #相对应的,LOAD_FAST是从f_localsplus取值
              9 PRINT_ITEM          
             10 PRINT_NEWLINE         #打印输出 

  7          11 LOAD_GLOBAL              0 (s) #因为函数没有使用local名字空间,所以,这里不是LOAD_NAME,而是LOAD_GLOBAL,不要被名字迷惑,它实际上会依次搜索global,builtin名字空间。
             14 PRINT_ITEM          
             15 PRINT_NEWLINE       
             16 LOAD_CONST               0 (None)
             19 RETURN_VALUE

按照我们前面的分析,test3.py这个文件编译后其实对应2个PyCodeObject,一个是本身test3.py这个模块整体的PyCodeObject,另外一个则是函数test对应的PyCodeObject。根据PyCodeObject的结构,我们可以知道test3.py字节码中常量co_consts有5个,分别是整数1,字符串‘hello world',函数test对应的PyCodeObject对象,字符串__main__,以及模块返回值None对象。恩,从这里可以发现,其实模块也是有返回值的。我们同样可以用dis模块查看函数test的字节码。

关于字节码指令,代码中做了解析。需要注意到函数中局部变量如k的取值用的是LOAD_FAST,即直接从PyFrameObject的f_localsplus字段取,而不是LOAD_NAME那样依次从local,global以及builtin查找,这是函数的特性决定的。函数的运行时栈也是位于f_localsplus对应的那片内存中,只是前面一部分用于存储函数参数和局部变量,而后面那部分才是运行时栈使用,这样逻辑上运行时栈和函数参数以及局部变量是分离的,虽然物理上它们是连在一起的。

需要注意的是,python中使用了预测指令机制,比如COMPARE_OP经常跟JUMP_IF_FALSE或JUMP_IF_TRUE成对出现,所以如果COMPARE_OP的下一条指令正好是JUNP_IF_FALSE,则可以直接跳转到对应代码处执行,提高一定效率。

此外,还要知道在运行test3.py的时候,模块的test3.py栈帧对象中的f_locals和f_globals的值是一样的,都是__main__模块的字典。在test3.py的代码后面加上如下代码可以验证这个猜想。

... #test3.py的代码
 
if __name__ == "__main__":
    test()
    print locals() == sys.modules['__main__'].__dict__ # True
    print globals() == sys.modules['__main__'].__dict__ # True
    print globals() == locals() # True

正式因为如此,所以python中函数定义顺序是无关的,不需要跟C语言那样在调用函数前先声明函数。比如下面test4.py是完全正常的代码,函数定义顺序不影响函数调用,因为在执行def语句的时候,会执行MAKE_FUNCTION指令将函数对象加入到local名字空间,而local和global此时对应的是同一个字典,所以也相当于加入了global名字空间,从而在运行函数g的时候是可以找到函数f的。

另外也可以注意到,函数声明和实现其实是分离的,声明的字节码指令在模块的PyCodeObject中执行,而实现的字节码指令则是在函数自己的PyCodeObject中。

#test4.py
def g():      
  print 'function g'
  f() 

def f():
  print 'function f'

g()
~
免费视频教程
本文转载于:掘金,如有侵犯,请联系a@php.cn删除
相关文章
 如何使用spyder调试python代码
 最热门、最好用的python插件,你用了么
 pycharm怎么切换python2.7版本
 pycharm如何配置python解释器
相关视频章节
 解决提示“‘python’不是内部或外外部命令
 python代码缩进
 python编码规范
 python命名规范
视频教程分类