"dis" --- Desensamblador para bytecode de Python
************************************************

**Código fuente:** Lib/dis.py

======================================================================

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

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

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

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

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

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

   def myfunc(alist):
       return len(alist)

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

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

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

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


Command-line interface
======================

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

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

The following options are accepted:

-h, --help

   Display usage and exit.

-C, --show-caches

   Show inline caches.

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


Análisis de bytecode
====================

Nuevo en la versión 3.4.

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

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

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

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

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

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

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

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

   classmethod from_traceback(tb, *, show_caches=False)

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

   codeobj

      El objeto de código compilado.

   first_line

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

   dis()

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

   info()

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

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

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

Ejemplo:

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


Funciones de análisis
=====================

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

dis.code_info(x)

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

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

   Nuevo en la versión 3.2.

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

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

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

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

   Nuevo en la versión 3.2.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   6. parámetros de operación, y

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

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

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

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

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

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

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

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

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

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

   Nuevo en la versión 3.4.

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

dis.findlinestarts(code)

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

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

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

dis.findlabels(code)

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

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

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

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

   Nuevo en la versión 3.4.

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


Instrucciones bytecode de Python
================================

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

class dis.Instruction

   Detalles para una operación de bytecode

   opcode

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

   opname

      nombre legible por humanos para la operación

   arg

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

   argval

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

   argrepr

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

   offset

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

   starts_line

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

   is_jump_target

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

   positions

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

   Nuevo en la versión 3.4.

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

class dis.Positions

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

   lineno

   end_lineno

   col_offset

   end_col_offset

   Nuevo en la versión 3.11.

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

**Instrucciones generales**

NOP

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

POP_TOP

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

COPY(i)

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

   Nuevo en la versión 3.11.

SWAP(i)

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

   Nuevo en la versión 3.11.

CACHE

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

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

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

   Nuevo en la versión 3.11.

**Operaciones unarias**

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

UNARY_POSITIVE

   Implementa "TOS = +TOS".

UNARY_NEGATIVE

   Implementa "TOS = -TOS".

UNARY_NOT

   Implementa "TOS = not TOS".

UNARY_INVERT

   Implementa "TOS = ~TOS".

GET_ITER

   Implementa "TOS = iter(TOS)".

GET_YIELD_FROM_ITER

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

   Nuevo en la versión 3.5.

**Operaciones binarias e in situ**

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

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

BINARY_OP(op)

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

   Nuevo en la versión 3.11.

BINARY_SUBSCR

   Implementa "TOS = TOS1[TOS]".

STORE_SUBSCR

   Implementa "TOS1[TOS] = TOS2".

DELETE_SUBSCR

   Implementa "del TOS1[TOS]".

**Opcodes de corutinas**

GET_AWAITABLE(where)

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

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

      * "1" Después de una llamada a "__aenter__"

      * "2" Después de una llamada a "__aexit__"

   Nuevo en la versión 3.5.

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

GET_AITER

   Implementa "TOS = TOS.__aiter__()".

   Nuevo en la versión 3.5.

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

GET_ANEXT

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

   Nuevo en la versión 3.5.

END_ASYNC_FOR

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

   Nuevo en la versión 3.8.

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

BEFORE_ASYNC_WITH

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

   Nuevo en la versión 3.5.

**Opcodes misceláneos**

PRINT_EXPR

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

SET_ADD(i)

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

LIST_APPEND(i)

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

MAP_ADD(i)

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

   Nuevo en la versión 3.1.

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

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

RETURN_VALUE

   Retorna con TOS a quien llama la función.

YIELD_VALUE

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

SETUP_ANNOTATIONS

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

   Nuevo en la versión 3.6.

IMPORT_STAR

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

POP_EXCEPT

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

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

RERAISE

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

   Nuevo en la versión 3.9.

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

PUSH_EXC_INFO

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

   Nuevo en la versión 3.11.

CHECK_EXC_MATCH

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

   Nuevo en la versión 3.11.

CHECK_EG_MATCH

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

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

   Nuevo en la versión 3.11.

PREP_RERAISE_STAR

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

   Nuevo en la versión 3.11.

WITH_EXCEPT_START

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

   Nuevo en la versión 3.9.

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

LOAD_ASSERTION_ERROR

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

   Nuevo en la versión 3.9.

LOAD_BUILD_CLASS

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

BEFORE_WITH(delta)

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

   Nuevo en la versión 3.11.

GET_LEN

   Apila "len(TOS)" en la pila.

   Nuevo en la versión 3.10.

MATCH_MAPPING

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

   Nuevo en la versión 3.10.

MATCH_SEQUENCE

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

   Nuevo en la versión 3.10.

MATCH_KEYS

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

   Nuevo en la versión 3.10.

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

STORE_NAME(namei)

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

DELETE_NAME(namei)

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

UNPACK_SEQUENCE(count)

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

UNPACK_EX(counts)

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

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

STORE_ATTR(namei)

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

DELETE_ATTR(namei)

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

STORE_GLOBAL(namei)

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

DELETE_GLOBAL(namei)

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

LOAD_CONST(consti)

   Apila "co_consts[consti]" en la pila.

LOAD_NAME(namei)

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

BUILD_TUPLE(count)

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

BUILD_LIST(count)

   Funciona como "BUILD_TUPLE", pero crea una lista.

BUILD_SET(count)

   Funciona como "BUILD_TUPLE", pero crea un conjunto.

BUILD_MAP(count)

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

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

BUILD_CONST_KEY_MAP(count)

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

   Nuevo en la versión 3.6.

BUILD_STRING(count)

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

   Nuevo en la versión 3.6.

LIST_TO_TUPLE

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

   Nuevo en la versión 3.9.

LIST_EXTEND(i)

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

   Nuevo en la versión 3.9.

SET_UPDATE(i)

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

   Nuevo en la versión 3.9.

DICT_UPDATE(i)

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

   Nuevo en la versión 3.9.

DICT_MERGE(i)

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

   Nuevo en la versión 3.9.

LOAD_ATTR(namei)

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

COMPARE_OP(opname)

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

IS_OP(invert)

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

   Nuevo en la versión 3.9.

CONTAINS_OP(invert)

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

   Nuevo en la versión 3.9.

IMPORT_NAME(namei)

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

IMPORT_FROM(namei)

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

JUMP_FORWARD(delta)

   Incrementa el contador de bytecode en *delta*.

JUMP_BACKWARD(delta)

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

   Nuevo en la versión 3.11.

JUMP_BACKWARD_NO_INTERRUPT(delta)

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

   Nuevo en la versión 3.11.

POP_JUMP_FORWARD_IF_TRUE(delta)

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

   Nuevo en la versión 3.11.

POP_JUMP_BACKWARD_IF_TRUE(delta)

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

   Nuevo en la versión 3.11.

POP_JUMP_FORWARD_IF_FALSE(delta)

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

   Nuevo en la versión 3.11.

POP_JUMP_BACKWARD_IF_FALSE(delta)

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

   Nuevo en la versión 3.11.

POP_JUMP_FORWARD_IF_NOT_NONE(delta)

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

   Nuevo en la versión 3.11.

POP_JUMP_BACKWARD_IF_NOT_NONE(delta)

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

   Nuevo en la versión 3.11.

POP_JUMP_FORWARD_IF_NONE(delta)

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

   Nuevo en la versión 3.11.

POP_JUMP_BACKWARD_IF_NONE(delta)

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

   Nuevo en la versión 3.11.

JUMP_IF_TRUE_OR_POP(delta)

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

   Nuevo en la versión 3.1.

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

JUMP_IF_FALSE_OR_POP(delta)

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

   Nuevo en la versión 3.1.

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

FOR_ITER(delta)

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

LOAD_GLOBAL(namei)

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

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

LOAD_FAST(var_num)

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

STORE_FAST(var_num)

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

DELETE_FAST(var_num)

   Elimina la "co_varnames[var_num]" local.

MAKE_CELL(i)

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

   Nuevo en la versión 3.11.

LOAD_CLOSURE(i)

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

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

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

LOAD_DEREF(i)

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

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

LOAD_CLASSDEREF(i)

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

   Nuevo en la versión 3.4.

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

STORE_DEREF(i)

   Almacena TOS en la celda contenida en la ranura "i" del
   almacenamiento "locales rápidos".

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

DELETE_DEREF(i)

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

   Nuevo en la versión 3.2.

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

COPY_FREE_VARS(n)

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

   Nuevo en la versión 3.11.

RAISE_VARARGS(argc)

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

   * 0: "raise" (vuelve a lanzar la excepción anterior)

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

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

CALL(argc)

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

   * NULL

   * El llamable

   * Los argumentos posicionales

   * Los argumentos nombrados

   o:

   * El llamable

   * "self"

   * Los argumentos posicionales restantes

   * Los argumentos nombrados

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

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

   Nuevo en la versión 3.11.

CALL_FUNCTION_EX(flags)

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

   Nuevo en la versión 3.6.

LOAD_METHOD(namei)

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

   Nuevo en la versión 3.7.

PRECALL(argc)

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

   Nuevo en la versión 3.11.

PUSH_NULL

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

   Nuevo en la versión 3.11.

KW_NAMES(i)

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

   Nuevo en la versión 3.11.

MAKE_FUNCTION(flags)

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

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

   * "0x02" un diccionario de valores predeterminados de solo palabras
     clave

   * "0x04" una tupla de cadenas de caracteres que contiene
     anotaciones de parámetros

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

   * the code associated with the function (at TOS)

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

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

BUILD_SLICE(argc)

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

EXTENDED_ARG(ext)

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

FORMAT_VALUE(flags)

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

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

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

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

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

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

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

   Nuevo en la versión 3.6.

MATCH_CLASS(count)

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

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

   Nuevo en la versión 3.10.

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

RESUME(where)

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

      El operando "where" marca dónde ocurre el "RESUME":

      * "0" El comienzo de una función

      * "1" Después de una expresión "yield"

      * "2" Después de una expresión "yield from"

      * "3" Después de una expresión "await"

   Nuevo en la versión 3.11.

RETURN_GENERATOR

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

   Nuevo en la versión 3.11.

SEND

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

   Nuevo en la versión 3.11.

ASYNC_GEN_WRAP

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

   Nuevo en la versión 3.11.

HAVE_ARGUMENT

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

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


Colecciones opcode
==================

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

dis.opname

   Secuencia de nombres de operaciones, indexable utilizando el
   bytecode.

dis.opmap

   Nombres de operaciones de mapeo de diccionario a bytecodes.

dis.cmp_op

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

dis.hasconst

   Secuencia de bytecodes que acceden a una constante.

dis.hasfree

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

dis.hasname

   Secuencia de bytecodes que acceden a un atributo por nombre.

dis.hasjrel

   Secuencia de bytecodes que tienen un objetivo de salto relativo.

dis.hasjabs

   Secuencia de bytecodes que tienen un objetivo de salto absoluto.

dis.haslocal

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

dis.hascompare

   Secuencia de bytecodes de operaciones booleanas.
