Что такое байт код?

Байт-код (Bytecode)

Определение

Байт-код — это промежуточный код низкого уровня, который генерируется компилятором из исходного кода программы. Он является промежуточным представлением между исходным кодом и машинным кодом, понятным процессору. Байт-код выполняется виртуальной машиной (VM), а не напрямую процессором.

В Python байт-код — это инструкции, которые выполняет Python Virtual Machine (PVM), генерируемые из .py файлов в .pyc файлы.

Процесс компиляции в Python

Исходный код (.py)
        ↓
    Лексический анализ
        ↓
    Синтаксический анализ (AST)
        ↓
    Компилятор
        ↓
    Байт-код (.pyc)
        ↓
Python Virtual Machine
        ↓
    Выполнение

Просмотр байт-кода

import dis

def example_function(x):
    result = x + 10
    return result

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

Вывод:

  3           0 LOAD_FAST                0 (x)
              2 LOAD_CONST               1 (10)
              4 BINARY_ADD
              6 STORE_FAST               1 (result)

  4           8 LOAD_FAST                1 (result)
             10 RETURN_VALUE

Инструкции байт-кода

# LOAD_FAST — загрузить локальную переменную
# LOAD_CONST — загрузить константу
# STORE_FAST — сохранить в локальную переменную
# BINARY_ADD — сложение двух значений
# RETURN_VALUE — возврат значения
# CALL_FUNCTION — вызов функции
# POP_TOP — удалить верхний элемент со стека

def complex_example(a, b):
    if a > b:
        return a + b
    else:
        return a - b

dis.dis(complex_example)

Вывод:

  3           0 LOAD_FAST                0 (a)
              2 LOAD_FAST                1 (b)
              4 COMPARE_OP               4 (>)
              6 POP_JUMP_IF_FALSE       12

  4           8 LOAD_FAST                0 (a)
             10 LOAD_FAST                1 (b)
             12 BINARY_ADD
             14 RETURN_VALUE

  6     >>   16 LOAD_FAST                0 (a)
             18 LOAD_FAST                1 (b)
             20 BINARY_SUBTRACT
             22 RETURN_VALUE

Где хранится байт-код

project/
├── main.py
├── module.py
└── __pycache__/  (автоматически создаётся)
    ├── main.cpython-39.pyc
    ├── main.cpython-310.pyc
    └── module.cpython-39.pyc

При первом импорте Python автоматически создаёт .pyc файлы в папке __pycache__/.

Компиляция байт-кода в Python

import py_compile

# Компилирование файла в байт-код
py_compile.compile("module.py", cfile="module.cpython-39.pyc")

# Компилирование директории
import compileall
compileall.compile_dir(".", force=True)

Примеры байт-кода

Пример 1: Простое присваивание

x = 5
y = 10
z = x + y

# Байт-код:
LOAD_CONST 5
STORE_FAST x
LOAD_CONST 10
STORE_FAST y
LOAD_FAST x
LOAD_FAST y
BINARY_ADD
STORE_FAST z

Пример 2: Условие

if condition:
    x = 1
else:
    x = 2

# Байт-код:
LOAD_GLOBAL condition
POP_JUMP_IF_FALSE 10  # Прыгнуть на 10, если False
LOAD_CONST 1
STORE_FAST x
JUMP_FORWARD 4
LOAD_CONST 2
STORE_FAST x

Пример 3: Цикл

for i in range(3):
    print(i)

# Байт-код содержит инструкции:
GET_ITER  # Получить итератор
FOR_ITER  # Следующая итерация
LOAD_GLOBAL print
LOAD_FAST i
CALL_FUNCTION 1
POP_TOP

Разница между Python и Java байт-кодом

Декомпиляция байт-кода

# Инструмент uncompyle6 может восстановить исходный код из .pyc
# pip install uncompyle6

# uncompyle6 module.cpython-39.pyc > module.py

Оптимизация через байт-код

import timeit

# Функция для тестирования
def slow_function():
    result = 0
    for i in range(1000):
        result += i
    return result

# Первый вызов (компиляция в байт-код)
time1 = timeit.timeit(slow_function, number=10000)

# Второй вызов (используется уже скомпилированный байт-код)
time2 = timeit.timeit(slow_function, number=10000)

print(f"Первый раз: {time1}")
print(f"Второй раз: {time2}")
print(f"Ускорение: {time1 / time2}x")

Кэширование байт-кода

Python кэширует байт-код для ускорения загрузки:

# При импорте модуля
import mymodule  # Python проверяет mymodule.cpython-39.pyc

# Если .pyc существует и новее исходника — используется
# Если нет — создаётся новый .pyc

# Отключение кэширования (при разработке)
# python -B main.py
# или
import sys
sys.dont_write_bytecode = True

Анализ производительности через байт-код

import dis
import sys

print(f"Python версия: {sys.version}")

def inefficient():
    # Создание списка через конкатенацию
    result = []
    for i in range(10):
        result = result + [i]
    return result

def efficient():
    # Использование append
    result = []
    for i in range(10):
        result.append(i)
    return result

print("\nНеэффективный код:")
dis.dis(inefficient)

print("\nЭффективный код:")
dis.dis(efficient)

# Сравнение времени выполнения
import timeit
print(f"\nВремя inefficient: {timeit.timeit(inefficient, number=1000)}")
print(f"Время efficient: {timeit.timeit(efficient, number=1000)}")

PyCode объект

def my_func():
    return 42

# Получение объекта кода
code = my_func.__code__

print(f"Имя функции: {code.co_name}")
print(f"Количество аргументов: {code.co_argcount}")
print(f"Количество локальных переменных: {code.co_nlocals}")
print(f"Байт-код: {code.co_code}")
print(f"Константы: {code.co_consts}")
print(f"Имена переменных: {code.co_varnames}")

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

• Кэширование: скомпилированный код загружается быстрее
• Независимость: один байт-код работает на разных платформах
• Оптимизация: компилятор может оптимизировать байт-код
• Безопасность: сложнее получить исходный код из .pyc

Недостатки

• Сложность отладки: байт-код сложнее читать, чем исходный код
• Декомпиляция: существуют инструменты для восстановления кода
• Размер: .pyc файлы занимают дополнительное место

Итоговая схема

Байт-код — это промежуточное представление программы, которое генерируется компилятором и выполняется виртуальной машиной. В Python это .pyc файлы, которые автоматически кэшируются для ускорения загрузки модулей, делая Python более производительным при повторном использовании кода.