《Python源码剖析》之pyc文件

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