Heim > Artikel > Backend-Entwicklung > Wie ist die Pyc-Dateistruktur der virtuellen Python-Maschine?
Wie ist die Pyc-Dateistruktur der virtuellen Python-Maschine?
- 王林nach vorne
- 2023-05-27 21:01:581424Durchsuche
PYC-Datei
pyc-Datei ist eine Bytecode-Datei, die von Python beim Interpretieren und Ausführen des Quellcodes generiert wird. Sie enthält die Kompilierungsergebnisse des Quellcodes und zugehörige Metadateninformationen, damit Python den Code schneller laden und ausführen kann.
Im Gegensatz zu kompilierten Sprachen ist Python eine interpretierte Sprache und kompiliert den Quellcode nicht direkt in Maschinencode und führt ihn aus. Bevor der Code ausgeführt wird, kompiliert der Python-Interpreter zunächst den Quellcode in Bytecode und interpretiert ihn dann zur Ausführung. Die .pyc-Datei ist die Bytecode-Datei, die während dieses Prozesses generiert wird.
Wenn der Python-Interpreter eine .py-Datei zum ersten Mal ausführt, generiert er eine entsprechende .pyc-Datei im selben Verzeichnis, damit sie beim nächsten Laden der Datei schneller ausgeführt werden kann. Wenn die Quelldatei geändert und neu geladen wird, generiert der Interpreter die .pyc-Datei neu, um den zwischengespeicherten Bytecode zu aktualisieren.
PYC-Dateien generieren
Normale Python-Dateien müssen über den Compiler in Bytecode umgewandelt werden. Anschließend wird der Bytecode an die virtuelle Python-Maschine übergeben, und dann führt die virtuelle Python-Maschine den Bytecode aus. Der Gesamtprozess ist wie folgt:
Wir können das Modul „Alle kompilieren“ direkt verwenden, um die Pyc-Datei der entsprechenden Datei zu generieren.
➜ pvm ls demo.py hello.py ➜ pvm python -m compileall . Listing '.'... Listing './.idea'... Listing './.idea/inspectionProfiles'... Compiling './demo.py'... Compiling './hello.py'... ➜ pvm ls __pycache__ demo.py hello.py ➜ pvm ls __pycache__ demo.cpython-310.pyc hello.cpython-310.pyc
python -m compileall . Der Befehl scannt rekursiv die py-Dateien im aktuellen Verzeichnis und generiert die pyc-Datei der entsprechenden Datei. python -m compileall . 命令将递归扫描当前目录下面的 py 文件，并且生成对应文件的 pyc 文件。
PYC 文件布局
第一部分魔数由两部分组成：
第一部分 魔术是由一个 2 字节的整数和另外两个字符回车换行组成的， "rn" 也占用两个字节，一共是四个字节。这个两个字节的整数在不同的 python 版本还不一样，比如说在 python3.5 当中这个值为 3351 等值，在 python3.9 当中这个值为 3420，3421，3422，3423，3424等值（在 python 3.9 的小版本）。
第二部分 Bit Field 这个字段的主要作用是为了将来能够实现复现编译结果，但是在 python3.9a2 时，这个字段的值还全部是 0 。请参考PEP552-确定性pyc的详细内容。这个字段在 python2 和 python3 早期版本并没有（python3.5 还没有），在 python3 的后期版本这个字段才出现的。
第三部分 就是整个 py 源文件的大小了。
第四部分 也是整个 pyc 文件当中最重要的一个部分，最后一个部分就是一个 CodeObject 对象序列化之后的数据，我们稍后再来仔细分析一下这个对象相关的数据。
我们现在来具体分析一个 pyc 文件，对应的 python 代码为：
def f():
x = 1
return 2pyc 文件的十六进制形式如下所示：
➜ __pycache__ hexdump -C hello.cpython-310.pyc 00000000 6f 0d 0d 0a 00 00 00 00 b9 48 21 64 20 00 00 00 |o........H!d ...| 00000010 e3 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................| 00000020 00 02 00 00 00 40 00 00 00 73 0c 00 00 00 64 00 |.....@...s....d.| 00000030 64 01 84 00 5a 00 64 02 53 00 29 03 63 00 00 00 |d...Z.d.S.).c...| 00000040 00 00 00 00 00 00 00 00 00 01 00 00 00 01 00 00 |................| 00000050 00 43 00 00 00 73 08 00 00 00 64 01 7d 00 64 02 |.C...s....d.}.d.| 00000060 53 00 29 03 4e e9 01 00 00 00 e9 02 00 00 00 a9 |S.).N...........| 00000070 00 29 01 da 01 78 72 03 00 00 00 72 03 00 00 00 |.)...xr....r....| 00000080 fa 0a 2e 2f 68 65 6c 6c 6f 2e 70 79 da 01 66 01 |.../hello.py..f.| 00000090 00 00 00 73 04 00 00 00 04 01 04 01 72 06 00 00 |...s........r...| 000000a0 00 4e 29 01 72 06 00 00 00 72 03 00 00 00 72 03 |.N).r....r....r.| 000000b0 00 00 00 72 03 00 00 00 72 05 00 00 00 da 08 3c |...r....r......<| 000000c0 6d 6f 64 75 6c 65 3e 01 00 00 00 73 02 00 00 00 |module>....s....| 000000d0 0c 00 |..| 000000d2
因为数据使用小端表示方式，因此对于上面的数据来说：
第一部分魔数为：0xa0d0d6f 。
第二部分 Bit Field 为：0x0 。
第三部分最后一次修改日期为：0x642148b9 。
第四部分文件大小为：0x20 字节，也就是说 hello.py 这个文件的大小是 32 字节。
下面是一个小的代码片段用于读取 pyc 文件的头部元信息：
import struct
import time
import binascii
fname = "./__pycache__/hello.cpython-310.pyc"
f = open(fname, "rb")
magic = struct.unpack('<l', f.read(4))[0]
bit_filed = f.read(4)
print(f"bit field = {binascii.hexlify(bit_filed)}")
moddate = f.read(4)
filesz = f.read(4)
modtime = time.asctime(time.localtime(struct.unpack('<l', moddate)[0]))
filesz = struct.unpack('<L', filesz)
print("magic %s" % (hex(magic)))
print("moddate (%s)" % (modtime))
print("File Size %d" % filesz)
f.close()上面的代码输出结果如下所示：
bit field = b'00000000'
magic 0xa0d0d6f
moddate (Mon Mar 27 15:41:45 2023)
File Size 32
有关 pyc 文件的详细操作可以查看 python 标准库 importlib/_bootstrap_external.py 文件源代码。
CODEOBJECT
在 CPython 中，CodeObject 是一个对象，它包含了 Python 代码的字节码、常量、变量、位置参数、关键字参数等信息，以及一些用于运行代码的元数据，如文件名、代码行号等。
在 CPython 中，当我们执行一个 Python 模块或函数时，解释器会先将其代码编译为 CodeObject，然后再执行。在编译过程中，解释器会将 Python 代码转换为字节码，并将其保存在 CodeObject 对象中。此后，每当我们调用该模块或函数时，解释器都会使用 CodeObject 中的字节码来执行代码。
CodeObject 对象是不可变的，一旦创建就不能被修改。这是因为 Python 代码的字节码是不可变的，而 CodeObject
🎜🎜Der erste Teil der magischen Zahl besteht aus zwei Teilen: 🎜🎜🎜🎜Der erste Teil der Magie besteht aus einer 2-Byte-Ganzzahl und zwei weiteren Zeichen, Wagenrücklauf und Zeilenvorschub belegen ebenfalls zwei Bytes, a insgesamt vier Bytes. Diese Zwei-Byte-Ganzzahl ist in verschiedenen Python-Versionen unterschiedlich. In Python3.5 ist dieser Wert beispielsweise 3351 usw. und in Python3.9 ist dieser Wert 3420, 3421, 3422, 3423, 3424 usw. ( in einer Nebenversion von Python 3.9). 🎜🎜Teil 2 Bitfeld Der Hauptzweck dieses Feldes besteht darin, in Zukunft reproduzierbare Kompilierungsergebnisse zu ermöglichen, aber in Python3.9a2 sind die Werte dieses Feldes immer noch alle 0. Weitere Informationen finden Sie unter PEP552 – Deterministisches Pyc. Dieses Feld ist in frühen Versionen von Python2 und Python3 nicht vorhanden (noch nicht in Python3.5). Dieses Feld erscheint nur in späteren Versionen von Python3. 🎜🎜Der dritte Teil ist die Größe der gesamten Py-Quelldatei. 🎜🎜Der vierte Teil ist auch der wichtigste Teil der gesamten Pyc-Datei. Der letzte Teil sind die Daten nach der Serialisierung eines CodeObject-Objekts. Wir werden die Daten zu diesem Objekt später sorgfältig analysieren. 🎜🎜Lassen Sie uns nun eine Pyc-Datei im Detail analysieren. Der entsprechende Python-Code lautet: 🎜if __name__ == '__main__':
a = 100
print(a)🎜Die Hexadezimalform der Pyc-Datei lautet wie folgt: 🎜import marshal
import dis
import struct
import time
import types
import binascii
def print_metadata(fp):
magic = struct.unpack('<l', fp.read(4))[0]
print(f"magic number = {hex(magic)}")
bit_field = struct.unpack('<l', fp.read(4))[0]
print(f"bit filed = {bit_field}")
t = struct.unpack('<l', fp.read(4))[0]
print(f"time = {time.asctime(time.localtime(t))}")
file_size = struct.unpack('<l', fp.read(4))[0]
print(f"file size = {file_size}")
def show_code(code, indent=''):
print ("%scode" % indent)
indent += ' '
print ("%sargcount %d" % (indent, code.co_argcount))
print ("%snlocals %d" % (indent, code.co_nlocals))
print ("%sstacksize %d" % (indent, code.co_stacksize))
print ("%sflags %04x" % (indent, code.co_flags))
show_hex("code", code.co_code, indent=indent)
dis.disassemble(code)
print ("%sconsts" % indent)
for const in code.co_consts:
if type(const) == types.CodeType:
show_code(const, indent+' ')
else:
print(" %s%r" % (indent, const))
print("%snames %r" % (indent, code.co_names))
print("%svarnames %r" % (indent, code.co_varnames))
print("%sfreevars %r" % (indent, code.co_freevars))
print("%scellvars %r" % (indent, code.co_cellvars))
print("%sfilename %r" % (indent, code.co_filename))
print("%sname %r" % (indent, code.co_name))
print("%sfirstlineno %d" % (indent, code.co_firstlineno))
show_hex("lnotab", code.co_lnotab, indent=indent)
def show_hex(label, h, indent):
h = binascii.hexlify(h)
if len(h) < 60:
print("%s%s %s" % (indent, label, h))
else:
print("%s%s" % (indent, label))
for i in range(0, len(h), 60):
print("%s %s" % (indent, h[i:i+60]))
if __name__ == '__main__':
filename = "./__pycache__/pycdemo01.cpython-39.pyc"
with open(filename, "rb") as fp:
print_metadata(fp)
code_object = marshal.load(fp)
show_code(code_object)🎜Da die Daten für die oben genannten Daten eine Little-Endian-Darstellung verwenden:🎜magic number = 0xa0d0d61
bit filed = 0
time = Tue Mar 28 02:40:20 2023
file size = 54
code
argcount 0
nlocals 0
stacksize 2
flags 0040
code b'650064006b02721464015a01650265018301010064025300'
3 0 LOAD_NAME 0 (__name__)
2 LOAD_CONST 0 ('__main__')
4 COMPARE_OP 2 (==)
6 POP_JUMP_IF_FALSE 20
4 8 LOAD_CONST 1 (100)
10 STORE_NAME 1 (a)
5 12 LOAD_NAME 2 (print)
14 LOAD_NAME 1 (a)
16 CALL_FUNCTION 1
18 POP_TOP
>> 20 LOAD_CONST 2 (None)
22 RETURN_VALUE
consts
'__main__'
100
None
names ('__name__', 'a', 'print')
varnames ()
freevars ()
cellvars ()
filename './pycdemo01.py'
name '<module>'
firstlineno 3
lnotab b'08010401'🎜Die Ausgabe des obigen Codes ist wie folgt: 🎜🎜bit field = b'00000000'🎜Für detaillierte Vorgänge an Pyc-Dateien können Sie die Python-Standardbibliothek importlib anzeigen /_bootstrap_external. py-Datei-Quellcode. 🎜🎜CODEOBJECT🎜🎜In CPython ist
magic 0xa0d0d6f
moddate (Mo 27. März 15:41:45 2023)
Dateigröße 32🎜
CodeObject ein Objekt, das den Bytecode, Konstanten, Variablen, Positionsparameter, Schlüsselwortparameter und andere Informationen des Python-Codes sowie einige Informationen enthält, die zum Ausführen des verwendet werden Code-Metadaten, wie Dateiname, Codezeilennummer usw. 🎜🎜Wenn wir in CPython ein Python-Modul oder eine Python-Funktion ausführen, kompiliert der Interpreter zunächst seinen Code in CodeObject und führt ihn dann aus. Während der Kompilierung wandelt der Interpreter Python-Code in Bytecode um und speichert ihn in einem CodeObject-Objekt. Wenn wir danach dieses Modul oder diese Funktion aufrufen, verwendet der Interpreter den Bytecode in CodeObject, um den Code auszuführen. 🎜🎜CodeObject-Objekte sind unveränderlich und können nach ihrer Erstellung nicht mehr geändert werden. Dies liegt daran, dass der Bytecode des Python-Codes unveränderlich ist und das CodeObject-Objekt diese Bytecodes enthält, sodass es ebenfalls unveränderlich ist. 🎜🎜In diesem Artikel stellen wir hauptsächlich die Hauptinhalte des Codeobjekts vor und stellen kurz deren Funktionen vor. In den folgenden Artikeln werden wir den dem Codeobjekt entsprechenden Quellcode und die detaillierten Funktionen der entsprechenden Felder sorgfältig analysieren. 🎜现在举一个例子来分析一下 pycdemo.py 的 pyc 文件，pycdemo.py 的源程序如下所示：
if __name__ == '__main__':
a = 100
print(a)下面的代码是一个用于加载 pycdemo01.cpython-39.pyc 文件（也就是 hello.py 对应的 pyc 文件）的代码，使用 marshal 读取 pyc 文件里面的 code object 。
import marshal
import dis
import struct
import time
import types
import binascii
def print_metadata(fp):
magic = struct.unpack('<l', fp.read(4))[0]
print(f"magic number = {hex(magic)}")
bit_field = struct.unpack('<l', fp.read(4))[0]
print(f"bit filed = {bit_field}")
t = struct.unpack('<l', fp.read(4))[0]
print(f"time = {time.asctime(time.localtime(t))}")
file_size = struct.unpack('<l', fp.read(4))[0]
print(f"file size = {file_size}")
def show_code(code, indent=''):
print ("%scode" % indent)
indent += ' '
print ("%sargcount %d" % (indent, code.co_argcount))
print ("%snlocals %d" % (indent, code.co_nlocals))
print ("%sstacksize %d" % (indent, code.co_stacksize))
print ("%sflags %04x" % (indent, code.co_flags))
show_hex("code", code.co_code, indent=indent)
dis.disassemble(code)
print ("%sconsts" % indent)
for const in code.co_consts:
if type(const) == types.CodeType:
show_code(const, indent+' ')
else:
print(" %s%r" % (indent, const))
print("%snames %r" % (indent, code.co_names))
print("%svarnames %r" % (indent, code.co_varnames))
print("%sfreevars %r" % (indent, code.co_freevars))
print("%scellvars %r" % (indent, code.co_cellvars))
print("%sfilename %r" % (indent, code.co_filename))
print("%sname %r" % (indent, code.co_name))
print("%sfirstlineno %d" % (indent, code.co_firstlineno))
show_hex("lnotab", code.co_lnotab, indent=indent)
def show_hex(label, h, indent):
h = binascii.hexlify(h)
if len(h) < 60:
print("%s%s %s" % (indent, label, h))
else:
print("%s%s" % (indent, label))
for i in range(0, len(h), 60):
print("%s %s" % (indent, h[i:i+60]))
if __name__ == '__main__':
filename = "./__pycache__/pycdemo01.cpython-39.pyc"
with open(filename, "rb") as fp:
print_metadata(fp)
code_object = marshal.load(fp)
show_code(code_object)执行上面的程序输出结果如下所示：
magic number = 0xa0d0d61
bit filed = 0
time = Tue Mar 28 02:40:20 2023
file size = 54
code
argcount 0
nlocals 0
stacksize 2
flags 0040
code b'650064006b02721464015a01650265018301010064025300'
3 0 LOAD_NAME 0 (__name__)
2 LOAD_CONST 0 ('__main__')
4 COMPARE_OP 2 (==)
6 POP_JUMP_IF_FALSE 20
4 8 LOAD_CONST 1 (100)
10 STORE_NAME 1 (a)
5 12 LOAD_NAME 2 (print)
14 LOAD_NAME 1 (a)
16 CALL_FUNCTION 1
18 POP_TOP
>> 20 LOAD_CONST 2 (None)
22 RETURN_VALUE
consts
'__main__'
100
None
names ('__name__', 'a', 'print')
varnames ()
freevars ()
cellvars ()
filename './pycdemo01.py'
name '<module>'
firstlineno 3
lnotab b'08010401'下面是 code object 当中各个字段的作用：
首先需要了解一下代码块这个概念，所谓代码块就是一个小的 python 代码，被当做一个小的单元整体执行。在 Python 中常见的代码块包括函数体、类的定义和模块。
argcount，这个表示一个代码块的参数个数，这个参数只对函数体代码块有用，因为函数可能会有参数，比如上面的 pycdemo.py 是一个模块而不是一个函数，因此这个参数对应的值为 0 。
co_code，这个对象的具体内容就是一个字节序列，存储真实的 python 字节码，主要是用于 python 虚拟机执行的，在本篇文章当中暂时不详细分析。
co_consts，这个字段是一个列表类型的字段，主要是包含一些字符串常量和数值常量，比如上面的 ";main" 和 100 。
co_filename，这个字段的含义就是对应的源文件的文件名。
co_firstlineno，这个字段的含义为在 python 源文件当中第一行代码出现的行数，这个字段在进行调试的时候非常重要。
主要含义是标识该 code object 的类型的字段是 co_flags。0x0080 表示这个 block 是一个协程，0x0010 表示这个 code object 是嵌套的等等。
co_lnotab，这个字段的含义主要是用于计算每个字节码指令对应的源代码行数。
The main purpose of the field "co_varnames" is to indicate a name defined locally in a code object.。
co_names，和 co_varnames 相反，表示非本地定义但是在 code object 当中使用的名字。
co_nlocals，这个字段表示在一个 code object 当中本地使用的变量个数。
co_stackszie，因为 python 虚拟机是一个栈式计算机，这个参数的值表示这个栈需要的最大的值。
co_cellvars，co_freevars，这两个字段主要和嵌套函数和函数闭包有关。
Das obige ist der detaillierte Inhalt vonWie ist die Pyc-Dateistruktur der virtuellen Python-Maschine?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
In Verbindung stehende Artikel
Mehr sehen- Detaillierte Erläuterung von Python-bezogenen Operationsbeispielen auf JSON
- Python Fabric implementiert die Remote-Bereitstellung
- So implementieren Sie den SSH-Fernzugriff mit Python Paramiko
- Python Fabric implementiert Beispiele für Remote-Betrieb und -Bereitstellung
- Python Fabric implementiert die Remote-Bereitstellung