dis — Диссектор байткода Python

Исходный код: Lib/dis.py

Модуль dis поддерживает анализ байткода CPython байткода путём его дизассемблирования. Байткод CPython, который принимает этот модуль в качестве входных данных, определён в файле Include/opcode.h и используется компилятором и интерпретатором.

Примечание реализации CPython: Байткод — это деталь реализации интерпретатора CPython. Нет гарантий, что байткод не будет добавлен, удалён или изменён между версиями Python. Использование этого модуля не гарантирует работоспособность на разных виртуальных машинах Python или разных релизах Python.

Пример: Дана функция myfunc():

def myfunc(alist):
    return len(alist)

следующая команда может быть использована для отображения дизассемблирования myfunc():

>>> dis.dis(myfunc)
  2           0 LOAD_GLOBAL              0 (len)
              3 LOAD_FAST                0 (alist)
              6 CALL_FUNCTION            1
              9 RETURN_VALUE

(«2» — это номер строки).

1. Анализ байткода

Введено в версии 3.4.

API анализа байткода позволяет упаковывать фрагменты кода Python в объект Bytecode, который обеспечивает лёгкий доступ к деталям скомпилированного кода.

class dis.Bytecode(x, *, first_line=None, current_offset=None)

Проанализируйте байткод, соответствующий функции, генератору, методу, строке исходного кода или объекту кода (возвращаемому функцией compile()).

Это обертка для удобства работы со многими функциями, перечисленными ниже, в первую очередь get_instructions(), так как перебор экземпляра Bytecode возвращает операции байткода как экземпляры Instruction.

Если first_line не None, то это номер строки, который должен быть отчётён для первой строки исходного кода в дизассемблированном коде. В противном случае информация о строках исходного кода (если она есть) берётся непосредственно из объекта дизассемблированного кода.

Если current_offset не None, это смещение инструкции в дизассемблированном коде. Установка этого значения означает, что dis() отобразит маркер «текущая инструкция» для указанного кода операции.

classmethod from_traceback(tb): Создайте экземпляр Bytecode из заданного отслеживания, установив current_offset в инструкцию, вызвавшую исключение.

codeobj: Объект скомпилированного кода.

first_line: Первая строка исходного кода объекта кода (если она есть)

dis(): Возвращает отформатированный вид операций байткода (такой же, как при выводе dis.dis(), но возвращаемый как многострочная строка).

info(): Возвращает отформатированную многострочную строку с подробной информацией об объекте кода, как в code_info().

Пример:

>>> bytecode = dis.Bytecode(myfunc)
>>> for instr in bytecode:
...     print(instr.opname)
...
LOAD_GLOBAL
LOAD_FAST
CALL_FUNCTION
RETURN_VALUE

2. Функции анализа

Модуль dis также определяет следующие функции анализа, которые преобразуют входные данные напрямую в желаемый вывод. Они могут быть полезны, если выполняется только одна операция, поэтому промежуточный объект анализа не нужен:

dis.code_info(x)

Возвращает отформатированную многострочную строку с подробной информацией об объекте кода для предоставленной функции, генератора, метода, строки исходного кода или объекта кода.

Обратите внимание, что точное содержимое строк информации о коде сильно зависит от реализации, и они могут произвольно меняться между виртуальными машинами Python или версиями Python.

Введено в версии 3.2.

dis.show_code(x, *, file=None)

Выводит подробную информацию об объекте кода для предоставленной функции, метода, строки исходного кода или объекта кода в file (или sys.stdout если file не указан).

Это удобный сокращённый способ для print(code_info(x), file=file), предназначенный для интерактивного изучения в командной строке интерпретатора.

Введено в версии 3.2.

Изменено в версии 3.4: Добавлен параметр file.

dis.dis(x=None, *, file=None)

Разобрать объект x. x может обозначать модуль, класс, метод, функцию, генератор, объект кода, строку исходного кода или последовательность байтов исходного байткода. Для модуля он дизассемблирует все функции. Для класса он дизассемблирует все методы (включая методы класса и статические методы). Для объекта кода или последовательности байтового кода он печатает по одной строке для каждой инструкции байткода. Строки сначала компилируются в объекты кода с помощью встроенной функции compile() перед дизассемблированием. Если объект не указан, эта функция дизассемблирует последний стек отслеживания.

Дизассемблирование записывается как текст в предоставленный аргумент file, если он указан, и в sys.stdout в противном случае.

Изменено в версии 3.4: Добавлен параметр file.

dis.distb(tb=None, *, file=None)

Дизассемблирует функцию из верхнего уровня стека отслеживания, используя последний стек отслеживания, если он не был передан. Инструкция, вызвавшая исключение, указывается.

Изменено в версии 3.4: Добавлен параметр file.

dis.disassemble(code, lasti=-1, *, file=None)

dis.disco(code, lasti=-1, *, file=None)

Дизассемблирует объект кода, указывая последнюю инструкцию, если был передан lasti. Вывод делится на следующие столбцы:

номер строки, для первой инструкции каждой строки
текущая инструкция, указанная как -->,
меченые инструкции, указанные как >>,
адрес инструкции,
имя кода операции,
параметры операции и
интерпретация параметров в скобках.

Интерпретация параметров распознаёт имена локальных и глобальных переменных, значения констант, целевые точки ветвления и операторы сравнения.

Изменено в версии 3.4: Добавлен параметр file.

dis.get_instructions(x, *, first_line=None)

Возвращает итератор по инструкциям в предоставленной функции, методе, строке исходного кода или объекте кода.

Итератор генерирует серию именованных кортежей Instruction, предоставляющих подробности каждой операции в предоставленном коде.

Введено в версии 3.4.

dis.findlinestarts(code): Эта функция-генератор использует атрибуты co_firstlineno и co_lnotab объекта кода code для поиска смещений, которые являются началами строк в исходном коде. Они генерируются как пары (offset, lineno).

dis.findlabels(code): Обнаруживает все смещения в объекте кода code, которые являются целевыми адресами переходов, и возвращает список этих смещений.

dis.stack_effect(opcode[, oparg]): Вычисляет эффект стека для opcode с аргументом oparg.

Введено в версии 3.4.

3. Инструкции байткода Python

Функция get_instructions() и класс Bytecode предоставляют подробности инструкций байткода как экземпляры Instruction:

class dis.Instruction

Подробности для байткодовой операции

opcode: Числовой код операции, соответствующий значениям opcode, указанным ниже, и значениям байткода в Коллекциях opcode.

opname: Наименование операции в удобочитаемой форме

arg: Числовой аргумент операции (если есть), в противном случае None

argval: Раскрытое значение аргумента (если известно), в противном случае — такое же, как arg

argrepr: Удобочитаемое описание аргумента операции

offset: Начальный индекс операции в последовательности байткода

starts_line: Строка, начинающаяся с этого opcode (если есть), в противном случае None

is_jump_target: True если другой код переходит сюда, в противном случае False

Введено в версии 3.4.

В настоящее время компилятор Python генерирует следующие инструкции байткода.

Общие инструкции

NOP: Инструкция без действия. Используется в качестве заполнителя оптимизатором байткода.

POP_TOP: Удаляет элемент из вершины стека (TOS).

ROT_TWO: Меняет местами два верхних элемента стека.

ROT_THREE: Поднимает второй и третий элементы стека на одну позицию вверх, перемещает верхний элемент вниз на третью позицию.

DUP_TOP: Дублирует ссылку на вершине стека.

DUP_TOP_TWO: Дублирует две ссылки на вершине стека, сохраняя их в том же порядке.

Унарные операции

Унарные операции берут верхний элемент стека, применяют операцию и возвращают результат обратно на стек.

UNARY_POSITIVE: Реализует TOS = +TOS.

UNARY_NEGATIVE: Реализует TOS = -TOS.

UNARY_NOT: Реализует TOS = not TOS.

UNARY_INVERT: Реализует TOS = ~TOS.

GET_ITER: Реализует TOS = iter(TOS).

GET_YIELD_FROM_ITER: Если TOS является объектом генератора итератора или корутины, он остается без изменений. В противном случае реализует TOS = iter(TOS).

Введено в версии 3.5.

Бинарные операции

Бинарные операции удаляют верхний элемент стека (TOS) и второй сверху элемент стека (TOS1). Они выполняют операцию и помещают результат обратно на стек.

BINARY_POWER: Реализует TOS = TOS1 ** TOS.

BINARY_MULTIPLY: Реализует TOS = TOS1 * TOS.

BINARY_MATRIX_MULTIPLY: Реализует TOS = TOS1 @ TOS.

Введено в версии 3.5.

BINARY_FLOOR_DIVIDE: Реализует TOS = TOS1 // TOS.

BINARY_TRUE_DIVIDE: Реализует TOS = TOS1 / TOS.

BINARY_MODULO: Реализует TOS = TOS1 % TOS.

BINARY_ADD: Реализует TOS = TOS1 + TOS.

BINARY_SUBTRACT: Реализует TOS = TOS1 - TOS.

BINARY_SUBSCR: Реализует TOS = TOS1[TOS].

BINARY_LSHIFT: Реализует TOS = TOS1 << TOS.

BINARY_RSHIFT: Реализует TOS = TOS1 >> TOS.

BINARY_AND: Реализует TOS = TOS1 & TOS.

BINARY_XOR: Реализует TOS = TOS1 ^ TOS.

BINARY_OR: Реализует TOS = TOS1 | TOS.

Операции на месте

Операции на месте аналогичны бинарным операциям, поскольку они удаляют TOS и TOS1 и возвращают результат на стек, но операция выполняется на месте, когда TOS1 её поддерживает, и результирующий TOS может (но не обязательно) быть исходным TOS1.

INPLACE_POWER: Реализует операцию на месте TOS = TOS1 ** TOS.

INPLACE_MULTIPLY: Реализует операцию на месте TOS = TOS1 * TOS.

INPLACE_MATRIX_MULTIPLY: Реализует операцию на месте TOS = TOS1 @ TOS.

Введено в версии 3.5.

INPLACE_FLOOR_DIVIDE: Реализует операцию на месте TOS = TOS1 // TOS.

INPLACE_TRUE_DIVIDE: Реализует операцию на месте TOS = TOS1 / TOS.

INPLACE_MODULO: Реализует операцию на месте TOS = TOS1 % TOS.

INPLACE_ADD: Реализует операцию на месте TOS = TOS1 + TOS.

INPLACE_SUBTRACT: Реализует операцию на месте TOS = TOS1 - TOS.

INPLACE_LSHIFT: Реализует операцию на месте TOS = TOS1 << TOS.

INPLACE_RSHIFT: Реализует операцию на месте TOS = TOS1 >> TOS.

INPLACE_AND: Реализует операцию на месте TOS = TOS1 & TOS.

INPLACE_XOR: Реализует операцию на месте TOS = TOS1 ^ TOS.

INPLACE_OR: Реализует операцию на месте TOS = TOS1 | TOS.

STORE_SUBSCR: Реализует TOS1[TOS] = TOS2.

DELETE_SUBSCR: Реализует del TOS1[TOS].

Корутинные opcode

GET_AWAITABLE: Реализует TOS = get_awaitable(TOS), где get_awaitable(o) возвращает o если o является объектом корутины или объектом генератора с флагом CO_ITERABLE_COROUTINE, или раскрывает o.__await__.

GET_AITER: Реализует TOS = get_awaitable(TOS.__aiter__()). Подробности о GET_AWAITABLE и get_awaitable см. в GET_AWAITABLE.

GET_ANEXT: Реализует PUSH(get_awaitable(TOS.__anext__())). Подробности о GET_AWAITABLE и get_awaitable см. в GET_AWAITABLE.

BEFORE_ASYNC_WITH: Раскрывает __aenter__ и __aexit__ из объекта на вершине стека. Помещает __aexit__ и результат __aenter__() на стек.

SETUP_ASYNC_WITH: Создаёт новый объект фрейма.

Разные opcode

PRINT_EXPR: Реализует оператор выражения для интерактивного режима. Элемент TOS удаляется из стека и выводится на печать. В неинтерактивном режиме оператор выражения завершается инструкцией POP_TOP.

BREAK_LOOP: Завершает цикл из-за оператора break.

CONTINUE_LOOP(target): Продолжает цикл из-за оператора continue. target — адрес для перехода (который должен быть инструкцией FOR_ITER).

SET_ADD(i): Вызывает set.add(TOS1[-i], TOS). Используется для реализации множественных пониманий.

LIST_APPEND(i): Вызывает list.append(TOS[-i], TOS). Используется для реализации списковых включений.

MAP_ADD(i): Вызывает dict.setitem(TOS1[-i], TOS, TOS1). Используется для реализации словариковых включений.

Для всех инструкций SET_ADD, LIST_APPEND и MAP_ADD, в то время как добавленное значение или пара ключ/значение извлекается, объект контейнера остается в стеке, чтобы он был доступен для дальнейших итераций цикла.

RETURN_VALUE: Возвращает TOS вызывающей функции.

YIELD_VALUE: Извлекает TOS и передает его из генератора.

YIELD_FROM: Извлекает TOS и делегирует ему как подповторителю из генератора.

Новое в версии 3.3.

IMPORT_STAR: Загружает все символы, не начинающиеся с '_' непосредственно из модуля TOS в локальное пространство имен. Модуль извлекается после загрузки всех имен. Эта инструкция реализует from module import *.

POP_BLOCK: Удаляет один блок из стека блоков. В каждом кадре есть стек блоков, обозначающий вложенные циклы, операторы try и т.п.

POP_EXCEPT: Удаляет один блок из стека блоков. Попавший блок должен быть блоком обработки исключений, как неявно созданный при входе в обработчик исключений. В дополнение к извлечению лишних значений из стека фрейма, последние три извлеченные значения используются для восстановления состояния исключения.

END_FINALLY: Завершает операнд finally. Интерпретатор вспоминает, нужно ли повторно поднимать исключение или возвращать функцию, и продолжает с внешним блоком.

LOAD_BUILD_CLASS: Помещает builtins.__build_class__() в стек. Позже он вызывается CALL_FUNCTION для создания класса.

SETUP_WITH(delta): Эта инструкция выполняет несколько операций перед началом блока with. Сначала она загружает __exit__() из менеджера контекста и помещает его в стек для последующего использования WITH_CLEANUP. Затем вызывается __enter__(), и в стек помещается блок finally, указывающий на delta. Наконец, результат вызова метода enter помещается в стек. Следующая инструкция либо проигнорирует его (POP_TOP), либо сохранит его в (переменной/переменных) (STORE_FAST, STORE_NAME или UNPACK_SEQUENCE).

WITH_CLEANUP_START

Очищает стек при выходе из блока оператора with. TOS — это связанный метод __exit__() менеджера контекста. Ниже TOS находятся 1–3 значения, указывающие, как/почему был вызван блок finally:

SECOND = None
(SECOND, THIRD) = (WHY_{RETURN,CONTINUE}), retval
SECOND = WHY_*; нет retval ниже него
(SECOND, THIRD, FOURTH) = exc_info()

В последнем случае вызывается TOS(SECOND, THIRD, FOURTH), в противном случае TOS(None, None, None). В стек помещаются SECOND и результат вызова.

WITH_CLEANUP_FINISH

Извлекает тип исключения и результат вызова функции «exit» из стека.

Если стек представляет исключение и вызов функции возвращает значение «true», эта информация «удаляется» и заменяется одним WHY_SILENCED, чтобы предотвратить повторное поднятие исключения END_FINALLY. (Но нелокальные переходы все равно будут возобновлены.)

Все следующие инструкции ожидают аргументов. Аргумент состоит из двух байтов, где старший байт последним.

STORE_NAME(namei): Реализует name = TOS. namei — индекс name в атрибуте co_names объекта кода. Компилятор пытается использовать STORE_FAST или STORE_GLOBAL, если это возможно.

DELETE_NAME(namei): Реализует del name, где namei — индекс в атрибуте co_names объекта кода.

UNPACK_SEQUENCE(count): Распаковывает TOS в count отдельных значений, которые помещаются в стек справа налево.

UNPACK_EX(counts)

Реализует присваивание со звёздочкой в целевом значении: распаковывает итерируемый объект в TOS в отдельные значения, где общее количество значений может быть меньше, чем количество элементов в итерируемом объекте: одно из новых значений будет списком всех оставшихся элементов.

Нижний байт counts — это количество значений перед значением списка, старший байт counts — количество значений после него. Результирующие значения помещаются в стек справа налево.

STORE_ATTR(namei): Реализует TOS.name = TOS1, где namei — индекс имени в co_names.

DELETE_ATTR(namei): Реализует del TOS.name, используя namei как индекс в co_names.

STORE_GLOBAL(namei): Работает как STORE_NAME, но сохраняет имя как глобальное.

DELETE_GLOBAL(namei): Работает как DELETE_NAME, но удаляет глобальное имя.

LOAD_CONST(consti): Помещает co_consts[consti] в стек.

LOAD_NAME(namei): Помещает значение, связанное с co_names[namei] в стек.

BUILD_TUPLE(count): Создаёт кортеж, потребляя из стека count элементов, и помещает получившийся кортеж в стек.

BUILD_LIST(count): Работает как BUILD_TUPLE, но создаёт список.

BUILD_SET(count): Работает как BUILD_TUPLE, но создаёт множество.

BUILD_MAP(count): Помещает новый объект словаря в стек. Извлекает 2 * count элементов, так что словарь содержит count записей: {..., TOS3: TOS2, TOS1: TOS}.

Изменено в версии 3.5: Словарь создаётся из элементов стека, а не пустой словарь создаётся предварительно размером, чтобы вместить count элементов.

BUILD_TUPLE_UNPACK(count): Извлекает count итерируемых объектов из стека, объединяет их в один кортеж и помещает результат в стек. Реализует распаковку итерируемых объектов в кортежи (*x, *y, *z).

Новое в версии 3.5.

BUILD_LIST_UNPACK(count): Аналогично BUILD_TUPLE_UNPACK, но помещает в стек список вместо кортежа. Реализует распаковку итерируемых объектов в списки [*x, *y, *z].

Новое в версии 3.5.

BUILD_SET_UNPACK(count): Аналогично BUILD_TUPLE_UNPACK, но помещает в стек множество вместо кортежа. Реализует распаковку итерируемых объектов в множества {*x, *y, *z}.

Новое в версии 3.5.

BUILD_MAP_UNPACK(count): Извлекает count отображений из стека, объединяет их в один словарь и помещает результат в стек. Реализует распаковку словарей в словари {**x, **y, **z}.

Новое в версии 3.5.

BUILD_MAP_UNPACK_WITH_CALL(oparg): Это аналогично BUILD_MAP_UNPACK, но используется для f(**x, **y, **z) синтаксиса вызова. Самый младший байт oparg — это количество отображений, относительное положение соответствующей вызываемой функции f закодировано во втором байте oparg.

Введено в версии 3.5.

LOAD_ATTR(namei): Заменяет TOS на getattr(TOS, co_names[namei]).

COMPARE_OP(opname): Выполняет булеву операцию. Название операции можно найти в cmp_op[opname].

IMPORT_NAME(namei): Импортирует модуль co_names[namei]. TOS и TOS1 извлекаются и предоставляют аргументы fromlist и level функции __import__(). Объект модуля помещается на стек. Текущее пространство имён не затрагивается: для правильного оператора импорта последующая инструкция STORE_FAST изменяет пространство имён.

IMPORT_FROM(namei): Загружает атрибут co_names[namei] из модуля, найденного в TOS. Результирующий объект помещается на стек, чтобы впоследствии быть сохранённым инструкцией STORE_FAST.

JUMP_FORWARD(delta): Увеличивает счётчик байткода на delta.

POP_JUMP_IF_TRUE(target): Если TOS истинно, устанавливает счётчик байткода на target. TOS извлекается.

POP_JUMP_IF_FALSE(target): Если TOS ложно, устанавливает счётчик байткода на target. TOS извлекается.

JUMP_IF_TRUE_OR_POP(target): Если TOS истинно, устанавливает счётчик байткода на target и оставляет TOS на стеке. В противном случае (TOS ложно) TOS извлекается.

JUMP_IF_FALSE_OR_POP(target): Если TOS ложно, устанавливает счётчик байткода на target и оставляет TOS на стеке. В противном случае (TOS истинно) TOS извлекается.

JUMP_ABSOLUTE(target): Устанавливает счётчик байткода на target.

FOR_ITER(delta): TOS — это итератор. Вызывается его метод __next__(). Если это возвращает новое значение, помещает его на стек (оставляя итератор ниже него). Если итератор указывает, что он исчерпан, TOS извлекается, и счётчик байткода увеличивается на delta.

LOAD_GLOBAL(namei): Загружает глобальную переменную, имя которой co_names[namei] на стек.

SETUP_LOOP(delta): Помещает блок цикла на стек блоков. Блок охватывает текущую инструкцию с размером в delta байт.

SETUP_EXCEPT(delta): Помещает блок try из блока try-except на стек блоков. delta указывает на первый блок except.

SETUP_FINALLY(delta): Помещает блок try из блока try-except на стек блоков. delta указывает на блок finally.

LOAD_FAST(var_num): Помещает ссылку на локальную переменную co_varnames[var_num] на стек.

STORE_FAST(var_num): Сохраняет TOS в локальной переменной co_varnames[var_num].

DELETE_FAST(var_num): Удаляет локальную переменную co_varnames[var_num].

LOAD_CLOSURE(i): Помещает ссылку на ячейку, содержащуюся в слоте i хранения ячеек и свободных переменных. Имя переменной — co_cellvars[i] , если i меньше длины co_cellvars. В противном случае это co_freevars[i - len(co_cellvars)].

LOAD_DEREF(i): Загружает ячейку, содержащуюся в слоте i хранения ячеек и свободных переменных. Помещает ссылку на содержащийся в ней объект на стек.

LOAD_CLASSDEREF(i): Аналогично LOAD_DEREF, но сначала проверяет словарь локальных переменных перед обращением к ячейке. Это используется для загрузки свободных переменных в телах классов.

STORE_DEREF(i): Сохраняет TOS в ячейку, содержащуюся в слоте i хранения ячеек и свободных переменных.

DELETE_DEREF(i): Очищает ячейку, содержащуюся в слоте i хранения ячеек и свободных переменных. Используется оператором del.

RAISE_VARARGS(argc): Вызывает исключение. argc указывает на количество аргументов оператора raise, от 0 до 3. Обработчик найдёт трассировку стека как TOS2, параметр как TOS1, а исключение как TOS.

CALL_FUNCTION(argc): Вызывает вызываемый объект. Низкий байт argc указывает на количество позиционных аргументов, высокий байт — на количество ключевых аргументов. Стек содержит ключевые аргументы сверху (если есть), затем позиционные аргументы ниже (если есть), затем вызываемый объект ниже. Каждый ключевой аргумент представлен двумя значениями в стеке: именем аргумента и его значением, причём значение аргумента выше имени в стеке. Позиционные аргументы помещаются в порядке их передачи в вызываемый объект, причём самый правый позиционный аргумент находится сверху. CALL_FUNCTION извлекает все аргументы и вызываемый объект со стека, вызывает вызываемый объект с этими аргументами и помещает возвращённое значение вызываемого объекта на стек.

MAKE_FUNCTION(argc)

Помещает новый объект функции на стек. От нижнего к верхнему, потребляемый стек должен состоять из

argc & 0xFF объектов аргументов по умолчанию в позиционном порядке для позиционных параметров
(argc >> 8) & 0xFF пар имени и аргумента по умолчанию, причём имя находится непосредственно ниже объекта в стеке, для параметров только с ключевыми аргументами
(argc >> 16) & 0x7FFF объектов аннотаций параметров
кортежа, перечисляющего имена параметров для аннотаций (только если есть объекты аннотаций)
кода, связанного с функцией (в TOS1)
полного имени функции (в TOS)

MAKE_CLOSURE(argc): Создаёт новый объект функции, устанавливает свой слот __closure__ и помещает его на стек. TOS — это полное имя функции, TOS1 — код, связанный с функцией, а TOS2 — кортеж, содержащий ячейки для свободных переменных замыкания. argc интерпретируется как в MAKE_FUNCTION; аннотации и значения по умолчанию также находятся в том же порядке ниже TOS2.

BUILD_SLICE(argc): Помещает объект среза на стек. argc должен быть 2 или 3. Если это 2, slice(TOS1, TOS) помещается на стек; если это 3, slice(TOS2, TOS1, TOS) помещается на стек. См. встроенную функцию slice() для получения дополнительной информации.

EXTENDED_ARG(ext): Предваряет любую инструкцию, имеющую аргумент, слишком большой для размещения в двух байтах по умолчанию. ext содержит два дополнительных байта, которые вместе с аргументом последующей инструкции образуют четырёхбайтовый аргумент, ext являясь двумя старшими байтами.

CALL_FUNCTION_VAR(argc): Вызывает вызываемый объект, аналогично CALL_FUNCTION. argc представляет количество ключевых и позиционных аргументов, идентично CALL_FUNCTION. Верх стека содержит ключевые аргументы (если есть), хранящиеся аналогично CALL_FUNCTION. Ниже него — итерируемый объект, содержащий дополнительные позиционные аргументы. Ниже него — позиционные аргументы (если есть) и вызываемый объект, аналогично CALL_FUNCTION. Перед вызовом вызываемого объекта итерируемый объект «распаковывается», а его содержимое добавляется к позиционным аргументам, переданным внутри. Итерируемый объект игнорируется при вычислении значения argc.

Изменено в версии 3.5: В версиях с 3.0 по 3.4 итерируемый объект был выше ключевых аргументов; в 3.5 итерируемый объект был перемещён ниже ключевых аргументов.

END_OF_DOCUMENT_MARKER

CALL_FUNCTION_KW(argc): Вызывает вызываемый объект, аналогично CALL_FUNCTION. argc представляет количество ключевых и позиционных аргументов, идентично CALL_FUNCTION. Верх стека содержит объект отображения, содержащий дополнительные ключевые аргументы. Ниже него находятся ключевые аргументы (если есть), позиционные аргументы (если есть) и вызываемый объект, идентично CALL_FUNCTION. Перед вызовом вызываемого объекта, объект отображения вверху стека «распаковывается», и его содержимое добавляется к ключевым аргументам, переданным в. Объект отображения вверху стека игнорируется при вычислении значения argc.

CALL_FUNCTION_VAR_KW(argc): Вызывает вызываемый объект, аналогично CALL_FUNCTION_VAR и CALL_FUNCTION_KW. argc представляет количество ключевых и позиционных аргументов, идентично CALL_FUNCTION. Верх стека содержит объект отображения, как и в CALL_FUNCTION_KW. Под ним находятся ключевые аргументы (если есть), хранящиеся идентично CALL_FUNCTION. Под ними находится итерируемый объект, содержащий дополнительные позиционные аргументы. Под ним находятся позиционные аргументы (если есть) и вызываемый объект, идентично CALL_FUNCTION. Перед вызовом вызываемого объекта, объект отображения и итерируемый объект «распаковываются», и их содержимое передается в качестве ключевых и позиционных аргументов соответственно, идентично CALL_FUNCTION_VAR и CALL_FUNCTION_KW. Объект отображения и итерируемый объект игнорируются при вычислении значения argc.

Изменено в версии 3.5: В версиях 3.0 до 3.4 итерируемый объект находился над ключевыми аргументами; в 3.5 итерируемый объект был перемещен под ключевыми аргументами.

HAVE_ARGUMENT: Это не совсем оператор. Он определяет разделительную линию между операторами, которые не принимают аргументы < HAVE_ARGUMENT и теми, которые принимают >= HAVE_ARGUMENT.

4. Коллекции операторов

Эти коллекции предоставляются для автоматического интроспекции инструкций байт-кода:

dis.opname: Последовательность имён операций, индексируемая с помощью байт-кода.

dis.opmap: Словарь, сопоставляющий имена операций с байт-кодами.

dis.cmp_op: Последовательность всех имён операций сравнения.

dis.hasconst: Последовательность байт-кодов, которые обращаются к константе.

dis.hasfree: Последовательность байт-кодов, которые обращаются к свободной переменной (обратите внимание, что «свободные» в данном контексте относятся к именам в текущей области видимости, к которым обращаются внутренние области видимости, или к именам во внешних областях видимости, к которым обращаются из этой области видимости. Это не включает ссылки на глобальные или встроенные области видимости).

dis.hasname: Последовательность байт-кодов, которые обращаются к атрибуту по имени.

dis.hasjrel: Последовательность байт-кодов, имеющих относительную цель перехода.

dis.hasjabs: Последовательность байт-кодов, имеющих абсолютную цель перехода.

dis.haslocal: Последовательность байт-кодов, которые обращаются к локальной переменной.

dis.hascompare: Последовательность байт-кодов логических операций.