Python 프로그램의 실행 프로세스에는 소스 코드를 바이트코드로 변환(즉, 컴파일)하고 바이트코드를 실행하는 것이 포함됩니다.

질문:

우리는 텍스트를 처리하거나 시스템 관리 작업을 수행하기 위해 매일 Python 프로그램을 작성해야 합니다. 프로그램이 작성된 후 python 명령만 입력하면 프로그램을 시작하고 실행을 시작할 수 있습니다.

$ python some-program.py

그러면 텍스트 형식의 .py 파일이 CPU에서 단계별로 실행할 수 있는 기계 명령어로 어떻게 변환됩니까? 단계? ? 또한 프로그램 실행 중에 .pyc 파일이 생성될 수 있습니다. 이 파일의 기능은 무엇입니까?

1. 실행 과정

파이썬은 동작 면에서는 쉘 스크립트와 같은 해석형 언어에 더 가깝지만, 사실 파이썬 프로그램의 실행 원리는 가상 머신으로 요약할 수 있는 자바나 C#과 동일합니다. 및 단어 섹션 코드 . Python은 두 단계로 프로그램을 실행합니다. 먼저 프로그램 코드를 바이트코드로 컴파일한 다음 가상 머신을 시작하여 바이트코드를 실행합니다.

Python 명령을 Python 인터프리터라고도 부르지만 기본적으로 다른 명령과 동일합니다. 스크립팅 언어 해석기는 차이점을 나타냅니다. 실제로 Python 인터프리터는 컴파일러와 가상 머신의 두 부분으로 구성됩니다. Python 인터프리터가 시작되면 주로 다음 두 단계를 수행합니다.

컴파일러는 .py 파일의 Python 소스 코드를 바이트코드로 컴파일합니다. 따라서 가상 머신은 컴파일러에서 생성된 바이트코드를 한 줄씩 실행합니다. .py 파일의 Python 문은 기계 명령어로 직접 변환되지 않고 Python 바이트코드로 변환됩니다.

2. 바이트코드

파이썬 프로그램의 컴파일된 결과는 바이트코드이며, 여기에는 파이썬 작동과 관련된 많은 내용이 포함되어 있습니다. 따라서 Python 가상 머신의 작동 메커니즘을 더 깊이 이해하기 위해서든 Python 프로그램의 작동 효율성을 최적화하기 위해서든 바이트코드가 핵심 콘텐츠입니다. 그렇다면 Python 바이트코드는 어떤 모습일까요? Python 프로그램의 바이트코드를 어떻게 얻을 수 있나요? Python은 소스 코드를 즉시 컴파일할 수 있는 내장 함수 컴파일을 제공합니다. 소스 코드의 컴파일 결과를 얻으려면 컴파일할 소스 코드를 매개 변수로 사용하여 컴파일 함수를 호출하기만 하면 됩니다.

3. 소스 코드 컴파일

아래에서는 컴파일 기능을 통해 프로그램을 컴파일합니다.

소스 코드는 데모.py 파일에 저장됩니다.

PI = 3.14

def circle_area(r):
    return PI * r ** 2

class Person(object):
    def __init__(self, name):
        self.name = name

    def say(self):
        print('i am', self.name)

컴파일하기 전에 소스 코드를 파일에서 읽어야 합니다.

>>> text = open('D:\myspace\code\pythonCode\mix\demo.py').read()
>>> print(text)
PI = 3.14

def circle_area(r):
    return PI * r ** 2

class Person(object):
    def __init__(self, name):
        self.name = name

    def say(self):
        print('i am', self.name)

그런 다음 컴파일 함수는 소스 코드를 컴파일합니다:

>>> result = compile(text,'D:\myspace\code\pythonCode\mix\demo.py', 'exec')

컴파일 함수에는 3개의 매개변수가 필요합니다:

source: 컴파일할 소스 코드

filename: 소스 코드가 있는 파일 이름

mode: 컴파일 모드, exec는 소스 코드를 모듈로 처리하는 것을 의미합니다. 컴파일

세 가지 컴파일 모드:

exec: 모듈 소스 코드를 컴파일하는 데 사용

single: 단일 Python 문(대화식)을 컴파일하는 데 사용

eval: 컴파일에 사용 평가 표현식

4. PyCodeObject

컴파일 함수를 통해 최종 소스 코드 컴파일 결과를 얻었습니다.

>>> result
<code object <module> at 0x000001DEC2FCF680, file "D:\myspace\code\pythonCode\mix\demo.py", line 1>
>>> result.__class__
<class &#39;code&#39;>

마지막으로 코드 유형 객체를 얻었고 해당 기본 구조는 PyCodeObject

PyCodeObject 소스 코드는 다음과 같습니다.

/* Bytecode object */
struct PyCodeObject {
    PyObject_HEAD
    int co_argcount;            /* #arguments, except *args */
    int co_posonlyargcount;     /* #positional only arguments */
    int co_kwonlyargcount;      /* #keyword only arguments */
    int co_nlocals;             /* #local variables */
    int co_stacksize;           /* #entries needed for evaluation stack */
    int co_flags;               /* CO_..., see below */
    int co_firstlineno;         /* first source line number */
    PyObject *co_code;          /* instruction opcodes */
    PyObject *co_consts;        /* list (constants used) */
    PyObject *co_names;         /* list of strings (names used) */
    PyObject *co_varnames;      /* tuple of strings (local variable names) */
    PyObject *co_freevars;      /* tuple of strings (free variable names) */
    PyObject *co_cellvars;      /* tuple of strings (cell variable names) */
    /* The rest aren't used in either hash or comparisons, except for co_name,
       used in both. This is done to preserve the name and line number
       for tracebacks and debuggers; otherwise, constant de-duplication
       would collapse identical functions/lambdas defined on different lines.
    */
    Py_ssize_t *co_cell2arg;    /* Maps cell vars which are arguments. */
    PyObject *co_filename;      /* unicode (where it was loaded from) */
    PyObject *co_name;          /* unicode (name, for reference) */
    PyObject *co_linetable;     /* string (encoding addr<->lineno mapping) See
                                   Objects/lnotab_notes.txt for details. */
    void *co_zombieframe;       /* for optimization only (see frameobject.c) */
    PyObject *co_weakreflist;   /* to support weakrefs to code objects */
    /* Scratch space for extra data relating to the code object.
       Type is a void* to keep the format private in codeobject.c to force
       people to go through the proper APIs. */
    void *co_extra;

    /* Per opcodes just-in-time cache
     *
     * To reduce cache size, we use indirect mapping from opcode index to
     * cache object:
     *   cache = co_opcache[co_opcache_map[next_instr - first_instr] - 1]
     */

    // co_opcache_map is indexed by (next_instr - first_instr).
    //  * 0 means there is no cache for this opcode.
    //  * n > 0 means there is cache in co_opcache[n-1].
    unsigned char *co_opcache_map;
    _PyOpcache *co_opcache;
    int co_opcache_flag;  // used to determine when create a cache.
    unsigned char co_opcache_size;  // length of co_opcache.
};

코드 객체 PyCodeObject는 코드에 포함된 바이트코드와 상수, 이름 등을 포함한 컴파일 결과를 저장하는 데 사용됩니다. 주요 필드는 다음과 같습니다.

fieldco_argcountco_kwonlyargcountco_nlocalsco_stacksizeco_flagsco_firstlinenoco_codeco_constsco_namesco_varnames

下面打印看一下这些字段对应的数据：

通过co_code字段获得字节码：

>>> result.co_code
b'd\x00Z\x00d\x01d\x02\x84\x00Z\x01G\x00d\x03d\x04\x84\x00d\x04e\x02\x83\x03Z\x03d\x05S\x00'

通过co_names字段获得代码对象涉及的所有名字：

>>> result.co_names
('PI', 'circle_area', 'object', 'Person')

通过co_consts字段获得代码对象涉及的所有常量：

>>> result.co_consts
(3.14, <code object circle_area at 0x0000023D04D3F310, file "D:\myspace\code\pythonCode\mix\demo.py", line 3>, &#39;circle_area&#39;, <code object Person at 0x0000023D04D3F5D0, file "D:\myspace\code\pythonCode\mix\demo.py", line 6>, &#39;Person&#39;, None)

可以看到，常量列表中还有两个代码对象，其中一个是circle_area函数体，另一个是Person类定义体。对应Python中作用域的划分方式，可以自然联想到：每个作用域对应一个代码对象。如果这个假设成立，那么Person代码对象的常量列表中应该还包括两个代码对象：init函数体和say函数体。下面取出Person类代码对象来看一下：

>>> person_code = result.co_consts[3]
>>> person_code
<code object Person at 0x0000023D04D3F5D0, file "D:\myspace\code\pythonCode\mix\demo.py", line 6>
>>> person_code.co_consts
(&#39;Person&#39;, <code object __init__ at 0x0000023D04D3F470, file "D:\myspace\code\pythonCode\mix\demo.py", line 7>, &#39;Person.__init__&#39;, <code object say at 0x0000023D04D3F520, file "D:\myspace\code\pythonCode\mix\demo.py", line 10>, &#39;Person.say&#39;, None)

因此，我们得出结论：Python源码编译后，每个作用域都对应着一个代码对象，子作用域代码对象位于父作用域代码对象的常量列表里，层级一一对应。

至此，我们对Python源码的编译结果——代码对象PyCodeObject有了最基本的认识，后续会在虚拟机、函数机制、类机制中进一步学习。

5. 反编译

字节码是一串不可读的字节序列，跟二进制机器码一样。如果想读懂机器码，可以将其反汇编，那么字节码可以反编译吗？

通过dis模块可以将字节码反编译：

>>> import dis
>>> dis.dis(result.co_code)
 0 LOAD_CONST               0 (0)
 2 STORE_NAME               0 (0)
 4 LOAD_CONST               1 (1)
 6 LOAD_CONST               2 (2)
 8 MAKE_FUNCTION            0
10 STORE_NAME               1 (1)
12 LOAD_BUILD_CLASS
14 LOAD_CONST               3 (3)
16 LOAD_CONST               4 (4)
18 MAKE_FUNCTION            0
20 LOAD_CONST               4 (4)
22 LOAD_NAME                2 (2)
24 CALL_FUNCTION            3
26 STORE_NAME               3 (3)
28 LOAD_CONST               5 (5)
30 RETURN_VALUE

字节码反编译后的结果和汇编语言很类似。其中，第一列是字节码的偏移量，第二列是指令，第三列是操作数。以第一条字节码为例，LOAD_CONST指令将常量加载进栈，常量下标由操作数给出，而下标为0的常量是：

>>> result.co_consts[0]3.14

这样，第一条字节码的意义就明确了：将常量3.14加载到栈。

由于代码对象保存了字节码、常量、名字等上下文信息，因此直接对代码对象进行反编译可以得到更清晰的结果：

>>>dis.dis(result)
  1           0 LOAD_CONST               0 (3.14)
              2 STORE_NAME               0 (PI)

  3           4 LOAD_CONST               1 (<code object circle_area at 0x0000023D04D3F310, file "D:\myspace\code\pythonCode\mix\demo.py", line 3>)
              6 LOAD_CONST               2 (&#39;circle_area&#39;)
              8 MAKE_FUNCTION            0
             10 STORE_NAME               1 (circle_area)

  6          12 LOAD_BUILD_CLASS
             14 LOAD_CONST               3 (<code object Person at 0x0000023D04D3F5D0, file "D:\myspace\code\pythonCode\mix\demo.py", line 6>)
             16 LOAD_CONST               4 (&#39;Person&#39;)
             18 MAKE_FUNCTION            0
             20 LOAD_CONST               4 (&#39;Person&#39;)
             22 LOAD_NAME                2 (object)
             24 CALL_FUNCTION            3
             26 STORE_NAME               3 (Person)
             28 LOAD_CONST               5 (None)
             30 RETURN_VALUE

Disassembly of <code object circle_area at 0x0000023D04D3F310, file "D:\myspace\code\pythonCode\mix\demo.py", line 3>:
  4           0 LOAD_GLOBAL              0 (PI)
              2 LOAD_FAST                0 (r)
              4 LOAD_CONST               1 (2)
              6 BINARY_POWER
              8 BINARY_MULTIPLY
             10 RETURN_VALUE

Disassembly of <code object Person at 0x0000023D04D3F5D0, file "D:\myspace\code\pythonCode\mix\demo.py", line 6>:
  6           0 LOAD_NAME                0 (__name__)
              2 STORE_NAME               1 (__module__)
              4 LOAD_CONST               0 (&#39;Person&#39;)
              6 STORE_NAME               2 (__qualname__)

  7           8 LOAD_CONST               1 (<code object __init__ at 0x0000023D04D3F470, file "D:\myspace\code\pythonCode\mix\demo.py", line 7>)
             10 LOAD_CONST               2 (&#39;Person.__init__&#39;)
             12 MAKE_FUNCTION            0
             14 STORE_NAME               3 (__init__)

 10          16 LOAD_CONST               3 (<code object say at 0x0000023D04D3F520, file "D:\myspace\code\pythonCode\mix\demo.py", line 10>)
             18 LOAD_CONST               4 (&#39;Person.say&#39;)
             20 MAKE_FUNCTION            0
             22 STORE_NAME               4 (say)
             24 LOAD_CONST               5 (None)
             26 RETURN_VALUE

Disassembly of <code object __init__ at 0x0000023D04D3F470, file "D:\myspace\code\pythonCode\mix\demo.py", line 7>:
  8           0 LOAD_FAST                1 (name)
              2 LOAD_FAST                0 (self)
              4 STORE_ATTR               0 (name)
              6 LOAD_CONST               0 (None)
              8 RETURN_VALUE

Disassembly of <code object say at 0x0000023D04D3F520, file "D:\myspace\code\pythonCode\mix\demo.py", line 10>:
 11           0 LOAD_GLOBAL              0 (print)
              2 LOAD_CONST               1 (&#39;i am&#39;)
              4 LOAD_FAST                0 (self)
              6 LOAD_ATTR                1 (name)
              8 CALL_FUNCTION            2
             10 POP_TOP
             12 LOAD_CONST               0 (None)
             14 RETURN_VALUE

操作数指定的常量或名字的实际值在旁边的括号内列出，此外，字节码以语句为单位进行了分组，中间以空行隔开，语句的行号在字节码前面给出。例如PI = 3.14这个语句就被会变成了两条字节码：

  1           0 LOAD_CONST               0 (3.14)
              2 STORE_NAME               0 (PI)

6. pyc

如果将demo作为模块导入，Python将在demo.py文件所在目录下生成.pyc文件：

>>> import demo

pyc文件会保存经过序列化处理的代码对象PyCodeObject。这样一来，Python后续导入demo模块时，直接读取pyc文件并反序列化即可得到代码对象，避免了重复编译导致的开销。只有demo.py有新修改（时间戳比.pyc文件新），Python才会重新编译。

因此，对比Java而言：Python中的.py文件可以类比Java中的.java文件，都是源码文件；而.pyc文件可以类比.class文件，都是编译结果。只不过Java程序需要先用编译器javac命令来编译，再用虚拟机java命令来执行；而Python解释器把这两个过程都完成了。

목적
매개변수 수
키워드 매개변수 수
지역변수 개수
코드 실행에 필요한 스택 공간
Identification
코드 블록의 첫 번째 줄 번호
명령어 op 코드, 즉 바이트코드
상수 목록
name list
지역 변수 이름 목록

위 내용은 Python 프로그램의 실행 프로세스에는 소스 코드를 바이트코드로 변환(즉, 컴파일)하고 바이트코드를 실행하는 것이 포함됩니다.의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!