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