"dis" --- Disassembler for Python bytecode
******************************************

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

Distinto en la versión 3.12: The argument of a jump is the offset of
the target instruction relative to the instruction that appears
immediately after the jump instruction's "CACHE" entries.As a
consequence, the presence of the "CACHE" instructions is transparent
for forward jumps but needs to be taken into account when reasoning
about backward jumps.

Example: Given the function "myfunc()":

   def myfunc(alist):
       return len(alist)

the following command can be used to display the disassembly of
"myfunc()":

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

     3           2 LOAD_GLOBAL              1 (NULL + len)
                12 LOAD_FAST                0 (alist)
                14 CALL                     1
                22 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] [infile]

The following options are accepted:

-h, --help

   Display usage and exit.

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

Added in version 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
   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.

   Added in version 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*).

   Added in version 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)

   Disassemble the *x* object.  *x* can denote either a module, a
   class, a method, a function, a generator, an asynchronous
   generator, a coroutine, a code object, a string of source code or a
   byte sequence of raw bytecode. For a module, it disassembles all
   functions. For a class, it disassembles all methods (including
   class and static methods). For a code object or sequence of raw
   bytecode, it prints one line per bytecode instruction. It also
   recursively disassembles nested code objects. These can include
   generator expressions, nested functions, the bodies of nested
   classes, and the code objects used for annotation scopes. Strings
   are first compiled to code objects with the "compile()" built-in
   function before being disassembled.  If no object is provided, this
   function disassembles the last traceback.

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

   Added in version 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.

   Added in version 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.

   Added in version 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

   Added in version 3.11.

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

**Instrucciones generales**

In the following, We will refer to the interpreter stack as "STACK"
and describe operations on it as if it was a Python list. The top of
the stack corresponds to "STACK[-1]" in this language.

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

   Removes the top-of-stack item:

      STACK.pop()

END_FOR

   Removes the top two values from the stack. Equivalent to "POP_TOP";
   "POP_TOP". Used to clean up at the end of loops, hence the name.

   Added in version 3.12.

END_SEND

   Implements "del STACK[-2]". Used to clean up when a generator
   exits.

   Added in version 3.12.

COPY(i)

   Push the i-th item to the top of the stack without removing it from
   its original location:

      assert i > 0
      STACK.append(STACK[-i])

   Added in version 3.11.

SWAP(i)

   Swap the top of the stack with the i-th element:

      STACK[-i], STACK[-1] = STACK[-1], STACK[-i]

   Added in version 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.

   Added in version 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_NEGATIVE

   Implements "STACK[-1] = -STACK[-1]".

UNARY_NOT

   Implements "STACK[-1] = not STACK[-1]".

UNARY_INVERT

   Implements "STACK[-1] = ~STACK[-1]".

GET_ITER

   Implements "STACK[-1] = iter(STACK[-1])".

GET_YIELD_FROM_ITER

   If "STACK[-1]" is a *generator iterator* or *coroutine* object it
   is left as is.  Otherwise, implements "STACK[-1] =
   iter(STACK[-1])".

   Added in version 3.5.

**Operaciones binarias e in situ**

Binary operations remove the top two items from the stack ("STACK[-1]"
and "STACK[-2]"). They perform the operation, then put the result back
on the stack.

In-place operations are like binary operations, but the operation is
done in-place when "STACK[-2]" supports it, and the resulting
"STACK[-1]" may be (but does not have to be) the original "STACK[-2]".

BINARY_OP(op)

   Implements the binary and in-place operators (depending on the
   value of *op*):

      rhs = STACK.pop()
      lhs = STACK.pop()
      STACK.append(lhs op rhs)

   Added in version 3.11.

BINARY_SUBSCR

   Implements:

      key = STACK.pop()
      container = STACK.pop()
      STACK.append(container[key])

STORE_SUBSCR

   Implements:

      key = STACK.pop()
      container = STACK.pop()
      value = STACK.pop()
      container[key] = value

DELETE_SUBSCR

   Implements:

      key = STACK.pop()
      container = STACK.pop()
      del container[key]

BINARY_SLICE

   Implements:

      end = STACK.pop()
      start = STACK.pop()
      container = STACK.pop()
      STACK.append(container[start:end])

   Added in version 3.12.

STORE_SLICE

   Implements:

      end = STACK.pop()
      start = STACK.pop()
      container = STACK.pop()
      values = STACK.pop()
      container[start:end] = value

   Added in version 3.12.

**Opcodes de corutinas**

GET_AWAITABLE(where)

   Implements "STACK[-1] = get_awaitable(STACK[-1])", where
   "get_awaitable(o)" returns "o" if "o" is a coroutine object or a
   generator object with the "CO_ITERABLE_COROUTINE" flag, or resolves
   "o.__await__".

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

      * "1": After a call to "__aenter__"

      * "2": After a call to "__aexit__"

   Added in version 3.5.

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

GET_AITER

   Implements "STACK[-1] = STACK[-1].__aiter__()".

   Added in version 3.5.

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

GET_ANEXT

   Implement "STACK.append(get_awaitable(STACK[-1].__anext__()))" to
   the stack. See "GET_AWAITABLE" for details about "get_awaitable".

   Added in version 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
   "STACK[-2]" and the raised exception in "STACK[-1]". Both are
   popped. If the exception is not "StopAsyncIteration", it is re-
   raised.

   Added in version 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.

CLEANUP_THROW

   Handles an exception raised during a "throw()" or "close()" call
   through the current frame.  If "STACK[-1]" is an instance of
   "StopIteration", pop three values from the stack and push its
   "value" member.  Otherwise, re-raise "STACK[-1]".

   Added in version 3.12.

BEFORE_ASYNC_WITH

   Resolves "__aenter__" and "__aexit__" from "STACK[-1]". Pushes
   "__aexit__" and result of "__aenter__()" to the stack:

      STACK.extend((__aexit__, __aenter__())

   Added in version 3.5.

**Opcodes misceláneos**

SET_ADD(i)

   Implements:

      item = STACK.pop()
      set.add(STACK[-i], item)

   Used to implement set comprehensions.

LIST_APPEND(i)

   Implements:

      item = STACK.pop()
      list.append(STACK[-i], item)

   Used to implement list comprehensions.

MAP_ADD(i)

   Implements:

      value = STACK.pop()
      key = STACK.pop()
      dict.__setitem__(STACK[-i], key, value)

   Used to implement dict comprehensions.

   Added in version 3.1.

   Distinto en la versión 3.8: Map value is "STACK[-1]" and map key is
   "STACK[-2]". Before, those were reversed.

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

   Returns with "STACK[-1]" to the caller of the function.

RETURN_CONST(consti)

   Returns with "co_consts[consti]" to the caller of the function.

   Added in version 3.12.

YIELD_VALUE

   Yields "STACK.pop()" from a *generator*.

   Distinto en la versión 3.11: oparg set to be the stack depth.

   Distinto en la versión 3.12: oparg set to be the exception block
   depth, for efficient closing of generators.

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.

   Added in version 3.6.

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.

   Added in version 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.

   Added in version 3.11.

CHECK_EXC_MATCH

   Performs exception matching for "except". Tests whether the
   "STACK[-2]" is an exception matching "STACK[-1]". Pops "STACK[-1]"
   and pushes the boolean result of the test.

   Added in version 3.11.

CHECK_EG_MATCH

   Performs exception matching for "except*". Applies
   "split(STACK[-1])" on the exception group representing "STACK[-2]".

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

   Added in version 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".

   Added in version 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".

   Added in version 3.9.

LOAD_BUILD_CLASS

   Pushes "builtins.__build_class__()" onto the stack.  It is later
   called to construct a class.

BEFORE_WITH

   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.

   Added in version 3.11.

GET_LEN

   Perform "STACK.append(len(STACK[-1]))".

   Added in version 3.10.

MATCH_MAPPING

   If "STACK[-1]" 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".

   Added in version 3.10.

MATCH_SEQUENCE

   If "STACK[-1]" 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".

   Added in version 3.10.

MATCH_KEYS

   "STACK[-1]" is a tuple of mapping keys, and "STACK[-2]" is the
   match subject. If "STACK[-2]" contains all of the keys in
   "STACK[-1]", push a "tuple" containing the corresponding values.
   Otherwise, push "None".

   Added in version 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 = STACK.pop()". *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)

   Unpacks "STACK[-1]" into *count* individual values, which are put
   onto the stack right-to-left. Require there to be exactly *count*
   values.:

      assert(len(STACK[-1]) == count)
      STACK.extend(STACK.pop()[:-count-1:-1])

UNPACK_EX(counts)

   Implements assignment with a starred target: Unpacks an iterable in
   "STACK[-1]" into individual values, where the total number of
   values can be smaller than the number of items in the iterable: one
   of the new values will be a list of all leftover items.

   The number of values before and after the list value is limited to
   255.

   The number of values before the list value is encoded in the
   argument of the opcode. The number of values after the list if any
   is encoded using an "EXTENDED_ARG". As a consequence, the argument
   can be seen as a two bytes values where the low byte of *counts* is
   the number of values before the list value, the high byte of
   *counts* the number of values after it.

   The extracted values are put onto the stack right-to-left, i.e. "a,
   *b, c = d" will be stored after execution as "STACK.extend((a, b,
   c))".

STORE_ATTR(namei)

   Implements:

      obj = STACK.pop()
      value = STACK.pop()
      obj.name = value

   where *namei* is the index of name in "co_names" of the code
   object.

DELETE_ATTR(namei)

   Implements:

      obj = STACK.pop()
      del obj.name

   where *namei* is the index of name 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)

   Pushes the value associated with "co_names[namei]" onto the stack.
   The name is looked up within the locals, then the globals, then the
   builtins.

LOAD_LOCALS

   Pushes a reference to the locals dictionary onto the stack.  This
   is used to prepare namespace dictionaries for
   "LOAD_FROM_DICT_OR_DEREF" and "LOAD_FROM_DICT_OR_GLOBALS".

   Added in version 3.12.

LOAD_FROM_DICT_OR_GLOBALS(i)

   Pops a mapping off the stack and looks up the value for
   "co_names[namei]". If the name is not found there, looks it up in
   the globals and then the builtins, similar to "LOAD_GLOBAL". This
   is used for loading global variables in annotation scopes within
   class bodies.

   Added in version 3.12.

BUILD_TUPLE(count)

   Creates a tuple consuming *count* items from the stack, and pushes
   the resulting tuple onto the stack.:

      assert count > 0
      STACK, values = STACK[:-count], STACK[-count:]
      STACK.append(tuple(values))

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)

   Pushes a new dictionary object onto the stack.  Pops "2 * count"
   items so that the dictionary holds *count* entries: "{...,
   STACK[-4]: STACK[-3], STACK[-2]: STACK[-1]}".

   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)

   The version of "BUILD_MAP" specialized for constant keys. Pops the
   top element on the stack which contains a tuple of keys, then
   starting from "STACK[-2]", pops *count* values to form values in
   the built dictionary.

   Added in version 3.6.

BUILD_STRING(count)

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

   Added in version 3.6.

LIST_EXTEND(i)

   Implements:

      seq = STACK.pop()
      list.extend(STACK[-i], seq)

   Used to build lists.

   Added in version 3.9.

SET_UPDATE(i)

   Implements:

      seq = STACK.pop()
      set.update(STACK[-i], seq)

   Used to build sets.

   Added in version 3.9.

DICT_UPDATE(i)

   Implements:

      map = STACK.pop()
      dict.update(STACK[-i], map)

   Used to build dicts.

   Added in version 3.9.

DICT_MERGE(i)

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

   Added in version 3.9.

LOAD_ATTR(namei)

   If the low bit of "namei" is not set, this replaces "STACK[-1]"
   with "getattr(STACK[-1], co_names[namei>>1])".

   If the low bit of "namei" is set, this will attempt to load a
   method named "co_names[namei>>1]" from the "STACK[-1]" object.
   "STACK[-1]" is popped. This bytecode distinguishes two cases: if
   "STACK[-1]" has a method with the correct name, the bytecode pushes
   the unbound method and "STACK[-1]". "STACK[-1]" will be used as the
   first argument ("self") by "CALL" when calling the unbound method.
   Otherwise, "NULL" and the object returned by the attribute lookup
   are pushed.

   Distinto en la versión 3.12: If the low bit of "namei" is set, then
   a "NULL" or "self" is pushed to the stack before the attribute or
   unbound method respectively.

LOAD_SUPER_ATTR(namei)

   This opcode implements "super()", both in its zero-argument and
   two-argument forms (e.g. "super().method()", "super().attr" and
   "super(cls, self).method()", "super(cls, self).attr").

   It pops three values from the stack (from top of stack down): -
   "self": the first argument to the current method -  "cls": the
   class within which the current method was defined -  the global
   "super"

   With respect to its argument, it works similarly to "LOAD_ATTR",
   except that "namei" is shifted left by 2 bits instead of 1.

   The low bit of "namei" signals to attempt a method load, as with
   "LOAD_ATTR", which results in pushing "NULL" and the loaded method.
   When it is unset a single value is pushed to the stack.

   The second-low bit of "namei", if set, means that this was a two-
   argument call to "super()" (unset means zero-argument).

   Added in version 3.12.

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.

   Added in version 3.9.

CONTAINS_OP(invert)

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

   Added in version 3.9.

IMPORT_NAME(namei)

   Imports the module "co_names[namei]".  "STACK[-1]" and "STACK[-2]"
   are popped and provide the *fromlist* and *level* arguments of
   "__import__()". The module object is pushed onto the stack.  The
   current namespace is not affected: for a proper import statement, a
   subsequent "STORE_FAST" instruction modifies the namespace.

IMPORT_FROM(namei)

   Loads the attribute "co_names[namei]" from the module found in
   "STACK[-1]". The resulting object is pushed onto the stack, to be
   subsequently stored by a "STORE_FAST" instruction.

JUMP_FORWARD(delta)

   Incrementa el contador de bytecode en *delta*.

JUMP_BACKWARD(delta)

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

   Added in version 3.11.

JUMP_BACKWARD_NO_INTERRUPT(delta)

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

   Added in version 3.11.

POP_JUMP_IF_TRUE(delta)

   If "STACK[-1]" is true, increments the bytecode counter by *delta*.
   "STACK[-1]" is popped.

   Distinto en la versión 3.11: The oparg is now a relative delta
   rather than an absolute target. This opcode is a pseudo-
   instruction, replaced in final bytecode by the directed versions
   (forward/backward).

   Distinto en la versión 3.12: This is no longer a pseudo-
   instruction.

POP_JUMP_IF_FALSE(delta)

   If "STACK[-1]" is false, increments the bytecode counter by
   *delta*. "STACK[-1]" is popped.

   Distinto en la versión 3.11: The oparg is now a relative delta
   rather than an absolute target. This opcode is a pseudo-
   instruction, replaced in final bytecode by the directed versions
   (forward/backward).

   Distinto en la versión 3.12: This is no longer a pseudo-
   instruction.

POP_JUMP_IF_NOT_NONE(delta)

   If "STACK[-1]" is not "None", increments the bytecode counter by
   *delta*. "STACK[-1]" is popped.

   This opcode is a pseudo-instruction, replaced in final bytecode by
   the directed versions (forward/backward).

   Added in version 3.11.

   Distinto en la versión 3.12: This is no longer a pseudo-
   instruction.

POP_JUMP_IF_NONE(delta)

   If "STACK[-1]" is "None", increments the bytecode counter by
   *delta*. "STACK[-1]" is popped.

   This opcode is a pseudo-instruction, replaced in final bytecode by
   the directed versions (forward/backward).

   Added in version 3.11.

   Distinto en la versión 3.12: This is no longer a pseudo-
   instruction.

FOR_ITER(delta)

   "STACK[-1]" is an *iterator*.  Call its "__next__()" method. If
   this yields a new value, push it on the stack (leaving the iterator
   below it).  If the iterator indicates it is exhausted then the byte
   code counter is incremented by *delta*.

   Distinto en la versión 3.12: Up until 3.11 the iterator was popped
   when it was exhausted.

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.

   Distinto en la versión 3.12: This opcode is now only used in
   situations where the local variable is guaranteed to be
   initialized. It cannot raise "UnboundLocalError".

LOAD_FAST_CHECK(var_num)

   Pushes a reference to the local "co_varnames[var_num]" onto the
   stack, raising an "UnboundLocalError" if the local variable has not
   been initialized.

   Added in version 3.12.

LOAD_FAST_AND_CLEAR(var_num)

   Pushes a reference to the local "co_varnames[var_num]" onto the
   stack (or pushes "NULL" onto the stack if the local variable has
   not been initialized) and sets "co_varnames[var_num]" to "NULL".

   Added in version 3.12.

STORE_FAST(var_num)

   Stores "STACK.pop()" into the 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.

   Added in version 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_FROM_DICT_OR_DEREF(i)

   Pops a mapping off the stack and looks up the name associated with
   slot "i" of the "fast locals" storage in this mapping. If the name
   is not found there, loads it from the cell contained in slot "i",
   similar to "LOAD_DEREF". This is used for loading free variables in
   class bodies (which previously used "LOAD_CLASSDEREF") and in
   annotation scopes within class bodies.

   Added in version 3.12.

STORE_DEREF(i)

   Stores "STACK.pop()" into the cell contained in slot "i" of the
   "fast locals" storage.

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

   Added in version 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.

   Added in version 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 STACK[-1]" (raise exception instance or type at
     "STACK[-1]")

   * 2: "raise STACK[-2] from STACK[-1]" (raise exception instance or
     type at "STACK[-2]" with "__cause__" set to "STACK[-1]")

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.

   Added in version 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.

   Added in version 3.6.

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.

   Added in version 3.11.

KW_NAMES(consti)

   Prefixes "CALL". Stores a reference to "co_consts[consti]" into an
   internal variable for use by "CALL". "co_consts[consti]" must be a
   tuple of strings.

   Added in version 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 "STACK[-1]")

   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 "STACK[-1]" was
   removed.

BUILD_SLICE(argc)

   Pushes a slice object on the stack.  *argc* must be 2 or 3.  If it
   is 2, implements:

      end = STACK.pop()
      start = STACK.pop()
      STACK.append(slice(start, stop))

   if it is 3, implements:

      step = STACK.pop()
      end = STACK.pop()
      start = STACK.pop()
      STACK.append(slice(start, end, step))

   See the "slice()" built-in function for more information.

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.

   Added in version 3.6.

MATCH_CLASS(count)

   "STACK[-1]" is a tuple of keyword attribute names, "STACK[-2]" is
   the class being matched against, and "STACK[-3]" is the match
   subject.  *count* is the number of positional sub-patterns.

   Pop "STACK[-1]", "STACK[-2]", and "STACK[-3]". If "STACK[-3]" is an
   instance of "STACK[-2]" and has the positional and keyword
   attributes required by *count* and "STACK[-1]", push a tuple of
   extracted attributes. Otherwise, push "None".

   Added in version 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" The start of a function, which is neither a generator,
     coroutine nor an async generator

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

   Added in version 3.11.

RETURN_GENERATOR

   Create a generator, coroutine, or async generator from the current
   frame. Used as first opcode of in code object for the above
   mentioned callables. Clear the current frame and return the newly
   created generator.

   Added in version 3.11.

SEND(delta)

   Equivalent to "STACK[-1] = STACK[-2].send(STACK[-1])". Used in
   "yield from" and "await" statements.

   If the call raises "StopIteration", pop the top value from the
   stack, push the exception's "value" attribute, and increment the
   bytecode counter by *delta*.

   Added in version 3.11.

HAVE_ARGUMENT

   This is not really an opcode.  It identifies the dividing line
   between opcodes in the range [0,255] which don't use their argument
   and those that do ("< HAVE_ARGUMENT" and ">= HAVE_ARGUMENT",
   respectively).

   If your application uses pseudo instructions, use the "hasarg"
   collection instead.

   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.

   Distinto en la versión 3.12: Pseudo instructions were added to the
   "dis" module, and for them it is not true that comparison with
   "HAVE_ARGUMENT" indicates whether they use their arg.

CALL_INTRINSIC_1

   Calls an intrinsic function with one argument. Passes "STACK[-1]"
   as the argument and sets "STACK[-1]" to the result. Used to
   implement functionality that is not performance critical.

   The operand determines which intrinsic function is called:

   +-------------------------------------+-------------------------------------+
   | Operand                             | Description                         |
   |=====================================|=====================================|
   | "INTRINSIC_1_INVALID"               | Not valid                           |
   +-------------------------------------+-------------------------------------+
   | "INTRINSIC_PRINT"                   | Prints the argument to standard     |
   |                                     | out. Used in the REPL.              |
   +-------------------------------------+-------------------------------------+
   | "INTRINSIC_IMPORT_STAR"             | Performs "import *" for the named   |
   |                                     | module.                             |
   +-------------------------------------+-------------------------------------+
   | "INTRINSIC_STOPITERATION_ERROR"     | Extracts the return value from a    |
   |                                     | "StopIteration" exception.          |
   +-------------------------------------+-------------------------------------+
   | "INTRINSIC_ASYNC_GEN_WRAP"          | Wraps an async generator value      |
   +-------------------------------------+-------------------------------------+
   | "INTRINSIC_UNARY_POSITIVE"          | Performs the unary "+" operation    |
   +-------------------------------------+-------------------------------------+
   | "INTRINSIC_LIST_TO_TUPLE"           | Converts a list to a tuple          |
   +-------------------------------------+-------------------------------------+
   | "INTRINSIC_TYPEVAR"                 | Creates a "typing.TypeVar"          |
   +-------------------------------------+-------------------------------------+
   | "INTRINSIC_PARAMSPEC"               | Creates a "typing.ParamSpec"        |
   +-------------------------------------+-------------------------------------+
   | "INTRINSIC_TYPEVARTUPLE"            | Creates a "typing.TypeVarTuple"     |
   +-------------------------------------+-------------------------------------+
   | "INTRINSIC_SUBSCRIPT_GENERIC"       | Returns "typing.Generic"            |
   |                                     | subscripted with the argument       |
   +-------------------------------------+-------------------------------------+
   | "INTRINSIC_TYPEALIAS"               | Creates a "typing.TypeAliasType";   |
   |                                     | used in the "type" statement. The   |
   |                                     | argument is a tuple of the type     |
   |                                     | alias's name, type parameters, and  |
   |                                     | value.                              |
   +-------------------------------------+-------------------------------------+

   Added in version 3.12.

CALL_INTRINSIC_2

   Calls an intrinsic function with two arguments. Used to implement
   functionality that is not performance critical:

      arg2 = STACK.pop()
      arg1 = STACK.pop()
      result = intrinsic2(arg1, arg2)
      STACK.push(result)

   The operand determines which intrinsic function is called:

   +------------------------------------------+-------------------------------------+
   | Operand                                  | Description                         |
   |==========================================|=====================================|
   | "INTRINSIC_2_INVALID"                    | Not valid                           |
   +------------------------------------------+-------------------------------------+
   | "INTRINSIC_PREP_RERAISE_STAR"            | Calculates the "ExceptionGroup" to  |
   |                                          | raise from a "try-except*".         |
   +------------------------------------------+-------------------------------------+
   | "INTRINSIC_TYPEVAR_WITH_BOUND"           | Creates a "typing.TypeVar" with a   |
   |                                          | bound.                              |
   +------------------------------------------+-------------------------------------+
   | "INTRINSIC_TYPEVAR_WITH_CONSTRAINTS"     | Creates a "typing.TypeVar" with     |
   |                                          | constraints.                        |
   +------------------------------------------+-------------------------------------+
   | "INTRINSIC_SET_FUNCTION_TYPE_PARAMS"     | Sets the "__type_params__"          |
   |                                          | attribute of a function.            |
   +------------------------------------------+-------------------------------------+

   Added in version 3.12.

**Pseudo-instructions**

These opcodes do not appear in Python bytecode. They are used by the
compiler but are replaced by real opcodes or removed before bytecode
is generated.

SETUP_FINALLY(target)

   Set up an exception handler for the following code block. If an
   exception occurs, the value stack level is restored to its current
   state and control is transferred to the exception handler at
   "target".

SETUP_CLEANUP(target)

   Like "SETUP_FINALLY", but in case of an exception also pushes the
   last instruction ("lasti") to the stack so that "RERAISE" can
   restore it. If an exception occurs, the value stack level and the
   last instruction on the frame are restored to their current state,
   and control is transferred to the exception handler at "target".

SETUP_WITH(target)

   Like "SETUP_CLEANUP", but in case of an exception one more item is
   popped from the stack before control is transferred to the
   exception handler at "target".

   This variant is used in "with" and "async with" constructs, which
   push the return value of the context manager's "__enter__()" or
   "__aenter__()" to the stack.

POP_BLOCK

   Marks the end of the code block associated with the last
   "SETUP_FINALLY", "SETUP_CLEANUP" or "SETUP_WITH".

JUMP

JUMP_NO_INTERRUPT

   Undirected relative jump instructions which are replaced by their
   directed (forward/backward) counterparts by the assembler.

LOAD_METHOD

   Optimized unbound method lookup. Emitted as a "LOAD_ATTR" opcode
   with a flag set in the arg.


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

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

Distinto en la versión 3.12: The collections now contain pseudo
instructions and instrumented instructions as well. These are opcodes
with values ">= MIN_PSEUDO_OPCODE" and ">= MIN_INSTRUMENTED_OPCODE".

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

   Sequence of bytecodes that use their argument.

   Added in version 3.12.

dis.hasconst

   Secuencia de bytecodes que acceden a una constante.

dis.hasfree

   Sequence of bytecodes that access a free variable. 'free' in this
   context refers to names in the current scope that are referenced by
   inner scopes or names in outer scopes that are referenced from this
   scope.  It does *not* include references to global or builtin
   scopes.

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.

dis.hasexc

   Sequence of bytecodes that set an exception handler.

   Added in version 3.12.
