# `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.

CPython implementation detail: 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.

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

    def myfunc(alist):
        return len(alist)

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

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

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

## 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)

  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.

  classmethod `from_traceback`(tb)

    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.

Ejemplo:

    >>> bytecode = dis.Bytecode(myfunc)
    >>> for instr in bytecode:
    ...     print(instr.opname)
    ...
    LOAD_GLOBAL
    LOAD_FAST
    CALL_FUNCTION
    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)

  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.

  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.

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

  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.

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

  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.

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

  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.

  Nuevo en la versión 3.4.

`dis.``findlinestarts`(code)

  Esta función de generador utiliza los atributos `co_firstlineno` y `co_lnotab` del objeto de código code para encontrar los desplazamientos que son comienzos de líneas en el código fuente. Se generan como pares `(offset, lineno)`. Ver Objects/lnotab_notes.txt para el formato `co_lnotab` y cómo decodificarlo.

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

`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 arg resuelto (si se conoce), de lo contrario igual que arg

  `argrepr`

    descripción legible por humanos del argumento de operación

  `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`

  Nuevo en la versión 3.4.

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

Instrucciones generales

`NOP`

  Código que hace nada. Utilizado como marcador de posición por el optimizador de código de bytes.

`POP_TOP`

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

`ROT_TWO`

  Intercambia los dos elementos más apilados.

`ROT_THREE`

  Levanta el segundo y tercer elemento de la pila una posición hacia arriba, mueve el elemento superior hacia abajo a la posición tres.

`ROT_FOUR`

  Lifts second, third and fourth stack items one position up, moves top down to position four.

  Nuevo en la versión 3.8.

`DUP_TOP`

  Duplica la referencia en la parte superior de la pila.

  Nuevo en la versión 3.2.

`DUP_TOP_TWO`

  Duplica las dos referencias en la parte superior de la pila, dejándolas en el mismo orden.

  Nuevo en la versión 3.2.

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

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.

`BINARY_POWER`

  Implementa `TOS = TOS1 ** TOS`.

`BINARY_MULTIPLY`

  Implementa `TOS = TOS1 * TOS`.

`BINARY_MATRIX_MULTIPLY`

  Implementa `TOS = TOS1 @ TOS`.

  Nuevo en la versión 3.5.

`BINARY_FLOOR_DIVIDE`

  Implementa `TOS = TOS1 // TOS`.

`BINARY_TRUE_DIVIDE`

  Implementa `TOS = TOS1 / TOS`.

`BINARY_MODULO`

  Implementa `TOS = TOS1 % TOS`.

`BINARY_ADD`

  Implementa `TOS = TOS1 + TOS`.

`BINARY_SUBTRACT`

  Implementa `TOS = TOS1 - TOS`.

`BINARY_SUBSCR`

  Implementa `TOS = TOS1[TOS]`.

`BINARY_LSHIFT`

  Implementa `TOS = TOS1 << TOS`.

`BINARY_RSHIFT`

  Implementa `TOS = TOS1 >> TOS`.

`BINARY_AND`

  Implementa `TOS = TOS1 & TOS`.

`BINARY_XOR`

  Implementa `TOS = TOS1 ^ TOS`.

`BINARY_OR`

  Implementa `TOS = TOS1 | TOS`.

Operaciones en su lugar

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.

`INPLACE_POWER`

  Implementa en su lugar `TOS = TOS1 ** TOS`.

`INPLACE_MULTIPLY`

  Implementa en su lugar `TOS = TOS1 * TOS`.

`INPLACE_MATRIX_MULTIPLY`

  Implementa en su lugar `TOS = TOS1 @ TOS`.

  Nuevo en la versión 3.5.

`INPLACE_FLOOR_DIVIDE`

  Implementa en su lugar `TOS = TOS1 // TOS`.

`INPLACE_TRUE_DIVIDE`

  Implementa en su lugar `TOS = TOS1 / TOS`.

`INPLACE_MODULO`

  Implementa en su lugar `TOS = TOS1 % TOS`.

`INPLACE_ADD`

  Implementa en su lugar `TOS = TOS1 + TOS`.

`INPLACE_SUBTRACT`

  Implementa en su lugar `TOS = TOS1 - TOS`.

`INPLACE_LSHIFT`

  Implementa en su lugar `TOS = TOS1 << TOS`.

`INPLACE_RSHIFT`

  Implementa en su lugar `TOS = TOS1 >> TOS`.

`INPLACE_AND`

  Implementa en su lugar `TOS = TOS1 & TOS`.

`INPLACE_XOR`

  Implementa en su lugar `TOS = TOS1 ^ TOS`.

`INPLACE_OR`

  Implementa en su lugar `TOS = TOS1 | TOS`.

`STORE_SUBSCR`

  Implementa `TOS1[TOS] = TOS2`.

`DELETE_SUBSCR`

  Implementa `del TOS1[TOS]`.

Opcodes de corutinas

`GET_AWAITABLE`

  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__`.

  Nuevo en la versión 3.5.

`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`

  Implementa `PUSH(get_awaitable(TOS.__anext__()))`. Consulte `GET_AWAITABLE` para obtener detalles sobre `get_awaitable`

  Nuevo en la versión 3.5.

`END_ASYNC_FOR`

  Termina un bucle `async for`. Maneja una excepción planteada cuando se espera un próximo elemento. Si TOS es `StopAsyncIteration` desapila 7 valores de la pila y restaura el estado de excepción utilizando los tres últimos. De lo contrario, vuelva a lanzar la excepción utilizando los tres valores de la pila. Se elimina un bloque de controlador de excepción de la pila de bloques.

  Nuevo en la versión 3.8.

`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.

`SETUP_ASYNC_WITH`

  Crea un nuevo objeto marco.

  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)

  Calls `list.append(TOS1[-i], TOS)`. Used to implement list comprehensions.

`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.

`YIELD_FROM`

  Desapila TOS y delega en él como un subiterador de un generator.

  Nuevo en la versión 3.3.

`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_BLOCK`

  Elimina un bloque de la pila de bloques. Por cuadro, hay una pila de bloques, que denota declaraciones `try`, y tal.

`POP_EXCEPT`

  Elimina un bloque de la pila de bloques. El bloque desapilado debe ser un bloque de controlador de excepción, como se crea implícitamente al ingresar un controlador de excepción. Además de desapilar valores extraños de la pila de cuadros, los últimos tres valores desapilados se utilizan para restaurar el estado de excepción.

`POP_FINALLY`(preserve_tos)

  Limpia la pila de valores y la pila de bloques. Si preserve_tos no es `0`, primero se desapila TOS de la pila y se apila a la pila después de realizar otras operaciones de pila:

  - Si TOS es `NULL` o un número entero (apilado por `BEGIN_FINALLY` o `CALL_FINALLY`) se desapila de la pila.

  - Si TOS es un tipo de excepción (se apila cuando se ha lanzado una excepción) se desapilan 6 valores de la pila, los últimos tres valores se usan para restaurar el estado de excepción. Se elimina un bloque de controlador de excepción de la pila de bloques.

  Es similar a `END_FINALLY`, pero no cambia el contador de bytecode ni lanza una excepción. Se usa para implementar `break`, `continue` y `return` en el bloque `finally`.

  Nuevo en la versión 3.8.

`BEGIN_FINALLY`

  Apila `NULL` en la pila para usarlo en `END_FINALLY`, `POP_FINALLY`, `WITH_CLEANUP_START` y `WITH_CLEANUP_FINISH`. Inicia el bloque `finally`.

  Nuevo en la versión 3.8.

`END_FINALLY`

  Termina una cláusula `finally`. El intérprete recuerda si la excepción se debe volver a ser lanzada o si se debe continuar la ejecución según el valor de TOS.

  - Si TOS es `NULL` (apilado por `BEGIN_FINALLY`) continúa con la siguiente instrucción. TOS se desapila.

  - Si TOS es un entero (apilado por `CALL_FINALLY`), establece el contador de bytecode en TOS. TOS se desapila.

  - Si TOS es un tipo de excepción (se apila cuando se ha lanzado una excepción) se desapilan 6 valores de la pila, los primeros tres valores desapilados se utilizan para volver a lanzar la excepción y los últimos tres valores desapilados se utilizan para restaurar el estado de excepción. Se elimina un bloque de controlador de excepción de la pila de bloques.

`LOAD_BUILD_CLASS`

  Apila `builtins.__build_class__()` en la pila. Más tarde se llama por `CALL_FUNCTION` para construir una clase.

`SETUP_WITH`(delta)

  Este opcode realiza varias operaciones antes de que comience un bloque with. Primero, carga `__exit__()` desde el administrador de contexto y lo apila a la pila para su uso posterior por `WITH_CLEANUP_START`. Entonces, `__enter__()` se llama, y finalmente se bloquea un bloque que apunta a delta. Finalmente, el resultado de llamar al método `__enter__()` se apila en la pila. El siguiente opcode lo ignorará (`POP_TOP`), o lo almacenará en (una) variable (s) (`STORE_FAST`, `STORE_NAME`, o `UNPACK_SEQUENCE`) .

  Nuevo en la versión 3.2.

`WITH_CLEANUP_START`

  Comienza a limpiar la pila cuando sale un bloque de instrucciones `with`.

  En la parte superior de la pila están `NULL` (apilado por `BEGIN_FINALLY`) o 6 valores apilados si se ha lanzado una excepción en el bloque with. A continuación se muestra el gestor de contexto `__exit__()` o un método ligado `__aexit__()`.

  Si TOS es `NULL`, llama a `SECOND(None, None, None)`, elimina la función de la pila, deja TOS y apila `None` a la pila. De lo contrario, llama `SEVENTH(TOP, SECOND, THIRD)`, desplaza los 3 valores inferiores de la pila hacia abajo, reemplaza el espacio vacío con `NULL` y apila TOS. Finalmente apila el resultado de la llamada.

`WITH_CLEANUP_FINISH`

  Termina de limpiar la pila cuando sale un bloque de instrucciones `with`.

  TOS es el resultado de la llamada a la función `__exit__()` o `__aexit__()` apilada por `WITH_CLEANUP_START`. SECOND es `None` o un tipo de excepción (se activa cuando se ha lanzado una excepción).

  Desapila dos valores de la pila. Si SECOND no es None y TOS es verdadero, se desenrolla el bloque EXCEPT_HANDLER que se creó cuando se detectó la excepción y empuja `NULL` a la pila.

Todos los siguientes códigos de operación utilizan sus argumentos.

`STORE_NAME`(namei)

  Implementa `name = TOS`. namei es el índice de name en el atributo `co_names` del objeto de código. El compilador intenta usar `STORE_FAST` o `STORE_GLOBAL` si es posible.

`DELETE_NAME`(namei)

  Implementa `del name`, donde namei es el índice en atributo `co_names` del objeto de código.

`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)

  Implementa `del TOS.name`, usando namei como índice en `co_names`.

`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.

`BUILD_TUPLE_UNPACK`(count)

  Desapila count iterables de la pila, los une en una sola tupla y apila el resultado. Implementa el desempaquetado iterable cuando se imprime una tupla `(*x, *y, *z)`.

  Nuevo en la versión 3.5.

`BUILD_TUPLE_UNPACK_WITH_CALL`(count)

  Esto es similar a `BUILD_TUPLE_UNPACK`, pero se usa para la sintaxis de llamada `f(*x, *y, *z)`. El elemento de la pila en la posición `count + 1` debe ser la correspondiente invocable `f`.

  Nuevo en la versión 3.6.

`BUILD_LIST_UNPACK`(count)

  Esto es similar a `BUILD_TUPLE_UNPACK`, pero apila una lista en lugar de tupla. Implementa el desempaquetado iterable en los despliegues de lista `[*x, *y, *z]`.

  Nuevo en la versión 3.5.

`BUILD_SET_UNPACK`(count)

  Esto es similar a `BUILD_TUPLE_UNPACK`, pero apila un conjunto en lugar de tupla. Implementa el desempaquetado iterable en los despliegues de conjunto `{*x, *y, *z}`.

  Nuevo en la versión 3.5.

`BUILD_MAP_UNPACK`(count)

  Desapila count mapeos de la pila, los fusiona en un solo diccionario y apila el resultado. Implementa el desempaquetado del diccionario en las pantallas del diccionario `{**x, **y, **z}`.

  Nuevo en la versión 3.5.

`BUILD_MAP_UNPACK_WITH_CALL`(count)

  Esto es similar a `BUILD_MAP_UNPACK`, pero se usa para la sintaxis de llamada `f(**x, **y, **z)`. El elemento de la pila en la posición `count + 2` debe ser la correspondiente invocable `f`.

  Nuevo en la versión 3.5.

  Distinto en la versión 3.6: La posición del invocable se determina agregando 2 al argumento opcode en lugar de codificarlo en el segundo byte del argumento.

`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]`.

`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.

`POP_JUMP_IF_TRUE`(target)

  Si TOS es true, establece el contador de bytecode en target. TOS es desapilado (popped).

  Nuevo en la versión 3.1.

`POP_JUMP_IF_FALSE`(target)

  Si TOS es falso, establece el contador de bytecode en target. TOS es desapilado (popped).

  Nuevo en la versión 3.1.

`JUMP_IF_TRUE_OR_POP`(target)

  Si TOS es verdadero, establece el contador de bytecode en target y deja TOS en la pila. De lo contrario (TOS es falso), TOS se desapila.

  Nuevo en la versión 3.1.

`JUMP_IF_FALSE_OR_POP`(target)

  Si TOS es falso, establece el contador de bytecode en target y deja TOS en la pila. De lo contrario (TOS es verdadero), TOS se desapila.

  Nuevo en la versión 3.1.

`JUMP_ABSOLUTE`(target)

  Establezca el contador de bytecode en target.

`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 nombre global `co_names[namei]` en la pila.

`SETUP_FINALLY`(delta)

  Apila un bloque try de una cláusula try-finally o try-except en la pila de bloques. delta apunta al último bloque o al primero excepto el bloque.

`CALL_FINALLY`(delta)

  Apila la dirección de la siguiente instrucción en la pila e incrementa el contador de bytecode en delta. Se usa para llamar al bloque finalmente como una «subrutina».

  Nuevo en la versión 3.8.

`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.

`LOAD_CLOSURE`(i)

  Apila una referencia a la celda contenida en la ranura i de la celda y el almacenamiento variable libre. El nombre de la variable es `co_cellvars[i]` si i es menor que la longitud de co_cellvars. De lo contrario, es `co_freevars[i - len(co_cellvars)]`.

`LOAD_DEREF`(i)

  Carga la celda contenida en la ranura i de la celda y el almacenamiento variable libre. Apila una referencia al objeto que contiene la celda en la pila.

`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.

`STORE_DEREF`(i)

  Almacena TOS en la celda contenida en la ranura i de la celda y almacenamiento variable libre.

`DELETE_DEREF`(i)

  Vacía la celda contenida en la ranura i de la celda y el almacenamiento variable libre. Utilizado por la declaración `del`.

  Nuevo en la versión 3.2.

`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_FUNCTION`(argc)

  Llama a un objeto invocable con argumentos posicionales. argc indica el número de argumentos posicionales. La parte superior de la pila contiene argumentos posicionales, con el argumento más a la derecha en la parte superior. Debajo de los argumentos hay un objeto invocable para llamar. `CALL_FUNCTION` 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.

  Distinto en la versión 3.6: Este código de operación se usa solo para llamadas con argumentos posicionales.

`CALL_FUNCTION_KW`(argc)

  Llama a un objeto invocable con argumentos posicionales (si los hay) y palabras clave. argc indica el número total de argumentos posicionales y de palabras clave. El elemento superior en la pila contiene una tupla de nombres de argumentos de palabras clave. Debajo de eso hay argumentos de palabras clave en el orden correspondiente a la tupla. Debajo de eso hay argumentos posicionales, con el parámetro más a la derecha en la parte superior. Debajo de los argumentos hay un objeto invocable para llamar. `CALL_FUNCTION_KW` 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.

  Distinto en la versión 3.6: Los argumentos de palabras clave se empaquetan en una tupla en lugar de un diccionario, argc indica el número total de argumentos.

`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. Debajo de eso hay un objeto iterable que contiene argumentos posicionales y un objeto invocable para llamar. `BUILD_MAP_UNPACK_WITH_CALL` y `BUILD_TUPLE_UNPACK_WITH_CALL` puede usarse para fusionar múltiples objetos de mapeo e iterables que contienen argumentos. Antes de llamar al invocable, el objeto de mapeo y el objeto iterable se «desempaquetan» y sus contenidos se pasan como palabras 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 llamado `co_names[namei]` desde el objeto TOS. TOS aparece. Este bytecode distingue dos casos: si TOS tiene un método con el nombre correcto, el bytecode apila el método no vinculado y TOS. TOS se usará como primer argumento (`self`) por `CALL_METHOD` cuando se llama al método independiente. De lo contrario, `NULL` y el objeto retornado por la búsqueda de atributos son apilados.

  Nuevo en la versión 3.7.

`CALL_METHOD`(argc)

  Llama a un método. argc es el número de argumentos posicionales. Los argumentos de palabras clave no son compatibles. Este código de operación está diseñado para usarse con `LOAD_METHOD`. Los argumentos posicionales están en la parte superior de la pila. Debajo de ellos, los dos elementos descritos en `LOAD_METHOD` están en la pila (`self` y un objeto de método independiente o `NULL` y un invocable arbitrario). Todos ellos aparecen y se apila el valor de retorno.

  Nuevo en la versión 3.7.

`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` un diccionario de anotaciones

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

  - el código asociado con la función (en TOS1)

  - el nombre calificado de la función (en TOS)

`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.

`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.