"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: The argument of jump, exception handling
and loop instructions is now the instruction offset rather than the
byte offset.

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)

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

   Eleva los elementos de la segunda, tercera y cuarta pila una
   posición hacia arriba, se mueve de arriba hacia abajo a la posición
   cuatro.

   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

   Pushes "get_awaitable(TOS.__anext__())" to the stack.  See
   "GET_AWAITABLE" for details about "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)

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

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.

RERAISE

   Re-lanza la excepción que se encuentra actualmente al tope de la
   pila. Si oparg no es cero, restaura "f_lasti" del marco actual a su
   valor cuando se lanza la excepción.

   Nuevo en la versión 3.9.

WITH_EXCEPT_START

   Llama a la función en la posición 7 de la pila con los tres
   elementos superiores de la pila como argumentos. Se usa 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.

LOAD_ASSERTION_ERROR

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

   Nuevo en la versión 3.9.

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_EXCEPT_START". Luego, "__enter__()" se llama, y un bloque
   finally que apunta a *delta* se apila. 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.

COPY_DICT_WITHOUT_KEYS

   TOS es una tuple de llaves de mapeo, y TOS1 es el sujeto de la
   coincidencia. Reemplaza TOS con un "dict" formado por los ítems de
   TOS1, pero sin ninguna de las llaves en TOS.

   Nuevo en la versión 3.10.

GET_LEN

   Apila "len(TOS)" en la pila.

   Nuevo en la versión 3.10.

MATCH_MAPPING

   Si TOS es una instancia de "collections.abc.Mapping" (o, más
   técnicamente, si tiene el indicador "Py_TPFLAGS_MAPPING"
   establecido en su "tp_flags"), apila "True" en la pila. De lo
   contrario apila "False".

   Nuevo en la versión 3.10.

MATCH_SEQUENCE

   Si TOS es una instancia de "collections.abc.Sequence" y *no* es una
   instancia de "str"/"bytes"/"bytearray" (o, más técnicamente, si
   tiene el indicador "Py_TPFLAGS_SEQUENCE"  establecido en su
   "tp_flags"), apila "True" en la pila. De lo contrario apila
   "False".

   Nuevo en la versión 3.10.

MATCH_KEYS

   TOS es una tuple de llaves de mapeo, y TOS1 es el sujeto de la
   coincidencia. Si TOS1 contiene todas las llaves en TOS, apila un
   "tuple" que contiene los valores correspondientes, seguido por
   "True". De lo contrario apila "None", seguido de "False".

   Nuevo en la versión 3.10.

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.

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

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

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_NOT_EXC_MATCH(target)

   Comprueba si el segundo valor de la pila es una excepción que
   coincide con el TOS y salta si no lo es. Saca dos valores de la
   pila.

   Nuevo en la versión 3.9.

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.

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 de la pila
   contiene una tupla con los nombres de los argumentos de la palabra
   clave, que deben ser cadenas de caracteres. Debajo están los
   valores para los argumentos de la palabra clave, en el orden
   correspondiente a la tupla. Debajo están los 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. 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 devuelto 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" 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*)

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

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

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

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.

   Desapila TOS. Si TOS2 es una instancia de TOS1 y tiene los
   atributos clave y posicionales requeridos por *count* y TOS,
   establece TOS como "True" y TOS1 es una tupla de atributos
   extraídos. De lo contrario, establece TOS como "False".

   Nuevo en la versión 3.10.

GEN_START(kind)

      Pops TOS. The "kind" operand corresponds to the type of
      generator or coroutine. The legal kinds are 0 for generator, 1
      for coroutine, and 2 for async generator.

   Nuevo en la versión 3.10.

ROT_N(count)

   Eleva los *count* elementos más altos de la pila una posición hacia
   arriba, y baja TOS hacia la posición *count*.

   Nuevo en la versión 3.10.

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.
