csdn推荐
前言
前面我们主要围绕pyObject和pyTypeObject聊完了python的内建对象部分,现在我们将开启新的篇章—python虚拟机,将聚焦在python的执行部分,搞懂从“代码”到“执行”的过程。开启新的篇章之前,你也许会有一个疑惑:我们写的代码是如何执行的?从表面看,我只要按照python的正确语法书写一段代码,然后“剩下的”交给python解释器,代码就能被执行了!这也许就是大部分人能够给出的解释了,在没有学习此篇章之前,我也是这么认为的,因为我也没有探究过“剩下的部分”python解释器是如何去操作的。因此,从这一篇博客开始,让我们一起带着这个问题,“钻进”python的解释器中,看看它到底做了个啥!
开始
作为python开发者,我相信大家对pyc文件应该并不陌生,它虽然经常“藏”在我们看不到的地方,但有时作用可不小,你也许为了提速,将整个项目的py文件转成pyc文件,然后再去执行;或者你为了加密,将py文件转成pyc文件再发给别人…等等这些,都和pyc文件的特性有关系,这样看来,pyc文件似乎比py文件更“抢手”?这其中似乎有什么蹊跷?还是python解释器对pyc文件有偏心?因此,在开启“python执行过程”的探索,pyc文件似乎比py文件更有研究价值?
什么是pyc文件?
细心的小伙伴应该早就发现了:我们写的py文件夹中,有时候会多一个额外的文件夹:__pychache_,点开这个文件夹,你可能还会发现,这里面会有一些以.pyc结尾的文件,同时,你还会发现它们的文件名和上级目录中的py文件名是有一些对应关系的。
这里的以.pyc结尾的文件就是我们常说的pyc文件,看看它的目录名:__pycache_,根据目录名,我想大家应该猜到它的作用是什么了,没错,我们就可以把它当作是对py文件的一个缓存文件,缓存的主要目的:!
pyc文件是怎么产生的?
看上面的那个截图发现,__pycache__中似乎只有一个.pyc文件,为什么其他的py文件没有对应的pyc文件呢?这也许从侧面说明了一点:pyc文件不是必须的,应该只在特定情况下才能触发生成。(如果你还是有点怀疑,可以查看自己的py文件目录)
是和我们写的代码有关系吗?答案是肯定的!
实际上,当我们每次通过import导入一个py文件时,都可能会触发这个“生成pyc文件”的开关。
在当前目录所有的py文件中,我只对demo2.py文件进行了导入操作,没有对其他的py文件执行导入操作,因此实际上就是import机制触发了pyc文件的产生。当然,如果你想手动生成,也是可以的,下面是通过代码生成pyc文件的一个方法:
import py_compile
# 将py文件编译成pyc文件(编译成PyCodeObject存放在pyc文件中)
# PyCodeObject是编译真正的结果,pyc文件只是它存放的位置
pyc_path = py_compile.compile(file='demo.py')
# 读取pyc文件的内容
pyc_content = open(pyc_path, 'rb').read()
print(pyc_content) # 二进制的
通过读取pyc文件的内容可以发现,它实际上是一个二进制文件。
pyc文件的结构
到目前为止,我们已经知道pyc文件是一个二进制文件,用于缓存py文件,那么它的结构是怎样的呢?它里面包含了哪些东西?你是不是不知道该何从下手了?别担心!你是否还记得它是可以通过import机制生成的?那么就说明import机制中一定包含了它生成的逻辑!所以那就让我们一起顺藤摸瓜吧!
”顺着import摸瓜“
当我在阅读《python源码剖析》时,书中介绍的创建pyc的过程是在import.c这个文件中产生的,但我找了很长时间都没有找到相应的逻辑,最后通过查阅各种资料和AI发现这个逻辑已经放在标准库importlib中实现了(这里可能是版本的关系导致的,或许有出入,但问题不大)。
该说不说,python中有一个非常好用的东西,那就是它的异常栈,当一个函数有多处实现,不知道具体是哪个地方的时候,我们在每一个地方“埋雷”,当python解释器不小心踩到我们的雷,它的执行路线就会像多米洛骨牌连续翻倒一样,清晰的展现在我们面前:
可以看到,import一个模块时,它会走到一个名为get_code的函数中,在此函数中,就包含了pyc文件生成的逻辑,这段代码的大概逻辑就是:
找到模块对应的py路径,根据py路径找到它对应的pyc路径;尝试从pyc中读取,如果读取成功,校验它和py文件中的内容是否一致(这里有两种校验方式:基于hash和基于时间戳),如果是一致的就直接返回;如果发生了变化,就从py中读取得到code obejct,并写入到对应的pyc文件,之后再返回;最后调用exec方法执行返回的code obejct。
def get_code(self, fullname):
"""Concrete implementation of InspectLoader.get_code.
Reading of bytecode requires path_stats to be implemented. To write
bytecode, set_data must also be implemented.
"""
source_path = self.get_filename(fullname)
source_mtime = None
source_bytes = None
source_hash = None
hash_based = False
check_source = True
try:
# 获取py文件对应的pyc文件的路径
bytecode_path = cache_from_source(source_path)
except NotImplementedError:
bytecode_path = None
else:
try:
"""
- 'mtime' (mandatory) is the numeric timestamp of last source
code modification;
- 'size' (optional) is the size in bytes of the source code."""
st = self.path_stats(source_path)
except OSError:
pass
else:
# py文件最后的修改时间
source_mtime = int(st['mtime'])
try:
data = self.get_data(bytecode_path)
except OSError:
pass
else:
exc_details = {
'name': fullname,
'path': bytecode_path,
}
try:
flags = _classify_pyc(data, fullname, exc_details)
bytes_data = memoryview(data)[16:]
hash_based = flags & 0b1 != 0
if hash_based:
check_source = flags & 0b10 != 0
if (_imp.check_hash_based_pycs != 'never' and
(check_source or
_imp.check_hash_based_pycs == 'always')):
source_bytes = self.get_data(source_path)
source_hash = _imp.source_hash(
_RAW_MAGIC_NUMBER,
source_bytes,
)
_validate_hash_pyc(data, source_hash, fullname,
exc_details)
else:
_validate_timestamp_pyc(
data,
source_mtime,
st['size'],
fullname,
exc_details,
)
except (ImportError, EOFError):
pass
else:
_bootstrap._verbose_message('{} matches {}', bytecode_path,
source_path)
return _compile_bytecode(bytes_data, name=fullname,
bytecode_path=bytecode_path,
source_path=source_path)
if source_bytes is None:
source_bytes = self.get_data(source_path)
code_object = self.source_to_code(source_bytes, source_path)
_bootstrap._verbose_message('code object from {}', source_path)
if (not sys.dont_write_bytecode and bytecode_path is not None and
source_mtime is not None):
if hash_based:
if source_hash is None:
source_hash = _imp.source_hash(source_bytes)
data = _code_to_hash_pyc(code_object, source_hash, check_source)
else:
data = _code_to_timestamp_pyc(code_object, source_mtime,
len(source_bytes))
try:
self._cache_bytecode(source_path, bytecode_path, data)
print(f'写入code object到:{bytecode_path}文件')
if str(bytecode_path).endswith('demo.cpython-311.pyc'):
print(1/0)
except NotImplementedError:
pass
return code_object
直白一点就是:如果有现成的,判断一下是不是最新的,如果是就用现成的(pyc);如果没有(或者不是最新的),就现场生成一个。所以,这里就是pyc能够提升加载速度的逻辑,在加载一个模块时,python解释器会先把我们写的代码进行“编译”,然后将“编译”好的代码再拿去执行,同时会将编译的结果写到pyc文件中,当再次需要导入这个模块时,如果已经有编译好的pyc文件,并且是最新的,就直接使用它就好,这样就省去了“编译”的时间。其实就是一个缓存的逻辑!
pyc文件的内容
还是在get_code这个函数中,我们可以找到两种生成pyc文件的方式:
分别是基于时间戳和hash值的两种方式,以基于时间戳的方式为例,它的具体逻辑如下:
基于当前的python解释器的版本MAGIC_NUMBER生成一个字节数组,之后在添加其他的一些数据:mtime(源文件最后的编辑时间),source_size(源文件的大小),code(源码编译后的结果)以及一个无任何含义的0(可能是官方预留的),注意:除了code以外,其他数据的长度都是4,这就是pyc文件的所有内容,它们分别是:magic_number,mtine,0,source_size,code(不同的python版本内容可能有出入,我这里是py3-11-7)。
tips:magic_number主要用于判断解释器和当前要执行的python代码是否兼容,你可以尝试用py3-7编译一个pyc文件,然后用py3-11去执行,它会抛出一个magic_number不兼容的错误。
为了证实pyc真的就是如上那些内容,我们可以试着解析一个pyc文件试试!
code object
到目前为止,我们一直围绕着pyc文件在转,从它的生成逻辑到它结构内容,以及它的意义,对它的了解应该算是了如指掌了!但是我们似乎忽略了一个重要的环节—“编译”,源文件是如何被编译的,以及它的编译结果是什么?
通过源代码可以发现,其实就是调用了内置的compile方法对源文件的内容进行了“编译”,编译的结果通过调用type方法可以知道是:code object。
tips:关于compile内部是如何执行的,可以参考python源文件中的Python/compile.c文件。
code object的结构
在探究code object的结构之前,我们可以先来看一下它所对应的源码的内容是怎样的,以demo.py文件为例,它的内容如下:
class A:
def fun(self, msg='hello'):
print('hello world2')
a = A()
a.fun()
可以看到:它包含了一个类A,类下面包含了一个方法fun,fun有两个参数,一个是self,另外一个是msg,fun中执行了一个打印字符串“hello world2”,同时在全局下,它还包含了一个变量a,a调用了方法fun,这就是所有的内容,如果你是python的开发者,你会如何将它“编译”成你需要的内容?
想一想,这里面是不是一个嵌套关系:在全局下,它包含了一个类型A和一个实例a;在类型A中,它包含了一个方法fun;在方法fun中,它包含了一个位置参数self和一个关键字参数msg,且默认值是“hello”,同时它内部还包含了一个字符串“hello world2”;如何存储这些信息以及它们之间的关系呢?
实际上code object也是类似于这样的一个嵌套对象,每一个code object对象有它自己的属性,同时code object里面可以包含其他code object,每一个code object都可以看成是一个域(或者是一个code block(代码块)),而这个域就可以是上面说的哪些对象:可以是一个模块,可以是一个类,可以是一个函数,可以是一个方法…
demo.py编译得到的code object如下:
code object各属性含义如下:
属性名称含义
co_argcount
位置参数的数量。
co_kwonlyargcount
关键字参数的数量。
co_nlocals
局部变量的数量。
co_stacksize
所需的栈大小。
co_flags
编译标志。
co_code
实际的字节码指令。
co_consts
常量池(字面量、元组等)。
co_names
在字节码中使用的名称列表。
co_varnames
局部变量名列表。
co_filename
源代码文件名。
co_name
代码对象的名称。
co_firstlineno
第一行的行号。
co_lnotab
行号表(字节码到源代码行号的映射)。
co_freevars
自由变量的名称(闭包中使用的变量)。
co_cellvars
闭包中绑定的局部变量的名称。
每一个code object中都有一个重要的属性,就是co_code,它存储了字节码指令,在实际执行的时候,会根据不同的字节码指令执行不同的操作;当前code object如果包含了其他的code object,它们都会被存储在co_consts这个属性中。
解析code object对象
为了更加清晰地看到code object的嵌套结构,我们可以使用json或者xml结构来展示它的结构:
import dis
import types
import xml.etree.ElementTree as ET
from notes.utils import utils
import marshal
import pprint
def parse_code_object(code_object, result={}):
"""将code对象转成json"""
# 反编译当前的code object对象,得到字节码指令
print(f'{code_object.co_name}')
dis.dis(code_object)
keys = ['co_name', 'co_names', 'co_consts', 'co_argcount', 'co_cellvars', 'co_code', 'co_exceptiontable',
'co_filename',
'co_firstlineno', 'co_flags', 'co_freevars', 'co_kwonlyargcount', 'co_lines', 'co_linetable', 'co_lnotab',
'co_nlocals', 'co_positions', 'co_posonlyargcount', 'co_qualname', 'co_stacksize', 'co_varnames', 'replace']
# 赋值
for key in keys:
result[key] = getattr(code_object, key)
result['co_consts'] = []
co_consts = code_object.co_consts
for co_const in co_consts:
if isinstance(co_const, types.CodeType):
_result = {}
parse_code_object(co_const, _result)
result['co_consts'].append(_result)
else:
result['co_consts'].append(co_const)
def code_object_to_xml(co, parent_element):
code_element = ET.SubElement(parent_element, 'code')
code_element.attrib['co_name'] = co.co_name
ET.SubElement(code_element, 'co_name').text = co.co_name
ET.SubElement(code_element, 'co_filename').text = co.co_filename
ET.SubElement(code_element, 'co_firstlineno').text = str(co.co_firstlineno)
ET.SubElement(code_element, 'co_argcount').text = str(co.co_argcount)
ET.SubElement(code_element, 'co_kwonlyargcount').text = str(co.co_kwonlyargcount)
ET.SubElement(code_element, 'co_nlocals').text = str(co.co_nlocals)
ET.SubElement(code_element, 'co_stacksize').text = str(co.co_stacksize)
ET.SubElement(code_element, 'co_flags').text = str(co.co_flags)
ET.SubElement(code_element, 'co_varnames').text = str(co.co_varnames)
ET.SubElement(code_element, 'co_names').text = str(co.co_names)
# ET.SubElement(code_element, 'co_consts').text = str(co.co_consts)
ET.SubElement(code_element, 'co_lnotab').text = co.co_lnotab.hex()
co_code_element = ET.SubElement(code_element, 'co_code')
co_code_element.text = co.co_code.hex()
# Recursively process nested code objects
for const in co.co_consts:
if isinstance(const, types.CodeType):
co_consts = ET.SubElement(code_element, 'co_consts')
code_object_to_xml(const, co_consts)
# code object它是可能是一个嵌套的对象,可以转成json或者xml进行可视化展示
pyc_file_path = '__pycache__/demo.cpython-311.pyc'
pyc_contents = utils.read_pyc_file(pyc_file_path)
# 将bytes转成python中的对象
bytecode_data = pyc_contents['bytecode_data']
code_object = marshal.loads(bytecode_data) # 这里得到的就是一个code object对象
# xml
root = ET.Element('root')
code_object_to_xml(code_object, root)
tree = ET.ElementTree(root)
file_path = 'output.xml'
tree.write(file_path, encoding='utf-8', xml_declaration=True)
# json
result = {}
parse_code_object(code_object, result)
pprint.pprint(result, sort_dicts=False)
解析的xml结构如下:
<root>
<code co_name="<span class="token entity named-entity" title="<module">>">
<co_name><span class="token entity named-entity" title="<module">></co_name>
<co_filename>
/Users/lvliangliang/Desktop/python/7.project/python-source-code-learning/notes/02python虚拟机/demo.py
</co_filename>
<co_firstlineno>1</co_firstlineno>
<co_argcount>0</co_argcount>
<co_kwonlyargcount>0</co_kwonlyargcount>
<co_nlocals>0</co_nlocals>
<co_stacksize>4</co_stacksize>
<co_flags>0</co_flags>
<co_varnames>()</co_varnames>
<co_names>('A', 'a', 'fun')</co_names>
<co_lnotab>00ff02011a051401</co_lnotab>
<co_code>
970002004700640084006401a6020000ab0200000000000000005a0002006500a6000000ab0000000000000000005a016501a0020000000000000000000000000000000000000000a6000000ab000000000000000000010064025300
</co_code>
<co_consts>
<code co_name="A">
<co_name>A</co_name>
<co_filename>
/Users/lvliangliang/Desktop/python/7.project/python-source-code-learning/notes/02python虚拟机/demo.py
</co_filename>
<co_firstlineno>1</co_firstlineno>
<co_argcount>0</co_argcount>
<co_kwonlyargcount>0</co_kwonlyargcount>
<co_nlocals>0</co_nlocals>
<co_stacksize>2</co_stacksize>
<co_flags>0</co_flags>
<co_varnames>()</co_varnames>
<co_names>('__name__', '__module__', '__qualname__', 'fun')</co_names>
<co_lnotab>0a01</co_lnotab>
<co_code>970065005a0164005a026404640284015a0364035300</co_code>
<co_consts>
<code co_name="fun">
<co_name>fun</co_name>
<co_filename>
/Users/lvliangliang/Desktop/python/7.project/python-source-code-learning/notes/02python虚拟机/demo.py
</co_filename>
<co_firstlineno>2</co_firstlineno>
<co_argcount>2</co_argcount>
<co_kwonlyargcount>0</co_kwonlyargcount>
<co_nlocals>2</co_nlocals>
<co_stacksize>3</co_stacksize>
<co_flags>3</co_flags>
<co_varnames>('self', 'msg')</co_varnames>
<co_names>('print',)</co_names>
<co_lnotab>0201</co_lnotab>
<co_code>97007401000000000000000000006401a6010000ab010000000000000000010064005300</co_code>
</code>
</co_consts>
</code>
</co_consts>
</code>
</root>
我们写的代码是如何执行的?
还记得我们最开始的疑惑吗?—”我们写的代码是如何执行的?“,到现在为止,我们从pyc文件“下手”,搞懂了一个模块被加载时,它的源代码会被编译成code object对象,这是一个嵌套的对象,它包含了执行源代码需要的所有信息,为了提高加载速度,这个对象也会被缓存到对应的pyc文件中,所以,从这一点看,pyc文件只不过是一个载体,用于暂时存储code object罢了,code object才是我们后续研究的重点!想象一下,现在我们已经拿到包含字节码(虽然目前我们还不知道这是啥)的code object对象,虽然不知道它后续是什么样的,但是我们能够肯定的是:我们离python解释器已经更近一步了,离我们的代码被它执行的距离也越来越近了,这是一个好的开始!暂且记录我们的进度为50%吧,当我们的这个进度为100时,我们就能彻底搞清楚这个执行的过程啦!加油,后面我们再继续探索!
更多内容可以关注博主的个人博客系统:《Python源码剖析》之pyc文件
文章来源:https://blog.csdn.net/max_LLL/article/details/139222093
微信扫描下方的二维码阅读本文
暂无评论内容