Какие знаешь этапы выполнения кода в интерпретируемом языке?

Этапы выполнения кода в интерпретируемом языке (Python)

Python часто называют интерпретируемым языком, но на деле процесс более сложен. Код проходит несколько этапов перед исполнением.

1. Исходный код (Source Code)

Это файл .py с текстом программы на Python.

# example.py
def greet(name):
    return f"Hello, {name}!"

result = greet("World")
print(result)

Характеристики:

• Читается построчно
• Может содержать синтаксические ошибки

2. Лексический анализ (Lexical Analysis / Tokenization)

Исходный текст разбивается на токены (лексемы) — минимальные единицы языка.

# Код:
result = greet("World")

# Токены:
# NAME: result
# EQUAL: =
# NAME: greet
# LPAR: (
# STRING: "World"
# RPAR: )
# NEWLINE

Python использует модуль tokenize для этого этапа.

import tokenize
import io

code = "x = 10 + 5"
tokens = list(tokenize.generate_tokens(io.StringIO(code).readline))
for token in tokens:
    print(token)

3. Синтаксический анализ (Parsing / Syntax Analysis)

Токены преобразуются в абстрактное синтаксическое дерево (AST — Abstract Syntax Tree).

import ast

code = """
def add(a, b):
    return a + b
"""

tree = ast.parse(code)
print(ast.dump(tree, indent=2))

Вывод будет содержать структуру:

Module(
  body=[
    FunctionDef(
      name="add",
      args=arguments(args=[arg(arg="a"), arg(arg="b")]),
      body=[Return(value=BinOp(left=Name(id="a"), op=Add(), right=Name(id="b")))]
    )
  ]
)

Проверки на этом этапе:

• Корректная расстановка скобок
• Правильный синтаксис операторов
• Валидная структура кода

4. Компиляция в байт-код (Compilation to Bytecode)

AST компилируется в байт-код — промежуточное представление, независимое от платформы.

import dis

def multiply(x, y):
    return x * y

# Просмотр байт-кода
dis.dis(multiply)

# Вывод:
#  2           0 LOAD_FAST                0 (x)
#              2 LOAD_FAST                1 (y)
#              4 BINARY_MULTIPLY
#              6 RETURN_VALUE

Полученный байт-код кэшируется в файлы .pyc в папке __pycache__/.

import py_compile

# Явная компиляция
py_compile.compile("module.py", cfile="module.pyc")

Преимущества байт-кода:

• Быстрее парсить повторно
• Меньше размер чем исходный код
• Независим от платформы

5. Виртуальная машина Python (PVM — Python Virtual Machine)

Байт-код исполняется интерпретатором (PVM), построенным на основе стека.

# Простой пример
x = 10
y = 20
z = x + y

# Соответствующий байт-код:
# LOAD_CONST    0 (10)
# STORE_FAST    0 (x)
# LOAD_CONST    1 (20)
# STORE_FAST    1 (y)
# LOAD_FAST     0 (x)
# LOAD_FAST     1 (y)
# BINARY_ADD
# STORE_FAST    2 (z)

PVM выполняет:

• Выделение памяти
• Управление ссылками
• Вызов функций
• Обработку исключений

6. Оптимизации во время выполнения (Runtime Optimizations)

Современные версии Python применяют оптимизации:

# Оптимизация константного складывания
x = 10 + 5  # Компилируется сразу как x = 15

# JIT компиляция (в Python 3.11+)
# Горячие функции компилируются в машинный код

Python 3.11+ использует adaptive specialization для оптимизации типов:

def add(a, b):
    return a + b

# При первом вызове с int - специализируется
add(5, 3)
add(2, 8)  # быстрее, специализированный код

# Вызов со строкой - перестраивается
add("hello", "world")

Полный цикл на примере

# Шаг 1-2: Лексический анализ
# x = 5 + 3 → [NAME, EQUAL, NUMBER, PLUS, NUMBER]

# Шаг 3: Синтаксический анализ
# Создается AST с BinOp(left=5, op=Add, right=3)

# Шаг 4: Компиляция
# Генерируется байт-код:
# LOAD_CONST 5
# LOAD_CONST 3
# BINARY_ADD
# STORE_FAST x

# Шаг 5-6: Выполнение
# PVM выполняет инструкции в цикле

Важные отличия в разных реализациях

• CPython — стандартная реализация, виртуальная машина на C
• PyPy — с JIT компиляцией, намного быстрее на длительных операциях
• Cython — компилируется в C для максимальной скорости

Понимание этих этапов помогает оптимизировать код и разбираться в ошибках выполнения.