CPython 字节码文件的结构是什么？

故事很长-你可以放一只海鸥。我也没有能力将文档中的所有内容复制到答案中，所以我必须自己阅读文档。此外，不会对dis进行实验- 假设问题的作者已经玩够了它并决定深入挖掘。

这是一个很长的问题，但由于它很受欢迎，我将针对一个选定的实现和一个选定的版本略微讨论这个主题CPython 3.6.1——这个版本是因为它是最新的，答案稍后会过时，而且因为这个问题明确说明了版本3.5.

一般来说，在最新版本中很容易弄清楚什么是什么 - 没有任何困难可以让你大吃一惊。起点将是py_compile模块。为什么来自它，而不是来自 C 来源？- 因为文档是这样说的：Этот модуль предоставляет функцию для генерации байт-кода из исходников. 正是医生所吩咐的。

我们也会提前写一个测试用例，在一个单独的test.py.

import time


def my_gen():
    for i in range(10):
        time.sleep(1)
        yield i**2


if __name__ == "__main__":
    for elem in my_gen():
        print(elem)

现在在主文件中我们可以像这样生成字节码：

import py_compile

py_compile.compile("test.py", "test.pyc")

扩展*.pyc只是一个扩展，一个命名约定，可以是任何东西，重要的是内容。

你可以像往常一样运行 - python test.pyc。

现在是时候关注生成字节码的函数了。你可以自己看资料，我摘录一段：

1. 那里发生的第一件事是确定输出字节码的路径和名称。我们已经明确指出了这一点。如果不是，则路径根据PEP 3147 / PEP 488确定，还取决于版本。

2. 文本源被转换为字节。该模块还负责 this -importlib或更确切地说是类importlib.machinery.SourceFileLoader。突然间，那里运行的所有代码都

   with _io.FileIO(path, 'r') as file:
       return file.read()
   

   也就是说，只是阅读源代码。在我们的代码中它看起来像：

   loader = importlib.machinery.SourceFileLoader('<py_compile>', file)
   source_bytes = loader.get_data(file)
   

3. 源被转换为 AST - 抽象语法树。不可能在这里写出源代码经过一系列各种函数和检查的路径，但简而言之：编译函数被调用：

   code1 = compile(source_bytes, file, mode='exec', dont_inherit=True)
   code = loader.source_to_code(source_bytes, file)
   
   print(code, type(code))
   
   print(code == code1)
   

   在上面的代码中，我复制了他们的源代码py_compile( loader.source_to_code) 并使用一个函数自己编写了它compile——简单情况下的结果是相同的。结果是模块中类的一个实例code。

4. 最后，最重要的是AST到字节码的转换。在 py_compile 中，这是这样完成的：

   source_stats = loader.path_stats(file)
   bytecode = importlib._bootstrap_external._code_to_bytecode(
           code, source_stats['mtime'], source_stats['size'])
   

   sourcestats看起来像这样{'mtime': 1493229661.7715623, 'size': 180}：mtime- 这是源代码更改的时间，以一些特殊的时间戳表示。它会进一步派上用场。

   内容code_to_bytecode：

   data = bytearray(MAGIC_NUMBER)
   data.extend(_w_long(mtime))
   data.extend(_w_long(source_size))
   data.extend(marshal.dumps(code))
   

   我很惊讶，但是转换为字节码本身通常需要 4 行。MAGIC_NUMBER- 一个神奇的词，每个新版本都是新的。对于 3.6.1（Python 3.6rc1）是(3379).to_bytes(2, 'little') + b'\r\n'. 可以在 中找到所有魔术词的列表importlib/_bootstrap_external.py。请注意，除了数字之外，还会插入一个回车符。功能_w_long是(int(x) & 0xFFFFFFFF).to_bytes(4, 'little')。- 您可以使用 HEX 编辑器检查 .pyc 文件的实际内容 - 一切都匹配。也就是说，代码本身在2 + 2 + 4 + 4字节之后开始。这些都是小东西，真正的目标是marshal模型和dumps函数。marshal-这个модуль, содержащий функции, которые могут читать и писать значение переменных в бинарном формате. Формате специфичен для Python, но независим от архитектуры конечной машины。

5. 此外，不幸的是，它在 python 中不起作用，你将不得不去源代码：你可以跟随对象的命运，但最终对象被这个函数marshal.dumps打成字节。它很长但相对简单。marshal 可以将很多对象放入一个文件中，但我们对该类型的对象感兴趣（它被传递给他）——为此有一个特殊的检查来查看传递的对象是否是一个代码。从这个函数可以看出，肯定写了很多信息——操作类型（op_code）、参数、参数值是这个列表中最简单的。这些变量的确切含义可以在 code.h文件中 PyCodeObject 结构的定义中看到（那里有很多注释）code

6. 不过，总的来说，并非全部。这仅仅是开始。我们可以看到具体的内容，按字节，写入了 pyc 文件，而不必爬入 C。事实是 Python 对象具有所有必要的属性code。我按照在 pyc 中编写的顺序排列参数：

   args = ['co_argcount', 'co_kwonlyargcount', 'co_nlocals', 'co_stacksize', 'co_flags',  'co_code', 'co_consts', 
           'co_names', 'co_varnames', 'co_freevars', 'co_cellvars', 'co_filename', 'co_name', 'co_firstlineno', 
           'co_lnotab']
   
   for arg in args:
       print(arg, getattr(code, arg, None))
   

   在屏幕上打印参数的值并计算偏移量（1 个调用w_long写入 4 个字节，W_TYPE写入 1 个字节）后，您可以使用 HEX 编辑器轻松查看写入的内容和位置。您已经可以使用 dis 分析 co_code - 在新版本中它有一个王牌get_instructions方法：

   for instruction in dis.get_instructions(code):
       print(instruction)
   

   它还具有一个字节偏移量、一个操作数代码以及您可能需要的一切。

7. 为了巩固您阅读的内容，您可以完全亲手解开pyc文件。我不会编写整个解析器 - 它非常昂贵，但根据已经编写的内容，您可以编写完整的解析器：

   from io import BytesIO
   import struct
   import datetime
   
   byte1_little = b"<c"
   byte2_little = b"<h"
   byte4_little = b"<I"
   
   byte1_big = b">c"
   byte2_big = b">h"
   byte4_big = b">I"
   
   INTEGER_TYPE = int.from_bytes(b'i', 'little')
   CODE_TYPE = int.from_bytes(b'c', 'little')
   SHORT_TUPLE_TYPE = int.from_bytes(b')', 'little')
   NONE_TYPE = int.from_bytes(b'N', 'little')
   
   
   def parse_string(raw_bytes):
       # Наш рулевой тут - https://github.com/python/cpython/blob/3.6/Python/marshal.c#L427
       # Байтик на тип, четверочку на размер
       SIZE = int.from_bytes(raw_bytes.read(4), 'little')
       print("BYTES TO READ: ", SIZE)
       s = raw_bytes.read(SIZE)
       return s
   
   
   def parse_code(raw_bytes):
       CO_ARGCOUNT = struct.unpack(byte4_little, raw_bytes.read(4))[0]
       co_kwonlyargcount = struct.unpack(byte4_little,     raw_bytes.read(4))[0]
       CO_NLOCALS = struct.unpack(byte4_little, raw_bytes.read(4))[0]
       CO_STACKSIZE = struct.unpack(byte4_little, raw_bytes.read(4))[0]
       CO_FLAGS = struct.unpack(byte4_little, raw_bytes.read(4))[0]
       print("CODE STATS:", CO_ARGCOUNT, co_kwonlyargcount, CO_NLOCALS, CO_STACKSIZE, CO_FLAGS)
       CODE_TYPE = raw_bytes.read(1)
       # Тип строка
       assert CODE_TYPE == b's'
       CODE_ITSELF = parse_string(raw_bytes)
       return CODE_ITSELF
   
   
   def parse_long(raw_bytes):
       VALUE = int.from_bytes(raw_bytes.read(4), 'little')
       print("LONG VALUE:", VALUE)
       return VALUE
   
   
   def parse_none(raw_bytes):
       # Уже отпрасили
       return None
   
   
   def parse_tuple(raw_bytes):
       # Размер у маленького - 1 байт, а не 4
       # https://github.com/python/cpython/blob/3.6/Python/marshal.c#L471
       SIZE = int.from_bytes(raw_bytes.read(1), 'little')
       print("TUPLE LEN:", SIZE)
       # Следующий тип - SHORT_TUPLE. Также по аналогии
       for index in range(SIZE):
           NEXT_TYPE = int.from_bytes(raw_bytes.read(1), 'little')
           if NEXT_TYPE == INTEGER_TYPE or NEXT_TYPE == INTEGER_TYPE | 128:
               print("LONG TYPE")
               parse_long(raw_bytes)
           # None 1 байт
           elif NEXT_TYPE == NONE_TYPE:
               print("NONE TYPE")
               parse_none(raw_bytes)
           # code
           elif NEXT_TYPE == CODE_TYPE or NEXT_TYPE == CODE_TYPE | 128:
               print("CODE TYPE")
               parse_code(raw_bytes)
           elif NEXT_TYPE == SHORT_TUPLE_TYPE:
               parse_tuple(raw_bytes)
   
   
   with open("test.pyc", "rb") as f:
       raw_bytes = BytesIO(f.read())
   
   MAGIC_NUMBER = struct.unpack(byte2_little, raw_bytes.read(2))[0]
   assert MAGIC_NUMBER == 3379
   # пропускаем \r\n
   raw_bytes.read(2)
   TIMESTAMP = struct.unpack(byte4_little, raw_bytes.read(4))[0]
   print(datetime.datetime.fromtimestamp(TIMESTAMP))
   SIZE = struct.unpack(byte4_little, raw_bytes.read(4))[0]
   print(SIZE)
   OBJ_TYPE = int.from_bytes(raw_bytes.read(1), 'little')
   # Объект типа TYPE_CODE - см. https://github.com/python/cpython/blob/3.6/Python/marshal.c#L46
   # Флаг 128 выставляется в функции https://github.com/python/cpython/blob/3.6/Python/marshal.c#L288
   assert OBJ_TYPE == CODE_TYPE | 128
   parse_code(raw_bytes)
   NEXT_TYPE = int.from_bytes(raw_bytes.read(1), 'little')
   # Small tuple
   if NEXT_TYPE == SHORT_TUPLE_TYPE:
       parse_tuple(raw_bytes)
   

   代码有些不完整，只处理了几个类型，但我希望思路清晰 - 这段代码是函数的镜像dumps- 只有使用w_object（写入对象）和它自己的简单类型记录器，你还需要r_object（读取对象）和简单的读者。r_object 已经写入，只需要仔细阅读即可。