# `dis` — Desensamblador para bytecode de Python

Código fuente: Lib/dis.py

El módulo `dis` admite el análisis de CPython bytecode al desarmarlo. El bytecode de CPython que este módulo toma como entrada se define en el archivo `Include/opcode.h` y lo utilizan el compilador y el intérprete.

Detalles de implementación de CPython: Bytecode es un detalle de implementación del intérprete CPython. No se garantiza que el bytecode no se agregará, eliminará ni cambiará entre las versiones de Python. El uso de este módulo no debe considerarse para trabajar en diferentes máquinas virtuales Python o versiones de Python.

Distinto en la versión 3.6: Use 2 bytes para cada instrucción. Anteriormente, el número de bytes variaba según la instrucción.

Distinto en la versión 3.10: El argumento de las instrucciones de salto, manejo de excepciones y bucle ahora es el desplazamiento de instrucción en lugar del desplazamiento de byte.

Distinto en la versión 3.11: Some instructions are accompanied by one or more inline cache entries, which take the form of `CACHE` instructions. These instructions are hidden by default, but can be shown by passing `show_caches=True` to any `dis` utility. Furthermore, the interpreter now adapts the bytecode to specialize it for different runtime conditions. The adaptive bytecode can be shown by passing `adaptive=True`.

Ejemplo: dada la función `myfunc()`:

    def myfunc(alist):
        return len(alist)

el siguiente comando se puede utilizar para mostrar el desmontaje de `myfunc()`:

    >>> dis.dis(myfunc)
      2           0 RESUME                   0

      3           2 LOAD_GLOBAL              1 (NULL + len)
                 14 LOAD_FAST                0 (alist)
                 16 PRECALL                  1
                 20 CALL                     1
                 30 RETURN_VALUE

(El «2» es un número de línea).

## Command-line interface

The `dis` module can be invoked as a script from the command line:

    python -m dis [-h] [-C] [infile]

The following options are accepted:

-h, --help

  Display usage and exit.

-C, --show-caches

  Show inline caches.

If `infile` is specified, its disassembled code will be written to stdout. Otherwise, disassembly is performed on compiled source code recieved from stdin.

## Análisis de bytecode

Nuevo en la versión 3.4.

La API de análisis de bytecode permite que partes del código Python se envuelvan en un objeto `Bytecode` que proporciona un fácil acceso a los detalles del código compilado.

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

  Analiza el bytecode correspondiente a una función, generador, generador asíncrono, corutina, método, cadena de código fuente o un objeto de código (como lo retorna `compile()`).

  Este es un contenedor conveniente para muchas de las funciones enumeradas a continuación, en particular `get_instructions()`, ya que iterar sobre una instancia de `Bytecode` produce las operaciones de bytecode como instancias de `Instruction`.

  Si first_line no es `None`, indica el número de línea que se debe informar para la primera línea de origen en el código desmontado. De lo contrario, la información de la línea de origen (si la hay) se toma directamente del objeto de código desmontado.

  Si current_offset no es `None`, se refiere a un desplazamiento de instrucción en el código desmontado. Establecer esto significa `dis()` mostrará un marcador de «instrucción actual» contra el código de operación especificado.

  If show_caches is `True`, `dis()` will display inline cache entries used by the interpreter to specialize the bytecode.

  If adaptive is `True`, `dis()` will display specialized bytecode that may be different from the original bytecode.

  classmethod from_traceback(tb, *, show_caches=False)

    Construye una instancia de `Bytecode` a partir del traceback dado, estableciendo current_offset en la instrucción responsable de la excepción.

  codeobj

    El objeto de código compilado.

  first_line

    La primera línea de origen del objeto de código (si está disponible)

  dis()

    Retorna una vista formateada de las operaciones de bytecode (lo mismo que impreso por `dis.dis()`, pero retornado como una cadena de caracteres multilínea).

  info()

    Retorna una cadena de caracteres multilínea formateada con información detallada sobre el objeto de código, como `code_info()`.

  Distinto en la versión 3.7: Esto ahora puede manejar objetos generadores asíncronos y de corutinas.

  Distinto en la versión 3.11: Added the show_caches and adaptive parameters.

Ejemplo:

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

## Funciones de análisis

El módulo `dis` también define las siguientes funciones de análisis que convierten la entrada directamente en la salida deseada. Pueden ser útiles si solo se realiza una sola operación, por lo que el objeto de análisis intermedio no es útil:

dis.code_info(x)

  Retorna una cadena de caracteres multilínea formateada con información detallada del objeto de código para la función, generador, generador asíncrono, corutina, método, cadena de código fuente u objeto de código suministrados.

  Tenga en cuenta que el contenido exacto de las cadenas de información de código depende en gran medida de la implementación y puede cambiar arbitrariamente en las diferentes máquinas virtuales Python o las versiones de Python.

  Nuevo en la versión 3.2.

  Distinto en la versión 3.7: Esto ahora puede manejar objetos generadores asíncronos y de corutinas.

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

  Imprime información detallada del objeto de código para la función, método, cadena de código fuente u objeto de código suministrado en file (o `sys.stdout` si file no está especificado).

  Esta es una abreviatura conveniente para `print(code_info(x), file=file)`, destinado a la exploración interactiva en el indicador del intérprete (prompt).

  Nuevo en la versión 3.2.

  Distinto en la versión 3.4: Agrega un parámetro file.

dis.dis(x=None, *, file=None, depth=None, show_caches=False, adaptive=False)

  Desmontar el objeto x. x puede denotar un módulo, una clase, un método, una función, un generador, un generador asíncrono, una corutina, un objeto de código, una cadena de código fuente o una secuencia de bytes de código de bytes sin procesar. Para un módulo, desmonta todas las funciones. Para una clase, desmonta todos los métodos (incluidos los métodos de clase y estáticos). Para un objeto de código o secuencia de bytecode sin procesar, imprime una línea por instrucción de bytecode. También desmonta recursivamente objetos de código anidados (el código de comprensiones, expresiones generadoras y funciones anidadas, y el código utilizado para construir clases anidadas). Las cadenas de caracteres se compilan primero en objetos de código con la función incorporada `compile()` antes de desmontarse. Si no se proporciona ningún objeto, esta función desmonta el último rastreo.

  El desensamblaje se escribe como texto en el argumento file proporcionado si se proporciona y, de lo contrario, `sys.stdout`.

  La profundidad máxima de recursión está limitada por depth a menos que sea `None`. `depth=0` significa que no hay recursión.

  If show_caches is `True`, this function will display inline cache entries used by the interpreter to specialize the bytecode.

  If adaptive is `True`, this function will display specialized bytecode that may be different from the original bytecode.

  Distinto en la versión 3.4: Agrega un parámetro file.

  Distinto en la versión 3.7: Desensamblaje recursivo implementado y parámetro agregado depth.

  Distinto en la versión 3.7: Esto ahora puede manejar objetos generadores asíncronos y de corutinas.

  Distinto en la versión 3.11: Added the show_caches and adaptive parameters.

dis.distb(tb=None, *, file=None, show_caches=False, adaptive=False)

  Desmonta la función de inicio de pila de un rastreo, utilizando el último rastreo si no se pasó ninguno. Se indica la instrucción que causa la excepción.

  El desensamblaje se escribe como texto en el argumento file proporcionado si se proporciona y, de lo contrario, `sys.stdout`.

  Distinto en la versión 3.4: Agrega un parámetro file.

  Distinto en la versión 3.11: Added the show_caches and adaptive parameters.

dis.disassemble(code, lasti=-1, *, file=None, show_caches=False, adaptive=False)
dis.disco(code, lasti=-1, *, file=None, show_caches=False, adaptive=False)

  Desmonta un objeto de código, que indica la última instrucción si se proporcionó lasti. La salida se divide en las siguientes columnas:

  1. el número de línea, para la primera instrucción de cada línea

  2. la instrucción actual, indicada como `-->`,

  3. una instrucción etiquetada, indicada con `>>`,

  4. la dirección de la instrucción,

  5. el nombre del código de operación,

  6. parámetros de operación, y

  7. interpretación de los parámetros entre paréntesis.

  La interpretación de parámetros reconoce nombres de variables locales y globales, valores constantes, objetivos de ramificación y operadores de comparación.

  El desensamblaje se escribe como texto en el argumento file proporcionado si se proporciona y, de lo contrario, `sys.stdout`.

  Distinto en la versión 3.4: Agrega un parámetro file.

  Distinto en la versión 3.11: Added the show_caches and adaptive parameters.

dis.get_instructions(x, *, first_line=None, show_caches=False, adaptive=False)

  Retorna un iterador sobre las instrucciones en la función, método, cadena de código fuente u objeto de código suministrado.

  El iterador genera una serie de tuplas con nombre `Instruction` que dan los detalles de cada operación en el código suministrado.

  Si first_line no es `None`, indica el número de línea que se debe informar para la primera línea de origen en el código desmontado. De lo contrario, la información de la línea de origen (si la hay) se toma directamente del objeto de código desmontado.

  The show_caches and adaptive parameters work as they do in `dis()`.

  Nuevo en la versión 3.4.

  Distinto en la versión 3.11: Added the show_caches and adaptive parameters.

dis.findlinestarts(code)

  This generator function uses the `co_lines()` method of the code object code to find the offsets which are starts of lines in the source code. They are generated as `(offset, lineno)` pairs.

  Distinto en la versión 3.6: Los números de línea pueden estar disminuyendo. Antes, siempre estaban aumentando.

  Distinto en la versión 3.10: The PEP 626 `co_lines()` method is used instead of the `co_firstlineno` and `co_lnotab` attributes of the code object.

dis.findlabels(code)

  Detecta todos los desplazamientos en la cadena de caracteres de código de byte compilada code que son objetivos de salto y retorna una lista de estos desplazamientos.

dis.stack_effect(opcode, oparg=None, *, jump=None)

  Calcula el efecto de pila de opcode con el argumento oparg.

  Si el código tiene un objetivo de salto y jump es `True`, `stack_effect()` retornará el efecto de pila del salto. Si jump es `False`, retornará el efecto de acumulación de no saltar. Y si jump es `None` (predeterminado), retornará el efecto de acumulación máxima de ambos casos.

  Nuevo en la versión 3.4.

  Distinto en la versión 3.8: Agrega un parámetro jump.

## Instrucciones bytecode de Python

La función `get_instructions()` y clase `Bytecode` proporcionan detalles de las instrucciones bytecode como instancias `Instruction`:

class dis.Instruction

  Detalles para una operación de bytecode

  opcode

    código numérico para la operación, correspondiente a los valores del opcode listados a continuación y los valores de bytecode en Colecciones opcode.

  opname

    nombre legible por humanos para la operación

  arg

    argumento numérico para la operación (si existe), de lo contrario `None`

  argval

    valor de argumento resuelto (si lo hay); de lo contrario, `None`

  argrepr

    descripción legible por humanos del argumento de la operación (si lo hay); de lo contrario, una cadena vacía.

  offset

    índice de inicio de operación dentro de la secuencia de bytecode

  starts_line

    línea iniciada por este código de operación (si existe), de lo contrario `None`

  is_jump_target

    `True` si otro código salta aquí, de lo contrario, `False`

  positions

    Objeto `dis.Positions` que contiene las ubicaciones de inicio y finalización cubiertas por esta instrucción.

  Nuevo en la versión 3.4.

  Distinto en la versión 3.11: Se agrega el campo `positions`.

class dis.Positions

  En caso de que la información no esté disponible, algunos campos pueden ser `None`.

  lineno
  end_lineno
  col_offset
  end_col_offset

  Nuevo en la versión 3.11.

El compilador de Python actualmente genera las siguientes instrucciones de bytecode.

Instrucciones generales

NOP

  Código que no hace nada. Utilizado como marcador de posición por el optimizador de bytecode y para generar eventos de seguimiento de línea.

POP_TOP

  Elimina el elemento de la parte superior de la pila (TOS).

COPY(i)

  Empuje el elemento i-th a la parte superior de la pila. El elemento no se elimina de su ubicación original.

  Nuevo en la versión 3.11.

SWAP(i)

  Intercambie TOS con el artículo en la posición i.

  Nuevo en la versión 3.11.

CACHE

  En lugar de ser una instrucción real, este código de operación se usa para marcar espacio adicional para que el intérprete almacene en caché datos útiles directamente en el bytecode. Todas las utilidades `dis` lo ocultan automáticamente, pero se puede ver con `show_caches=True`.

  Lógicamente, este espacio forma parte de la instrucción anterior. Muchos códigos de operación esperan ser seguidos por un número exacto de cachés y le indicarán al intérprete que los omita en tiempo de ejecución.

  Los cachés poblados pueden parecer instrucciones arbitrarias, por lo que se debe tener mucho cuidado al leer o modificar el bytecode adaptativo sin procesar que contiene datos acelerados.

  Nuevo en la versión 3.11.

Operaciones unarias

Las operaciones unarias toman la parte superior de la pila, aplican la operación y retornan el resultado a la pila.

UNARY_POSITIVE

  Implementa `TOS = +TOS`.

UNARY_NEGATIVE

  Implementa `TOS = -TOS`.

UNARY_NOT

  Implementa `TOS = not TOS`.

UNARY_INVERT

  Implementa `TOS = ~TOS`.

GET_ITER

  Implementa `TOS = iter(TOS)`.

GET_YIELD_FROM_ITER

  Si `TOS` es un iterador generador o un objeto corutina se deja como está. De lo contrario, implementa `TOS = iter(TOS)`.

  Nuevo en la versión 3.5.

Operaciones binarias e in situ

Las operaciones binarias eliminan el elemento superior de la pila (TOS) y el segundo elemento de la pila superior (TOS1) de la pila. Realizan la operación y retornan el resultado a la pila.

Las operaciones en el lugar son como operaciones binarias, ya que eliminan TOS y TOS1, y retornan el resultado a la pila, pero la operación se realiza en el lugar cuando TOS1 lo admite, y el TOS resultante puede ser (pero no tiene ser) el TOS1 original.

BINARY_OP(op)

  Implementa los operadores binarios e in situ (según el valor de op).

  Nuevo en la versión 3.11.

BINARY_SUBSCR

  Implementa `TOS = TOS1[TOS]`.

STORE_SUBSCR

  Implementa `TOS1[TOS] = TOS2`.

DELETE_SUBSCR

  Implementa `del TOS1[TOS]`.

Opcodes de corutinas

GET_AWAITABLE(where)

  Implementa `TOS = get_awaitable(TOS)`, donde `get_awaitable(o)` retorna `o` si `o` es un objeto de corutina o un objeto generador con el indicador CO_ITERABLE_COROUTINE, o resuelve `o.__await__`.

  > Si el operando `where` es distinto de cero, indica dónde ocurre la instrucción:

  > - `1` Después de una llamada a `__aenter__`

  > - `2` Después de una llamada a `__aexit__`

  Nuevo en la versión 3.5.

  Distinto en la versión 3.11: Anteriormente, esta instrucción no tenía un oparg.

GET_AITER

  Implementa `TOS = TOS.__aiter__()`.

  Nuevo en la versión 3.5.

  Distinto en la versión 3.7: Ya no se admite el retorno de objetos awaitable de `__aiter__`.

GET_ANEXT

  Agrega `get_awaitable(TOS.__anext__())` a la pila. Consulte `GET_AWAITABLE` para obtener detalles sobre `get_awaitable`.

  Nuevo en la versión 3.5.

END_ASYNC_FOR

  Terminates an `async for` loop. Handles an exception raised when awaiting a next item. The stack contains the async iterable in TOS1 and the raised exception in TOS. Both are popped. If the exception is not `StopAsyncIteration`, it is re-raised.

  Nuevo en la versión 3.8.

  Distinto en la versión 3.11: La representación de excepciones en la pila ahora consta de uno, no de tres elementos.

BEFORE_ASYNC_WITH

  Resuelve `__aenter__` y `__aexit__` del objeto en la parte superior de la pila. Apila `__aexit__` y el resultado de `__aenter__()` a la pila.

  Nuevo en la versión 3.5.

Opcodes misceláneos

PRINT_EXPR

  Implementa la declaración de expresión para el modo interactivo. TOS se elimina de la pila y se imprime. En modo no interactivo, una declaración de expresión termina con `POP_TOP`.

SET_ADD(i)

  Llama a `set.add(TOS1[-i], TOS)`. Se utiliza para implementar comprensiones de conjuntos.

LIST_APPEND(i)

  Llama a `list.append(TOS1[-i], TOS)`. Se utiliza para implementar listas por comprensión.

MAP_ADD(i)

  Llama a `dict.__setitem__(TOS1[-i], TOS1, TOS)`. Se utiliza para implementar comprensiones de diccionarios.

  Nuevo en la versión 3.1.

  Distinto en la versión 3.8: El valor del mapa es TOS y la clave del mapa es TOS1. Antes, esos fueron revertidos.

Para todas las instrucciones `SET_ADD`, `LIST_APPEND` y `MAP_ADD`, mientras el valor agregado o el par clave/valor aparece, el objeto contenedor permanece en la pila para que quede disponible para futuras iteraciones del bucle.

RETURN_VALUE

  Retorna con TOS a quien llama la función.

YIELD_VALUE

  Desapila TOS y lo genera (yield) de un generator.

SETUP_ANNOTATIONS

  Comprueba si `__anotaciones__` está definido en `locals()`, si no está configurado como un `dict` vacío. Este código de operación solo se emite si el cuerpo de una clase o módulo contiene anotaciones de variables estáticamente.

  Nuevo en la versión 3.6.

IMPORT_STAR

  Carga todos los símbolos que no comienzan con `'_'` directamente desde el TOS del módulo al espacio de nombres local. El módulo se desapila después de cargar todos los nombres. Este opcode implementa `from module import *`.

POP_EXCEPT

  Extrae un valor de la pila, que se utiliza para restaurar el estado de excepción.

  Distinto en la versión 3.11: La representación de excepciones en la pila ahora consta de uno, no de tres elementos.

RERAISE

  Re-raises the exception currently on top of the stack. If oparg is non-zero, pops an additional value from the stack which is used to set `f_lasti` of the current frame.

  Nuevo en la versión 3.9.

  Distinto en la versión 3.11: La representación de excepciones en la pila ahora consta de uno, no de tres elementos.

PUSH_EXC_INFO

  Extrae un valor de la pila. Agrega la excepción actual a la parte superior de la pila. Agrega el valor que apareció originalmente de vuelta a la pila. Se utiliza en los controladores de excepciones.

  Nuevo en la versión 3.11.

CHECK_EXC_MATCH

  Realiza coincidencias de excepciones para `except`. Comprueba si TOS1 es una excepción que coincide con TOS. Aparece TOS y agrega el resultado booleano de la prueba.

  Nuevo en la versión 3.11.

CHECK_EG_MATCH

  Realiza coincidencias de excepciones para `except*`. Aplica `split(TOS)` en el grupo de excepción que representa TOS1.

  En caso de coincidencia, extrae dos elementos de la pila y agrega el subgrupo que no coincide (`None` en caso de coincidencia total) seguido del subgrupo coincidente. Cuando no hay ninguna coincidencia, muestra un elemento (el tipo de coincidencia) y presiona `None`.

  Nuevo en la versión 3.11.

PREP_RERAISE_STAR

  Combina la lista de excepciones generadas y re-elevadas de TOS en un grupo de excepciones para propagar desde un bloque try-except*. Utiliza el grupo de excepción original de TOS1 para reconstruir la estructura de las excepciones replanteadas. Saca dos elementos de la pila y agrega la excepción a relanzar o `None` si no hay una.

  Nuevo en la versión 3.11.

WITH_EXCEPT_START

  Llama a la función en la posición 4 de la pila con argumentos (tipo, val, tb) que representan la excepción en la parte superior de la pila. Se utiliza para implementar la llamada `context_manager.__exit__(*exc_info())` cuando se ha producido una excepción en una sentencia `with`.

  Nuevo en la versión 3.9.

  Distinto en la versión 3.11: La función `__exit__` está en la posición 4 de la pila en lugar de la 7. La representación de excepciones en la pila ahora consta de uno, no de tres, elementos.

LOAD_ASSERTION_ERROR

  Inserta `AssertionError` en la pila. Utilizado por la declaración `assert`.

  Nuevo en la versión 3.9.

LOAD_BUILD_CLASS

  Agrega `builtins.__build_class__()` a la pila. Más tarde se llama para construir una clase.

BEFORE_WITH(delta)

  Este código de operación realiza varias operaciones antes de que comience un bloque with. Primero, carga `__exit__()` desde el administrador de contexto y lo agrega a la pila para que `WITH_EXCEPT_START` lo use más tarde. Entonces, se llama `__enter__()`. Finalmente, el resultado de llamar al método `__enter__()` se agrega en la pila.

  Nuevo en la versión 3.11.

GET_LEN

  Apila `len(TOS)` en la pila.

  Nuevo en la versión 3.10.

MATCH_MAPPING

  If TOS is an instance of `collections.abc.Mapping` (or, more technically: if it has the `Py_TPFLAGS_MAPPING` flag set in its `tp_flags`), push `True` onto the stack. Otherwise, push `False`.

  Nuevo en la versión 3.10.

MATCH_SEQUENCE

  If TOS is an instance of `collections.abc.Sequence` and is not an instance of `str`/`bytes`/`bytearray` (or, more technically: if it has the `Py_TPFLAGS_SEQUENCE` flag set in its `tp_flags`), push `True` onto the stack. Otherwise, push `False`.

  Nuevo en la versión 3.10.

MATCH_KEYS

  TOS es una tupla de claves de mapeo y TOS1 es el sujeto de coincidencia. Si TOS1 contiene todas las claves en TOS, agrega un `tuple` que contenga los valores correspondientes. De lo contrario, agrega `None`.

  Nuevo en la versión 3.10.

  Distinto en la versión 3.11: Anteriormente, esta instrucción también generaba un valor booleano que indicaba éxito (`True`) o falla (`False`).

STORE_NAME(namei)

  Implements `name = TOS`. namei is the index of name in the attribute `co_names` of the code object. The compiler tries to use `STORE_FAST` or `STORE_GLOBAL` if possible.

DELETE_NAME(namei)

  Implements `del name`, where namei is the index into `co_names` attribute of the code object.

UNPACK_SEQUENCE(count)

  Descomprime TOS en count valores individuales, que se colocan en la pila de derecha a izquierda.

UNPACK_EX(counts)

  Implementa la asignación con un objetivo destacado: desempaqueta un iterable en TOS en valores individuales, donde el número total de valores puede ser menor que el número de elementos en el iterable: uno de los nuevos valores será una lista de todos los elementos sobrantes.

  El byte bajo de count es el número de valores antes del valor de la lista, el byte alto de count es el número de valores después de él. Los valores resultantes se colocan en la pila de derecha a izquierda.

STORE_ATTR(namei)

  Implementa `TOS.name = TOS1`, donde namei es el índice del nombre en `co_names`.

DELETE_ATTR(namei)

  Implements `del TOS.name`, using namei as index into `co_names` of the code object.

STORE_GLOBAL(namei)

  Funciona como `STORE_NAME`, pero almacena el nombre como global.

DELETE_GLOBAL(namei)

  Funciona como `DELETE_NAME`, pero elimina un nombre global.

LOAD_CONST(consti)

  Apila `co_consts[consti]` en la pila.

LOAD_NAME(namei)

  Apila el valor asociado con `co_names [namei]` en la pila.

BUILD_TUPLE(count)

  Crea una tupla que consume elementos count de la pila, y apila la tupla resultante a la pila.

BUILD_LIST(count)

  Funciona como `BUILD_TUPLE`, pero crea una lista.

BUILD_SET(count)

  Funciona como `BUILD_TUPLE`, pero crea un conjunto.

BUILD_MAP(count)

  Apila un nuevo objeto de diccionario en la pila. Desapila `2 * count` elementos para que el diccionario contenga count entradas: `{..., TOS3: TOS2, TOS1: TOS}`.

  Distinto en la versión 3.5: El diccionario se crea a partir de elementos de la pila en lugar de crear un diccionario vacío dimensionado previamente para contener count elementos.

BUILD_CONST_KEY_MAP(count)

  La versión de `BUILD_MAP` especializada para claves constantes. Desapila el elemento superior en la pila que contiene una tupla de claves, luego, a partir de `TOS1`, muestra los valores count para formar valores en el diccionario incorporado.

  Nuevo en la versión 3.6.

BUILD_STRING(count)

  Concatena count cadenas de caracteres de la pila y empuja la cadena de caracteres resultante en la pila.

  Nuevo en la versión 3.6.

LIST_TO_TUPLE

  Saca una lista de la pila y empuja una tupla que contiene los mismos valores.

  Nuevo en la versión 3.9.

LIST_EXTEND(i)

  Llama a `list.extend(TOS1[-i], TOS)`. Se utiliza para crear listas.

  Nuevo en la versión 3.9.

SET_UPDATE(i)

  Llama a `set.update(TOS1[-i], TOS)`. Se usa para construir decorados.

  Nuevo en la versión 3.9.

DICT_UPDATE(i)

  Llama a `dict.update(TOS1[-i], TOS)`. Se usa para construir dictados.

  Nuevo en la versión 3.9.

DICT_MERGE(i)

  Como `DICT_UPDATE` pero lanza una excepción para claves duplicadas.

  Nuevo en la versión 3.9.

LOAD_ATTR(namei)

  Reemplaza TOS con `getattr(TOS, co_names[namei])`.

COMPARE_OP(opname)

  Realiza una operación booleana. El nombre de la operación se puede encontrar en `cmp_op[opname]`.

IS_OP(invert)

  Realiza una comparación `is` o `is not` si `invert` es 1.

  Nuevo en la versión 3.9.

CONTAINS_OP(invert)

  Realiza una comparación `in` o `not in` si `invert` es 1.

  Nuevo en la versión 3.9.

IMPORT_NAME(namei)

  Importa el módulo `co_names[namei]`. TOS y TOS1 aparecen y proporcionan los argumentos fromlist y level de `__import__()`. El objeto del módulo se empuja a la pila. El espacio de nombres actual no se ve afectado: para una instrucción de importación adecuada, una instrucción posterior `STORE_FAST` modifica el espacio de nombres.

IMPORT_FROM(namei)

  Carga el atributo `co_names[namei]` del módulo que se encuentra en TOS. El objeto resultante se apila en la pila, para luego ser almacenado por la instrucción `STORE_FAST`.

JUMP_FORWARD(delta)

  Incrementa el contador de bytecode en delta.

JUMP_BACKWARD(delta)

  Decrementa el contador de bytecode en delta. Comprueba si hay interrupciones.

  Nuevo en la versión 3.11.

JUMP_BACKWARD_NO_INTERRUPT(delta)

  Decrementa el contador de bytecode en delta. No busca interrupciones.

  Nuevo en la versión 3.11.

POP_JUMP_FORWARD_IF_TRUE(delta)

  Si TOS es verdadero, incrementa el contador de bytecode en delta. TOS es retirado.

  Nuevo en la versión 3.11.

POP_JUMP_BACKWARD_IF_TRUE(delta)

  Si TOS es verdadero, decrementa el contador de bytecode en delta. TOS es retirado.

  Nuevo en la versión 3.11.

POP_JUMP_FORWARD_IF_FALSE(delta)

  Si TOS es falso, incrementa el contador de bytecode en delta. TOS es retirado.

  Nuevo en la versión 3.11.

POP_JUMP_BACKWARD_IF_FALSE(delta)

  Si TOS es falso, decrementa el contador de bytecode en delta. TOS es retirado.

  Nuevo en la versión 3.11.

POP_JUMP_FORWARD_IF_NOT_NONE(delta)

  Si TOS no es `None`, incrementa el contador de bytecode en delta. TOS es retirado.

  Nuevo en la versión 3.11.

POP_JUMP_BACKWARD_IF_NOT_NONE(delta)

  Si TOS no es `None`, decrementa el contador de bytecode en delta. TOS es retirado.

  Nuevo en la versión 3.11.

POP_JUMP_FORWARD_IF_NONE(delta)

  Si TOS es `None`, incrementa el contador de bytecode en delta. TOS es retirado.

  Nuevo en la versión 3.11.

POP_JUMP_BACKWARD_IF_NONE(delta)

  Si TOS es `None`, decrementa el contador de bytecode en delta. TOS es retirado.

  Nuevo en la versión 3.11.

JUMP_IF_TRUE_OR_POP(delta)

  Si TOS es verdadero, incrementa el contador de bytecode en delta y deja TOS en la pila. De lo contrario (TOS es falso), TOS es retirado.

  Nuevo en la versión 3.1.

  Distinto en la versión 3.11: El oparg es ahora un delta relativo en lugar de un objetivo absoluto.

JUMP_IF_FALSE_OR_POP(delta)

  Si TOS es falso, incrementa el contador de bytecode en delta y deja TOS en la pila. De lo contrario (TOS es verdadero), TOS es retirado.

  Nuevo en la versión 3.1.

  Distinto en la versión 3.11: El oparg es ahora un delta relativo en lugar de un objetivo absoluto.

FOR_ITER(delta)

  TOS es un iterador. Llama a su método `__next__()`. Si esto produce un nuevo valor, lo apila en la pila (dejando el iterador debajo de él). Si el iterador indica que está agotado, se abre TOS y el contador de código de bytes se incrementa en delta.

LOAD_GLOBAL(namei)

  Carga el `co_names[namei>>1]` global llamado en la pila.

  Distinto en la versión 3.11: Si se establece el bit bajo de `namei`, se agrega un `NULL` a la pila antes de la variable global.

LOAD_FAST(var_num)

  Apila una referencia al local `co_varnames[var_num]` sobre la pila.

STORE_FAST(var_num)

  Almacena TOS en el local `co_varnames[var_num]`.

DELETE_FAST(var_num)

  Elimina la `co_varnames[var_num]` local.

MAKE_CELL(i)

  Creates a new cell in slot `i`. If that slot is nonempty then that value is stored into the new cell.

  Nuevo en la versión 3.11.

LOAD_CLOSURE(i)

  Inserta una referencia a la celda contenida en la ranura `i` del almacenamiento «locales rápidos». El nombre de la variable es `co_fastlocalnames[i]`.

  Tenga en cuenta que `LOAD_CLOSURE` es efectivamente un alias para `LOAD_FAST`. Existe para mantener el bytecode un poco más legible.

  Distinto en la versión 3.11: `i` ya no se compensa con la longitud de `co_varnames`.

LOAD_DEREF(i)

  Carga la celda contenida en el slot `i` del almacenamiento «fast locals». Agrega una referencia al objeto que contiene la celda en la pila.

  Distinto en la versión 3.11: `i` is no longer offset by the length of `co_varnames`.

LOAD_CLASSDEREF(i)

  Al igual que `LOAD_DEREF` pero primero verifica el diccionario local antes de consultar la celda. Esto se usa para cargar variables libres en los cuerpos de clase.

  Nuevo en la versión 3.4.

  Distinto en la versión 3.11: `i` ya no se compensa con la longitud de `co_varnames`.

STORE_DEREF(i)

  Almacena TOS en la celda contenida en la ranura `i` del almacenamiento «locales rápidos».

  Distinto en la versión 3.11: `i` is no longer offset by the length of `co_varnames`.

DELETE_DEREF(i)

  Vacía la celda contenida en la ranura `i` del almacenamiento de «locales rápidos». Utilizado por la instrucción `del`.

  Nuevo en la versión 3.2.

  Distinto en la versión 3.11: `i` is no longer offset by the length of `co_varnames`.

COPY_FREE_VARS(n)

  Copia las variables libres `n` del cierre al marco. Elimina la necesidad de un código especial en el lado del que llama al llamar clausuras.

  Nuevo en la versión 3.11.

RAISE_VARARGS(argc)

  Provoca una excepción utilizando una de las 3 formas de la declaración `raise`, dependiendo del valor de argc:

  - 0: `raise` (vuelve a lanzar la excepción anterior)

  - 1: `raise TOS` (lanza instancia de excepción o un tipo en `TOS`)

  - 2: `raise TOS1 desde TOS` (lanza una instancia de excepción o tipo en `TOS1` con `__cause__` establecida en `TOS`)

CALL(argc)

  Llama a un objeto invocable con la cantidad de argumentos especificados por `argc`, incluidos los argumentos con nombre especificados por el `KW_NAMES` anterior, si los hay. En la pila están (en orden ascendente), ya sea:

  - NULL

  - El llamable

  - Los argumentos posicionales

  - Los argumentos nombrados

  o:

  - El llamable

  - `self`

  - Los argumentos posicionales restantes

  - Los argumentos nombrados

  `argc` es el total de los argumentos posicionales y con nombre, excluyendo `self` cuando `NULL` no está presente.

  `CALL` extrae todos los argumentos y el objeto invocable de la pila, llama al objeto invocable con esos argumentos y agrega el valor retornado por el objeto invocable.

  Nuevo en la versión 3.11.

CALL_FUNCTION_EX(flags)

  Llama a un objeto invocable con un conjunto variable de argumentos posicionales y de palabras clave. Si se establece el bit más bajo de flags, la parte superior de la pila contiene un objeto de mapeo que contiene argumentos de palabras clave adicionales. Antes de que se llame al invocable, el objeto de mapeo y el objeto iterable se «desempaquetan» y su contenido se pasa como palabra clave y argumentos posicionales, respectivamente. `CALL_FUNCTION_EX` saca todos los argumentos y el objeto invocable de la pila, llama al objeto invocable con esos argumentos y empuja el valor de retorno retornado por el objeto invocable.

  Nuevo en la versión 3.6.

LOAD_METHOD(namei)

  Carga un método denominado `co_names[namei]` desde el objeto TOS. TOS es retirado. Este código de bytes distingue dos casos: si TOS tiene un método con el nombre correcto, el código de bytes agrega el método independiente y TOS. `CALL` utilizará TOS como primer argumento (`self`) al llamar al método independiente. De lo contrario, se agregan `NULL` y el objeto devuelto por la búsqueda de atributos.

  Nuevo en la versión 3.7.

PRECALL(argc)

  Prefijos `CALL`. Lógicamente esto es un no op. Existe para permitir una especialización efectiva de las llamadas. `argc` es el número de argumentos como se describe en `CALL`.

  Nuevo en la versión 3.11.

PUSH_NULL

  > Agrega un `NULL` a la pila. Se usa en la secuencia de llamadas para hacer coincidir el `NULL` enviado por `LOAD_METHOD` para llamadas que no son de método.

  Nuevo en la versión 3.11.

KW_NAMES(i)

  Prefijos `PRECALL`. Almacena una referencia a `co_consts[consti]` en una variable interna para uso de `CALL`. `co_consts[consti]` debe ser una tupla de cadenas.

  Nuevo en la versión 3.11.

MAKE_FUNCTION(flags)

  Apila un nuevo objeto de función en la pila. De abajo hacia arriba, la pila consumida debe constar de valores si el argumento lleva un valor de marca especificado

  - `0x01`, una tupla de valores predeterminados para solo parámetros posicionales y posicionales o de palabras clave en orden posicional

  - `0x02` un diccionario de valores predeterminados de solo palabras clave

  - `0x04` una tupla de cadenas de caracteres que contiene anotaciones de parámetros

  - `0x08` una tupla que contiene celdas para variables libres, haciendo un cierre (closure)

  - the code associated with the function (at TOS)

  Distinto en la versión 3.10: El valor indicador `0x04` es una tupla de cadena de caracteres en vez de un diccionario

  Distinto en la versión 3.11: Qualified name at TOS was removed.

BUILD_SLICE(argc)

  Apila un objeto de rebanada en la pila. argc debe ser 2 o 3. Si es 2, se apila `slice(TOS1, TOS)`; si es 3, se apila `slice(TOS2, TOS1, TOS)`. Consulte la función incorporada `slice()` para obtener más información.

EXTENDED_ARG(ext)

  Prefija cualquier código de operación que tenga un argumento demasiado grande para caber en el byte predeterminado. ext contiene un byte adicional que actúa como bits más altos en el argumento. Para cada opcode, como máximo se permiten tres prefijos `EXTENDED_ARG`, formando un argumento de dos bytes a cuatro bytes.

FORMAT_VALUE(flags)

  Se utiliza para implementar cadenas literales formateadas (cadenas de caracteres f). Desapila un fmt_spec opcional de la pila, luego un value requerido. flags se interpreta de la siguiente manera:

  - `(flags & 0x03) == 0x00`: value es formateado como está.

  - `(flags & 0x03) == 0x01`: llama `str()` sobre value antes de formatearlo.

  - `(flags & 0x03) == 0x02`: llama `repr()` sobre value antes de formatearlo.

  - `(flags & 0x03) == 0x03`: llama `ascii()` sobre value antes de formatearlo.

  - `(flags & 0x04) == 0x04`: desapila fmt_spec de la pila y lo usa, de lo contrario usa un fmt_spec vacío.

  El formateo se realiza usando `PyObject_Format()`. El resultado se apila en la pila.

  Nuevo en la versión 3.6.

MATCH_CLASS(count)

  TOS es una tupla de nombres de atributos clave, TOS1 es la clase contra la cual se hace la coincidencia, y TOS2 es el sujeto de la coincidencia. count es el número de sub-patrones posicionales.

  Retira TOS, TOS1 y TOS2. Si TOS2 es una instancia de TOS1 y tiene los atributos posicionales y de palabra clave requeridos por count y TOS, agrega una tupla de atributos extraídos. De lo contrario, agrega `None`.

  Nuevo en la versión 3.10.

  Distinto en la versión 3.11: Anteriormente, esta instrucción también generaba un valor booleano que indicaba éxito (`True`) o falla (`False`).

RESUME(where)

  > Un no-op. Realiza comprobaciones internas de seguimiento, depuración y optimización.

  > El operando `where` marca dónde ocurre el `RESUME`:

  > - `0` El comienzo de una función

  > - `1` Después de una expresión `yield`

  > - `2` Después de una expresión `yield from`

  > - `3` Después de una expresión `await`

  Nuevo en la versión 3.11.

RETURN_GENERATOR

  Crea un generador, corrutina o generador asíncrono a partir del marco actual. Borra el marco actual y retorna el generador recién creado.

  Nuevo en la versión 3.11.

SEND

  Envía `None` al subgenerador de este generador. Se utiliza en sentencias `yield from` y `await`.

  Nuevo en la versión 3.11.

ASYNC_GEN_WRAP

  Envuelve el valor en la parte superior de la pila en un `async_generator_wrapped_value`. Se utiliza para producir en generadores asíncronos.

  Nuevo en la versión 3.11.

HAVE_ARGUMENT

  Esto no es realmente un opcode. Identifica la línea divisoria entre los opcode que no usan su argumento y los que lo hacen (`< HAVE_ARGUMENT` y `>= HAVE_ARGUMENT`, respectivamente).

  Distinto en la versión 3.6: Ahora cada instrucción tiene un argumento, pero los códigos de operación `<HAVE_ARGUMENT` la ignoran. Antes, solo los códigos de operación `> = HAVE_ARGUMENT` tenían un argumento.

## Colecciones opcode

Estas colecciones se proporcionan para la introspección automática de instrucciones de bytecode:

dis.opname

  Secuencia de nombres de operaciones, indexable utilizando el bytecode.

dis.opmap

  Nombres de operaciones de mapeo de diccionario a bytecodes.

dis.cmp_op

  Secuencia de todos los nombres de operaciones de comparación.

dis.hasconst

  Secuencia de bytecodes que acceden a una constante.

dis.hasfree

  Secuencia de bytecodes que acceden a una variable libre (tenga en cuenta que “libre” en este contexto se refiere a nombres en el alcance actual a los que hacen referencia los ámbitos internos o los nombres en los ámbitos externos a los que se hace referencia desde este ámbito. No incluye referencias a ámbitos globales o integrados).

dis.hasname

  Secuencia de bytecodes que acceden a un atributo por nombre.

dis.hasjrel

  Secuencia de bytecodes que tienen un objetivo de salto relativo.

dis.hasjabs

  Secuencia de bytecodes que tienen un objetivo de salto absoluto.

dis.haslocal

  Secuencia de códigos de bytes que acceden a una variable local.

dis.hascompare

  Secuencia de bytecodes de operaciones booleanas.