Из текста в байткод

Ядро запускает /usr/bin/python3 обычным execve. Динамический загрузчик подтягивает libpython3.11.so (или он вкомпилирован статически), управление уходит в main() из Programs/python.c — файл в двадцать строк, вся его работа состоит в вызове Py_BytesMain.

С точки зрения ОС Python — обычная C-программа. Никакой виртуальной машины уровня JVM с отдельным процессом-хостом здесь нет: интерпретатор это библиотека, слинкованная с крошечным main.

Modules/main.c разбирает аргументы и строит конфигурацию, после чего Python/pylifecycle.c поднимает интерпретатор. Порядок здесь неслучаен и решает проблему курицы и яйца:

• Встроенные модули. sys, builtins, _imp — они скомпилированы в бинарник и не импортируются обычным путём, потому что обычного пути ещё нет.
• Замороженные модули. importlib._bootstrap и importlib._bootstrap_external — сам механизм импорта, написанный на Python. Его нельзя импортировать: он и есть импорт. Поэтому его байткод вшит в бинарник (Python/frozen.c). В 3.11 список замороженных расширили до четырнадцати модулей ради скорости старта.
• Кодировки. encodings нужен раньше, чем что-либо прочитается с диска.
• sys.path. Собирается из места бинарника, переменных окружения и .pth-файлов.
• site.py. Добавляет site-packages, обрабатывает .pth. Самая дорогая часть старта.

Четыре с половиной миллисекунды — цена site.py. Восемьдесят восемь — цена одного import numpy. Для утилиты командной строки, которую вызывают в цикле из shell-скрипта, это и есть её производительность.

Файл читается как байты и декодируется. По умолчанию UTF-8; PEP 263 разрешает объявить другую кодировку строкой # -*- coding: cp1251 -*- в первых двух строках, и токенайзер вычитывает её раньше, чем начинает разбор. BOM тоже распознаётся.

Это единственная фаза, где Python видит байты. Дальше везде — str, то есть последовательность кодовых точек из урока 02.

Parser/tokenizer.c превращает текст в поток токенов. Главная особенность видна во фрагменте C: отступы становятся токенами. Токенайзер держит стек уровней отступа и на каждой строке сравнивает текущий с вершиной стека — глубже выдаёт INDENT, мельче выдаёт по DEDENT на каждый снятый уровень.

Отсюда три следствия, которые обычно считают причудами:

• IndentationError — отдельный подкласс SyntaxError, потому что ошибка возникает на другой фазе и с другой диагностикой.
• Смешивать табы и пробелы нельзя не из эстетики: токенайзеру нужно сравнивать уровни, а сравнить таб с пробелом однозначно невозможно.
• Внутри скобок отступ игнорируется — токенайзер считает открытые скобки и внутри них не порождает INDENT вовсе. Поэтому длинный вызов можно переносить как угодно.

С версии 3.9 (PEP 617) в CPython PEG-парсер вместо старого LL(1). Грамматика лежит в Grammar/python.gram и из неё генерируется Parser/parser.c — файл на десятки тысяч строк, который никто не пишет руками.

Практическое отличие PEG от LL(1): парсер может попробовать альтернативу, откатиться и попробовать следующую. Это сняло грамматические ограничения, из-за которых часть синтаксиса раньше была невыразима, и дало резко лучшие сообщения об ошибках — «Perhaps you forgot a comma?» появилось именно потому, что парсер способен разобрать неудачную ветку до конца и понять, чего в ней не хватило.

Парсер выдаёт дерево. Модуль ast отдаёт его же в Python-объектах — это буквально то самое дерево, а не отдельная реализация.

На дереве работает Python/ast_opt.c — оптимизатор, который вычисляет то, что можно вычислить сразу. Отсюда фрагмент B и вот это:

import ast
print(ast.dump(ast.parse("x = 1 + 2"), indent=2))
# в дереве останется BinOp: свёртка происходит позже, уже в компиляторе

code = compile("x = 1 + 2\ny = 'ab' * 3", "<s>", "exec")
print(code.co_consts)
# → (3, 'ababab', None)

В константах уже готовые значения: ни сложения, ни умножения при исполнении не будет. Оптимизатор осторожен — он не свернёт 'a' * 10**9, чтобы не раздуть .pyc до гигабайта.

Python/symtable.c делает отдельный полный проход по дереву до того, как сгенерирована хоть одна инструкция. Его единственная задача — для каждого имени в каждой области видимости решить, что это: локальная, глобальная, ячейка (переменная, которую захватывает вложенная функция) или свободная (захваченная у внешней).

import symtable
code = '''
g = 1
def outer():
    a = 1
    def inner():
        nonlocal a
        b = g
        return a + b
    return inner
'''
st = symtable.symtable(code, "<s>", "exec")
outer = st.get_children()[0]
inner = outer.get_children()[0]
for s in inner.get_symbols():
    print(s.get_name(), "local" if s.is_local() else "",
          "global" if s.is_global() else "", "free" if s.is_free() else "")
# → a   free
# → b  local
# → g   global

Правило простое и статическое: имя, которому в функции где-либо присваивается значение, локально во всей этой функции. Не с момента присваивания — везде, включая строки выше него. Никакого анализа потока управления здесь нет.

Из этого одного правила выводится фрагмент D: в handle есть строка DEBUG = True, значит DEBUG локальна на протяжении всей функции, значит if DEBUG читает локальную. При verbose=True она к этому моменту присвоена, при verbose=False — нет. Отсюда же global и nonlocal: это не «модификаторы времени исполнения», а указания этой фазе, единственный способ переопределить её решение.

И отсюда же — почему области видимости в Python лексические и статические, хотя типы динамические. Тип неизвестен до исполнения; принадлежность имени к области известна всегда.

Python/compile.c обходит дерево, зная решения таблицы символов, и строит граф потока управления из базовых блоков. На графе делаются оптимизации уровня «убрать недостижимый блок», «схлопнуть цепочку переходов», после чего блоки раскладываются в линейный поток байтов.

Одновременно вычисляется три служебных структуры:

• co_stacksize — максимальная глубина стека значений. Считается статически, чтобы при вызове функции выделить ровно столько места и больше никогда не проверять переполнение.
• co_linetable — сжатое соответствие «смещение в байткоде → строка исходника». То, из чего строится трассировка.
• co_exceptiontable — появилась в 3.11. Таблица «для диапазона инструкций от и до — обработчик находится там». Раньше вход в try исполнял инструкцию SETUP_FINALLY; теперь не исполняет ничего. Разбор — в уроке 23.

Результат компиляции — объект code, обычный неизменяемый объект Python. Его можно получить, разобрать, передать, сохранить.

def demo(a, b=2, *args, kw=3, **kwargs):
    total = a + b
    for x in args:
        total += x
    return total

co = demo.__code__
print(co.co_argcount, co.co_kwonlyargcount, co.co_nlocals, co.co_stacksize)
# → 2 1 7 3
print(co.co_varnames)
# → ('a', 'b', 'kw', 'args', 'kwargs', 'total', 'x')
print(len(co.co_code), "байт байткода")
# → 36 байт байткода

Обрати внимание на порядок в co_varnames: сначала позиционные аргументы, потом keyword-only, потом *args и **kwargs, и только потом настоящие локальные. Порядок фиксирован компилятором, и по нему инструкция LOAD_FAST 0 знает, что ноль — это a. Имена в исполнении не участвуют: доступ к локальной переменной это индекс в массиве, а не поиск в словаре.

Это прямое следствие фазы 6. Локальные быстрые именно потому, что таблица символов решила всё заранее.

Компилировать один и тот же модуль при каждом запуске незачем, поэтому code object сериализуется через Python/marshal.c и кладётся в __pycache__. Формат простой до неприличия: шестнадцать байт заголовка и дальше marshal.

import struct, marshal, importlib.util, os
import json                                  # что угодно из стандартной библиотеки

raw = open(json.__cached__, "rb").read()
magic, flags, mtime, size = struct.unpack("<4sIII", raw[:16])
print(magic.hex(), flags, mtime, size)
print(importlib.util.MAGIC_NUMBER.hex())     # тот же magic
obj = marshal.loads(raw[16:])
print(type(obj).__name__)
# → code

Валидация по умолчанию — сравнение mtime и размера, а не содержимого. Отсюда практическое: если развернуть код так, что время модификации файла окажется старше, чем записано в кеше, будет исполняться старый байткод. Именно поэтому в сборках, где важна воспроизводимость, включают hash-based .pyc (py_compile --invalidation-mode checked-hash).

Замер на модуле в 1199 строк: первый импорт с компиляцией — 23 мс, повторный с готовым кешем — 14 мс. Сама компиляция стоит 9 мс, и ровно столько платит каждый процесс, у которого __pycache__ недоступен на запись — например контейнер с read-only файловой системой.