dis: дизассемблер байткода Python

В первом уроке мы узнали, что компилятор превращает исходник в байткод, а виртуальная машина исполняет его. Байткод при этом остался абстракцией: мы видели тип кодового объекта и его атрибуты, но не сами команды. Дизассемблер dis из стандартной библиотеки печатает их построчно — это рентген Python-программы: видно, во что компилятор превратил каждую строку и на чём именно виртуальная машина тратит время.

Перед разбором вывода соберём подопытную функцию и убедимся, что она работает как ожидается:

def discount(price):
    if price >= 100:
        return price * 0.8
    return price

print(discount(200))
print(discount(50))

160.0
50

Первый дизассемблёр: колонки вывода

Функция dis.dis принимает кодовый объект — или функцию напрямую, байткод она берёт из __code__. Вот её байткод:

import dis

def discount(price):
    if price >= 100:
        return price * 0.8
    return price

dis.dis(discount)

  1           RESUME                   0

  2           LOAD_FAST                0 (price)
              LOAD_CONST               1 (100)
              COMPARE_OP             188 (bool(>=))
              POP_JUMP_IF_FALSE        5 (to L1)

  3           LOAD_FAST                0 (price)
              LOAD_CONST               2 (0.8)
              BINARY_OP                5 (*)
              RETURN_VALUE

  4   L1:     LOAD_FAST                0 (price)
              RETURN_VALUE

Разбираем колонки слева направо. Первая — номер строки исходника: инструкции второй строки программы все помечены двойкой. Вторая — смещение инструкции внутри байткода и метки переходов вроде L1. Третья — имя команды, четвёртая — её аргумент; в скобках dis печатает человекочитаемое значение аргумента: не абстрактный индекс 0, а конкретное (price).

Стековая машина: как VM исполняет команды

Инструкции работают не с переменными напрямую, а со стеком — последним хранилищем «положил сверху, взял сверху». LOAD_FAST кладёт значение локальной переменной на стек, COMPARE_OP снимает два верхних значения и сравнивает их, POP_JUMP_IF_FALSE снимает результат и при нуле прыгает на метку. Проследим за сложением из простой функции:

import dis

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

dis.dis(add)

  1           RESUME                   0

  2           LOAD_FAST_LOAD_FAST      1 (a, b)
              BINARY_OP                0 (+)
              RETURN_VALUE

Три команды на всю функцию: загрузить значения, выполнить сложение, вернуть результат. Сложение на стеке выглядит так: LOAD кладёт a и b, BINARY_OP снимает оба и кладёт обратно сумму, RETURN_VALUE снимает верхнее значение и отдаёт его вызывающему. Стековая модель объясняет порядок во всех инструкциях: всё, что нужно операции, сначала оказывается на стеке. Байткод — это план работы виртуальной машины: команды могут меняться от версии к версии, но стековая модель исполнения остаётся.

Что байткод говорит о коде

Чтение dis отвечает на вопросы, которые не видны в исходнике. Что компилятор свернул? Что попадает в константы? Сколько команд стоит за выражение? Всё это лежит в кодовом объекте рядом с байткодом — и читается обычными атрибутами:

def discount(price):
    if price >= 100:
        return price * 0.8
    return price

code = discount.__code__
print('имя:', code.co_name)
print('параметры:', code.co_varnames)
print('константы:', code.co_consts)

имя: discount
параметры: ('price',)
константы: (None, 100, 0.8)

Вывод совпал с дизассемблером: LOAD_CONST 1 (100) и LOAD_CONST 2 (0.8) берут значения из кортежа констант по индексам 1 и 2. None в начале — заготовка возврата по умолчанию. Атрибуты co_varnames и co_consts стабильны между версиями — в отличие от самих инструкций, поэтому инспекцию кода строят на них. Тот же приём на функции с локальной переменной:

def report(total):
    bonus = 10
    return total + bonus

code = report.__code__
print('локальные имена:', code.co_varnames)
print('константы:', code.co_consts)

локальные имена: ('total', 'bonus')
константы: (None, 10)

co_varnames перечислил и параметр, и локальную переменную в порядке появления: сначала total, потом bonus. Константа 10 ушла в co_consts — её в локальных именах нет, это данные, а не имя. Именно такие кортежи компилятор кладёт в кодовый объект ещё до первого вызова функции.

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

bytecode = add.__code__.co_code
print('тип байткода:', type(bytecode).__name__)
print('байт в байткоде больше нуля:', len(bytecode) > 0)

тип байткода: bytes
байт в байткоде больше нуля: True

Сам байткод — объект типа bytes: кодовые слова и аргументы, упакованные в байты. Именно эти байты лежат в marshal-блоке pyc-файла из второго урока и именно их печатает dis в виде человекочитаемых команд. Длина и содержимое байтов между версиями различаются — поэтому в опыте проверка только «байты есть», а не конкретное число.

dis и программный доступ к инструкциям

Помимо печати, dis умеет отдавать инструкции как объекты: dis.get_instructions возвращает их списком, у каждого есть атрибуты opname, argval, offset. На этом строятся анализаторы кода: поиск запрещённых операций, подсчёт стоимости функции, проверки стиля.

Компилятор и его оптимизации уже встретились нам в первом уроке — там же, где мы впервые скомпилировали строку сами. Связка между байткодом и файлами на диске — pyc из второго урока: в marshal-блоке лежат ровно эти байты co_code. А общий знаменатель всех версий байткода — magic-число в заголовке, пятый урок.

import types

source = 'result = 15 + 27\nprint(result)'
code = compile(source, '<проверка>', 'exec')
print('это кодовый объект:', isinstance(code, types.CodeType))
exec(code)

это кодовый объект: True
42

Компилируется и одиночное выражение — режим eval даёт кодовый объект, который eval вычисляет в значение. Передайте такой объект в dis.dis на своей машине: инструкции формулы будут те же LOAD и операции, что и у программ из этого урока:

expr = compile('max(3, 9) * 100', '<формула>', 'eval')
print('результат формулы:', eval(expr))

результат формулы: 900

Полный цикл — компиляция, инспекция, исполнение — в пяти строках. Прогоните этот блок в песочнице, затем передайте code в dis.dis на своей машине: увидите тот же вывод с LOAD_CONST 42, что и в первом уроке, со смещениями и инструкциями своей версии Python.

• dis.dis печатает байткод: строка исходника, смещение, имя команды, аргумент с человекочитаемым значением;
• виртуальная машина стековая: LOAD кладёт значения, операции снимают их со стека, RETURN отдаёт результат;
• вывод dis меняется между версиями Python — опора на модель, а не на заученный список команд;
• стабильные данные о функции — co_name, co_varnames, co_consts; сам байткод — bytes в co_code;
• dis.get_instructions отдаёт инструкции как объекты для программного анализа.

Следующий урок закрывает главный практический вопрос байткода: почему pyc не работает на другой версии Python и при чём тут magic-число.