dis.po

# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# Maintained by the python-doc-es workteam.
# docs-es@python.org /
# https://mail.python.org/mailman3/lists/docs-es.python.org/
# Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to
# get the list of volunteers
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-11-21 16:38-0300\n"
"PO-Revision-Date: 2024-11-24 19:55+0100\n"
"Last-Translator: Cristián Maureira-Fredes <cmaureirafredes@gmail.com>\n"
"Language-Team: python-doc-es\n"
"Language: es\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"Generated-By: Babel 2.16.0\n"
"X-Generator: Poedit 3.4.2\n"

#: ../Doc/library/dis.rst:2
msgid ":mod:`!dis` --- Disassembler for Python bytecode"
msgstr ":mod:`!dis` --- Desensamblador para bytecode de Python"

#: ../Doc/library/dis.rst:7
msgid "**Source code:** :source:`Lib/dis.py`"
msgstr "**Código fuente:** :source:`Lib/dis.py`"

#: ../Doc/library/dis.rst:17
msgid ""
"The :mod:`dis` module supports the analysis of CPython :term:`bytecode` by "
"disassembling it. The CPython bytecode which this module takes as an input "
"is defined in the file :file:`Include/opcode.h` and used by the compiler and "
"the interpreter."
msgstr ""
"El módulo :mod:`dis` admite el análisis de CPython :term:`bytecode` al "
"desarmarlo. El bytecode de CPython que este módulo toma como entrada se "
"define en el archivo :file:`Include/opcode.h` y lo utilizan el compilador y "
"el intérprete."

#: ../Doc/library/dis.rst:24
msgid ""
"Bytecode is an implementation detail of the CPython interpreter.  No "
"guarantees are made that bytecode will not be added, removed, or changed "
"between versions of Python.  Use of this module should not be considered to "
"work across Python VMs or Python releases."
msgstr ""
"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."

#: ../Doc/library/dis.rst:29
msgid ""
"Use 2 bytes for each instruction. Previously the number of bytes varied by "
"instruction."
msgstr ""
"Use 2 bytes para cada instrucción. Anteriormente, el número de bytes variaba "
"según la instrucción."

#: ../Doc/library/dis.rst:33
msgid ""
"The argument of jump, exception handling and loop instructions is now the "
"instruction offset rather than the byte offset."
msgstr ""
"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."

#: ../Doc/library/dis.rst:37
msgid ""
"Some instructions are accompanied by one or more inline cache entries, which "
"take the form of :opcode:`CACHE` instructions. These instructions are hidden "
"by default, but can be shown by passing ``show_caches=True`` to any :mod:"
"`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``."
msgstr ""
"Algunas instrucciones están acompañadas de una o más entradas de caché en "
"línea, que toman la forma de instrucciones :opcode:`CACHE`. Estas "
"instrucciones están ocultas de forma predeterminada, pero se pueden mostrar "
"al pasar ``show_caches=True`` a cualquier utilidad :mod:`dis`. Además, el "
"intérprete ahora adapta el código de bytes para especializarlo en diferentes "
"condiciones de ejecución. El código de bytes adaptativo se puede mostrar al "
"pasar ``adaptive=True``."

#: ../Doc/library/dis.rst:45
msgid ""
"The argument of a jump is the offset of the target instruction relative to "
"the instruction that appears immediately after the jump instruction's :"
"opcode:`CACHE` entries."
msgstr ""
"El argumento de un salto es el desplazamiento de la instrucción de destino "
"en relación con la instrucción que aparece inmediatamente después de las "
"entradas :opcode:`CACHE` de la instrucción de salto."

#: ../Doc/library/dis.rst:50
msgid ""
"As a consequence, the presence of the :opcode:`CACHE` instructions is "
"transparent for forward jumps but needs to be taken into account when "
"reasoning about backward jumps."
msgstr ""
"Como consecuencia, la presencia de las instrucciones :opcode:`CACHE` es "
"transparente para los saltos hacia adelante, pero debe tenerse en cuenta al "
"razonar sobre los saltos hacia atrás."

#: ../Doc/library/dis.rst:54
msgid ""
"The output shows logical labels rather than instruction offsets for jump "
"targets and exception handlers. The ``-O`` command line option and the "
"``show_offsets`` argument were added."
msgstr ""
"La salida muestra etiquetas lógicas en lugar de desplazamientos de "
"instrucciones para destinos de salto y controladores de excepciones. Se "
"agregaron la opción de línea de comandos ``-O`` y el argumento "
"``show_offsets``."

#: ../Doc/library/dis.rst:59
msgid "Example: Given the function :func:`!myfunc`::"
msgstr "Ejemplo: Dada la función :func:`!myfunc`::"

#: ../Doc/library/dis.rst:61
msgid ""
"def myfunc(alist):\n"
"    return len(alist)"
msgstr ""
"def myfunc(alist):\n"
"    return len(alist)"

#: ../Doc/library/dis.rst:64
msgid ""
"the following command can be used to display the disassembly of :func:`!"
"myfunc`:"
msgstr ""
"El siguiente comando se puede utilizar para mostrar el desmontaje de :func:`!"
"myfunc`:"

#: ../Doc/library/dis.rst:67
msgid ""
">>> dis.dis(myfunc)\n"
"  2           RESUME                   0\n"
"\n"
"  3           LOAD_GLOBAL              1 (len + NULL)\n"
"              LOAD_FAST                0 (alist)\n"
"              CALL                     1\n"
"              RETURN_VALUE"
msgstr ""
">>> dis.dis(myfunc)\n"
"  2           RESUME                   0\n"
"\n"
"  3           LOAD_GLOBAL              1 (len + NULL)\n"
"              LOAD_FAST                0 (alist)\n"
"              CALL                     1\n"
"              RETURN_VALUE"

#: ../Doc/library/dis.rst:77
msgid "(The \"2\" is a line number)."
msgstr "(El \"2\" es un número de línea)."

#: ../Doc/library/dis.rst:82
msgid "Command-line interface"
msgstr "Interfaz de línea de comandos"

#: ../Doc/library/dis.rst:84
msgid "The :mod:`dis` module can be invoked as a script from the command line:"
msgstr ""
"El módulo :mod:`dis` se puede invocar como un script desde la línea de "
"comandos:"

#: ../Doc/library/dis.rst:86
msgid "python -m dis [-h] [-C] [-O] [infile]"
msgstr "python -m dis [-h] [-C] [-O] [infile]"

#: ../Doc/library/dis.rst:90
msgid "The following options are accepted:"
msgstr "Se aceptan las siguientes opciones:"

#: ../Doc/library/dis.rst:96
msgid "Display usage and exit."
msgstr "Mostrar uso y salir."

#: ../Doc/library/dis.rst:100
msgid "Show inline caches."
msgstr "Mostrar cachés en línea."

#: ../Doc/library/dis.rst:104
msgid "Show offsets of instructions."
msgstr "Mostrar desplazamientos de instrucciones."

#: ../Doc/library/dis.rst:106
msgid ""
"If :file:`infile` is specified, its disassembled code will be written to "
"stdout. Otherwise, disassembly is performed on compiled source code received "
"from stdin."
msgstr ""
"Si se especifica :file:`infile`, su código desensamblado se escribirá en la "
"salida estándar. De lo contrario, el desensamblado se realiza en el código "
"fuente compilado recibido de la entrada estándar."

#: ../Doc/library/dis.rst:110
msgid "Bytecode analysis"
msgstr "Análisis de bytecode"

#: ../Doc/library/dis.rst:114
msgid ""
"The bytecode analysis API allows pieces of Python code to be wrapped in a :"
"class:`Bytecode` object that provides easy access to details of the compiled "
"code."
msgstr ""
"La API de análisis de bytecode permite que partes del código Python se "
"envuelvan en un objeto :class:`Bytecode` que proporciona un fácil acceso a "
"los detalles del código compilado."

#: ../Doc/library/dis.rst:121
msgid ""
"Analyse the bytecode corresponding to a function, generator, asynchronous "
"generator, coroutine, method, string of source code, or a code object (as "
"returned by :func:`compile`)."
msgstr ""
"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 :func:`compile`)."

#: ../Doc/library/dis.rst:125
msgid ""
"This is a convenience wrapper around many of the functions listed below, "
"most notably :func:`get_instructions`, as iterating over a :class:`Bytecode` "
"instance yields the bytecode operations as :class:`Instruction` instances."
msgstr ""
"Este es un contenedor conveniente para muchas de las funciones enumeradas a "
"continuación, en particular :func:`get_instructions`, ya que iterar sobre "
"una instancia de :class:`Bytecode` produce las operaciones de bytecode como "
"instancias de :class:`Instruction`."

#: ../Doc/library/dis.rst:129 ../Doc/library/dis.rst:326
msgid ""
"If *first_line* is not ``None``, it indicates the line number that should be "
"reported for the first source line in the disassembled code.  Otherwise, the "
"source line information (if any) is taken directly from the disassembled "
"code object."
msgstr ""
"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."

#: ../Doc/library/dis.rst:134
msgid ""
"If *current_offset* is not ``None``, it refers to an instruction offset in "
"the disassembled code. Setting this means :meth:`.dis` will display a "
"\"current instruction\" marker against the specified opcode."
msgstr ""
"Si *current_offset* no es ``None``, se refiere a un desplazamiento de "
"instrucción en el código desmontado. Establecer esto significa :meth:`.dis` "
"mostrará un marcador de \"instrucción actual\" contra el código de operación "
"especificado."

#: ../Doc/library/dis.rst:138
msgid ""
"If *show_caches* is ``True``, :meth:`.dis` will display inline cache entries "
"used by the interpreter to specialize the bytecode."
msgstr ""
"Si *show_caches* es ``True``, :meth:`.dis` mostrará las entradas de caché en "
"línea utilizadas por el intérprete para especializar el código de bytes."

#: ../Doc/library/dis.rst:141
msgid ""
"If *adaptive* is ``True``, :meth:`.dis` will display specialized bytecode "
"that may be different from the original bytecode."
msgstr ""
"Si *adaptive* es ``True``, :meth:`.dis` mostrará un código de bytes "
"especializado que puede ser diferente del código de bytes original."

#: ../Doc/library/dis.rst:144
msgid ""
"If *show_offsets* is ``True``, :meth:`.dis` will include instruction offsets "
"in the output."
msgstr ""
"Si *show_offsets* es ``True``, :meth:`.dis` incluirá desplazamientos de "
"instrucciones en la salida."

#: ../Doc/library/dis.rst:149
msgid ""
"Construct a :class:`Bytecode` instance from the given traceback, setting "
"*current_offset* to the instruction responsible for the exception."
msgstr ""
"Construye una instancia de :class:`Bytecode` a partir del *traceback* dado, "
"estableciendo *current_offset* en la instrucción responsable de la excepción."

#: ../Doc/library/dis.rst:154
msgid "The compiled code object."
msgstr "El objeto de código compilado."

#: ../Doc/library/dis.rst:158
msgid "The first source line of the code object (if available)"
msgstr "La primera línea de origen del objeto de código (si está disponible)"

#: ../Doc/library/dis.rst:162
msgid ""
"Return a formatted view of the bytecode operations (the same as printed by :"
"func:`dis.dis`, but returned as a multi-line string)."
msgstr ""
"Retorna una vista formateada de las operaciones de bytecode (lo mismo que "
"impreso por :func:`dis.dis`, pero retornado como una cadena de caracteres "
"multilínea)."

#: ../Doc/library/dis.rst:167
msgid ""
"Return a formatted multi-line string with detailed information about the "
"code object, like :func:`code_info`."
msgstr ""
"Retorna una cadena de caracteres multilínea formateada con información "
"detallada sobre el objeto de código, como :func:`code_info`."

#: ../Doc/library/dis.rst:170 ../Doc/library/dis.rst:210
#: ../Doc/library/dis.rst:262
msgid "This can now handle coroutine and asynchronous generator objects."
msgstr ""
"Esto ahora puede manejar objetos generadores asíncronos y de corutinas."

#: ../Doc/library/dis.rst:173 ../Doc/library/dis.rst:265
#: ../Doc/library/dis.rst:282 ../Doc/library/dis.rst:312
#: ../Doc/library/dis.rst:335
msgid "Added the *show_caches* and *adaptive* parameters."
msgstr "Se agregaron los parámetros *show_caches* y *adaptive*."

#: ../Doc/library/dis.rst:176
msgid "Example:"
msgstr "Ejemplo:"

#: ../Doc/library/dis.rst:178
msgid ""
">>> bytecode = dis.Bytecode(myfunc)\n"
">>> for instr in bytecode:\n"
"...     print(instr.opname)\n"
"...\n"
"RESUME\n"
"LOAD_GLOBAL\n"
"LOAD_FAST\n"
"CALL\n"
"RETURN_VALUE"
msgstr ""
">>> bytecode = dis.Bytecode(myfunc)\n"
">>> for instr in bytecode:\n"
"...     print(instr.opname)\n"
"...\n"
"RESUME\n"
"LOAD_GLOBAL\n"
"LOAD_FAST\n"
"CALL\n"
"RETURN_VALUE"

#: ../Doc/library/dis.rst:192
msgid "Analysis functions"
msgstr "Funciones de análisis"

#: ../Doc/library/dis.rst:194
msgid ""
"The :mod:`dis` module also defines the following analysis functions that "
"convert the input directly to the desired output. They can be useful if only "
"a single operation is being performed, so the intermediate analysis object "
"isn't useful:"
msgstr ""
"El módulo :mod:`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:"

#: ../Doc/library/dis.rst:200
msgid ""
"Return a formatted multi-line string with detailed code object information "
"for the supplied function, generator, asynchronous generator, coroutine, "
"method, source code string or code object."
msgstr ""
"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."

#: ../Doc/library/dis.rst:204
msgid ""
"Note that the exact contents of code info strings are highly implementation "
"dependent and they may change arbitrarily across Python VMs or Python "
"releases."
msgstr ""
"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."

#: ../Doc/library/dis.rst:216
msgid ""
"Print detailed code object information for the supplied function, method, "
"source code string or code object to *file* (or ``sys.stdout`` if *file* is "
"not specified)."
msgstr ""
"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)."

#: ../Doc/library/dis.rst:220
msgid ""
"This is a convenient shorthand for ``print(code_info(x), file=file)``, "
"intended for interactive exploration at the interpreter prompt."
msgstr ""
"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*)."

#: ../Doc/library/dis.rst:225 ../Doc/library/dis.rst:256
#: ../Doc/library/dis.rst:279 ../Doc/library/dis.rst:309
msgid "Added *file* parameter."
msgstr "Agrega un parámetro *file*."

#: ../Doc/library/dis.rst:231
msgid ""
"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 :ref:`annotation scopes <annotation-scopes>`. Strings are "
"first compiled to code objects with the :func:`compile` built-in function "
"before being disassembled.  If no object is provided, this function "
"disassembles the last traceback."
msgstr ""
"Desensamblar el objeto *x*. *x* puede denotar un módulo, una clase, un "
"método, una función, un generador, un generador asincrónico, una corrutina, "
"un objeto de código, una cadena de código fuente o una secuencia de bytes de "
"código de bytes sin formato. Para un módulo, desensamblar todas las "
"funciones. Para una clase, desensamblar todos los métodos (incluidos los "
"métodos de clase y estáticos). Para un objeto de código o una secuencia de "
"código de bytes sin formato, imprime una línea por cada instrucción de "
"código de bytes. También desensamblar de forma recursiva objetos de código "
"anidados. Estos pueden incluir expresiones de generador, funciones anidadas, "
"los cuerpos de clases anidadas y los objetos de código utilizados para :ref:"
"`annotation scopes <annotation-scopes>`. Las cadenas se compilan primero en "
"objetos de código con la función incorporada :func:`compile` antes de "
"desensamblarse. Si no se proporciona ningún objeto, esta función "
"desensamblará el último seguimiento."

#: ../Doc/library/dis.rst:244 ../Doc/library/dis.rst:276
#: ../Doc/library/dis.rst:306
msgid ""
"The disassembly is written as text to the supplied *file* argument if "
"provided and to ``sys.stdout`` otherwise."
msgstr ""
"El desensamblaje se escribe como texto en el argumento *file* proporcionado "
"si se proporciona y, de lo contrario, ``sys.stdout``."

#: ../Doc/library/dis.rst:247
msgid ""
"The maximal depth of recursion is limited by *depth* unless it is ``None``. "
"``depth=0`` means no recursion."
msgstr ""
"La profundidad máxima de recursión está limitada por *depth* a menos que sea "
"``None``. ``depth=0`` significa que no hay recursión."

#: ../Doc/library/dis.rst:250
msgid ""
"If *show_caches* is ``True``, this function will display inline cache "
"entries used by the interpreter to specialize the bytecode."
msgstr ""
"Si *show_caches* es ``True``, esta función mostrará las entradas de caché en "
"línea utilizadas por el intérprete para especializar el código de bytes."

#: ../Doc/library/dis.rst:253
msgid ""
"If *adaptive* is ``True``, this function will display specialized bytecode "
"that may be different from the original bytecode."
msgstr ""
"Si *adaptive* es ``True``, esta función mostrará un código de bytes "
"especializado que puede ser diferente del código de bytes original."

#: ../Doc/library/dis.rst:259
msgid "Implemented recursive disassembling and added *depth* parameter."
msgstr "Desensamblaje recursivo implementado y parámetro agregado *depth*."

#: ../Doc/library/dis.rst:272
msgid ""
"Disassemble the top-of-stack function of a traceback, using the last "
"traceback if none was passed.  The instruction causing the exception is "
"indicated."
msgstr ""
"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."

#: ../Doc/library/dis.rst:285 ../Doc/library/dis.rst:315
msgid "Added the *show_offsets* parameter."
msgstr "Se agregó el parámetro *show_offsets*."

#: ../Doc/library/dis.rst:292
msgid ""
"Disassemble a code object, indicating the last instruction if *lasti* was "
"provided.  The output is divided in the following columns:"
msgstr ""
"Desmonta un objeto de código, que indica la última instrucción si se "
"proporcionó *lasti*. La salida se divide en las siguientes columnas:"

#: ../Doc/library/dis.rst:295
msgid "the line number, for the first instruction of each line"
msgstr "el número de línea, para la primera instrucción de cada línea"

#: ../Doc/library/dis.rst:296
msgid "the current instruction, indicated as ``-->``,"
msgstr "la instrucción actual, indicada como ``-->``,"

#: ../Doc/library/dis.rst:297
msgid "a labelled instruction, indicated with ``>>``,"
msgstr "una instrucción etiquetada, indicada con ``>>``,"

#: ../Doc/library/dis.rst:298
msgid "the address of the instruction,"
msgstr "la dirección de la instrucción,"

#: ../Doc/library/dis.rst:299
msgid "the operation code name,"
msgstr "el nombre del código de operación,"

#: ../Doc/library/dis.rst:300
msgid "operation parameters, and"
msgstr "parámetros de operación, y"

#: ../Doc/library/dis.rst:301
msgid "interpretation of the parameters in parentheses."
msgstr "interpretación de los parámetros entre paréntesis."

#: ../Doc/library/dis.rst:303
msgid ""
"The parameter interpretation recognizes local and global variable names, "
"constant values, branch targets, and compare operators."
msgstr ""
"La interpretación de parámetros reconoce nombres de variables locales y "
"globales, valores constantes, objetivos de ramificación y operadores de "
"comparación."

#: ../Doc/library/dis.rst:320
msgid ""
"Return an iterator over the instructions in the supplied function, method, "
"source code string or code object."
msgstr ""
"Retorna un iterador sobre las instrucciones en la función, método, cadena de "
"código fuente u objeto de código suministrado."

#: ../Doc/library/dis.rst:323
msgid ""
"The iterator generates a series of :class:`Instruction` named tuples giving "
"the details of each operation in the supplied code."
msgstr ""
"El iterador genera una serie de tuplas con nombre :class:`Instruction` que "
"dan los detalles de cada operación en el código suministrado."

#: ../Doc/library/dis.rst:331
msgid "The *adaptive* parameter works as it does in :func:`dis`."
msgstr "El parámetro *adaptive* funciona como lo hace en :func:`dis`."

#: ../Doc/library/dis.rst:338
msgid ""
"The *show_caches* parameter is deprecated and has no effect. The iterator "
"generates the :class:`Instruction` instances with the *cache_info* field "
"populated (regardless of the value of *show_caches*) and it no longer "
"generates separate items for the cache entries."
msgstr ""
"El parámetro *show_caches* está obsoleto y no tiene efecto. El iterador "
"genera las instancias :class:`Instruction` con el campo *cache_info* "
"completado (independientemente del valor de *show_caches*) y ya no genera "
"elementos separados para las entradas de caché."

#: ../Doc/library/dis.rst:346
msgid ""
"This generator function uses the :meth:`~codeobject.co_lines` method of the :"
"ref:`code object <code-objects>` *code* to find the offsets which are starts "
"of lines in the source code.  They are generated as ``(offset, lineno)`` "
"pairs."
msgstr ""
"Esta función generadora utiliza el método :meth:`~codeobject.co_lines` de :"
"ref:`code object <code-objects>` y *code* para encontrar los desplazamientos "
"que son inicios de líneas en el código fuente. Se generan como pares "
"``(offset, lineno)``."

#: ../Doc/library/dis.rst:351
msgid "Line numbers can be decreasing. Before, they were always increasing."
msgstr ""
"Los números de línea pueden estar disminuyendo. Antes, siempre estaban "
"aumentando."

#: ../Doc/library/dis.rst:354
msgid ""
"The :pep:`626` :meth:`~codeobject.co_lines` method is used instead of the :"
"attr:`~codeobject.co_firstlineno` and :attr:`~codeobject.co_lnotab` "
"attributes of the :ref:`code object <code-objects>`."
msgstr ""
"Se utiliza el método :pep:`626` :meth:`~codeobject.co_lines` en lugar de los "
"atributos :attr:`~codeobject.co_firstlineno` y :attr:`~codeobject.co_lnotab` "
"del :ref:`code object <code-objects>`."

#: ../Doc/library/dis.rst:359
msgid ""
"Line numbers can be ``None`` for bytecode that does not map to source lines."
msgstr ""
"Los números de línea pueden ser ``None`` para el código de bytes que no se "
"asigna a las líneas de origen."

#: ../Doc/library/dis.rst:365
msgid ""
"Detect all offsets in the raw compiled bytecode string *code* which are jump "
"targets, and return a list of these offsets."
msgstr ""
"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."

#: ../Doc/library/dis.rst:371
msgid "Compute the stack effect of *opcode* with argument *oparg*."
msgstr "Calcula el efecto de pila de *opcode* con el argumento *oparg*."

#: ../Doc/library/dis.rst:373
msgid ""
"If the code has a jump target and *jump* is ``True``, :func:`~stack_effect` "
"will return the stack effect of jumping.  If *jump* is ``False``, it will "
"return the stack effect of not jumping. And if *jump* is ``None`` (default), "
"it will return the maximal stack effect of both cases."
msgstr ""
"Si el código tiene un objetivo de salto y *jump* es ``True``, :func:"
"`~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."

#: ../Doc/library/dis.rst:380
msgid "Added *jump* parameter."
msgstr "Agrega un parámetro *jump*."

#: ../Doc/library/dis.rst:383
msgid ""
"If ``oparg`` is omitted (or ``None``), the stack effect is now returned for "
"``oparg=0``. Previously this was an error for opcodes that use their arg. It "
"is also no longer an error to pass an integer ``oparg`` when the ``opcode`` "
"does not use it; the ``oparg`` in this case is ignored."
msgstr ""
"Si se omite ``oparg`` (o ``None``), ahora se devuelve el efecto de pila para "
"``oparg=0``. Anteriormente, esto era un error para los códigos de operación "
"que usan su argumento. Tampoco es un error pasar un entero ``oparg`` cuando "
"``opcode`` no lo usa; en este caso, se ignora ``oparg``."

#: ../Doc/library/dis.rst:393
msgid "Python Bytecode Instructions"
msgstr "Instrucciones bytecode de Python"

#: ../Doc/library/dis.rst:395
msgid ""
"The :func:`get_instructions` function and :class:`Bytecode` class provide "
"details of bytecode instructions as :class:`Instruction` instances:"
msgstr ""
"La función :func:`get_instructions` y clase :class:`Bytecode` proporcionan "
"detalles de las instrucciones bytecode como instancias :class:`Instruction`:"

#: ../Doc/library/dis.rst:400
msgid "Details for a bytecode operation"
msgstr "Detalles para una operación de bytecode"

#: ../Doc/library/dis.rst:404
msgid ""
"numeric code for operation, corresponding to the opcode values listed below "
"and the bytecode values in the :ref:`opcode_collections`."
msgstr ""
"código numérico para la operación, correspondiente a los valores del opcode "
"listados a continuación y los valores de bytecode en :ref:"
"`opcode_collections`."

#: ../Doc/library/dis.rst:410
msgid "human readable name for operation"
msgstr "nombre legible por humanos para la operación"

#: ../Doc/library/dis.rst:415
msgid ""
"numeric code for the base operation if operation is specialized; otherwise "
"equal to :data:`opcode`"
msgstr ""
"código numérico para la operación base si la operación es especializada; en "
"caso contrario, igual a :data:`opcode`"

#: ../Doc/library/dis.rst:421
msgid ""
"human readable name for the base operation if operation is specialized; "
"otherwise equal to :data:`opname`"
msgstr ""
"Nombre legible para humanos para la operación base si la operación es "
"especializada; de lo contrario, es igual a :data:`opname`"

#: ../Doc/library/dis.rst:427
msgid "numeric argument to operation (if any), otherwise ``None``"
msgstr ""
"argumento numérico para la operación (si existe), de lo contrario ``None``"

#: ../Doc/library/dis.rst:431
msgid "alias for :data:`arg`"
msgstr "alias para :data:`arg`"

#: ../Doc/library/dis.rst:435
msgid "resolved arg value (if any), otherwise ``None``"
msgstr "valor de argumento resuelto (si lo hay); de lo contrario, ``None``"

#: ../Doc/library/dis.rst:440
msgid ""
"human readable description of operation argument (if any), otherwise an "
"empty string."
msgstr ""
"descripción legible por humanos del argumento de la operación (si lo hay); "
"de lo contrario, una cadena vacía."

#: ../Doc/library/dis.rst:446
msgid "start index of operation within bytecode sequence"
msgstr "índice de inicio de operación dentro de la secuencia de bytecode"

#: ../Doc/library/dis.rst:451
msgid ""
"start index of operation within bytecode sequence, including prefixed "
"``EXTENDED_ARG`` operations if present; otherwise equal to :data:`offset`"
msgstr ""
"índice de inicio de la operación dentro de la secuencia de bytecode, "
"incluidas las operaciones con prefijo ``EXTENDED_ARG`` si están presentes; "
"de lo contrario, igual a :data:`offset`"

#: ../Doc/library/dis.rst:457
msgid "start index of the cache entries following the operation"
msgstr "índice de inicio de las entradas de caché después de la operación"

#: ../Doc/library/dis.rst:462
msgid "end index of the cache entries following the operation"
msgstr "índice final de las entradas de caché después de la operación"

#: ../Doc/library/dis.rst:467
msgid "``True`` if this opcode starts a source line, otherwise ``False``"
msgstr ""
"``True`` si este código de operación inicia una línea de origen, de lo "
"contrario ``False``"

#: ../Doc/library/dis.rst:472
msgid ""
"source line number associated with this opcode (if any), otherwise ``None``"
msgstr ""
"número de línea de origen asociado con este código de operación (si lo hay), "
"de lo contrario ``None``"

#: ../Doc/library/dis.rst:477
msgid "``True`` if other code jumps to here, otherwise ``False``"
msgstr "``True`` si otro código salta aquí, de lo contrario, ``False``"

#: ../Doc/library/dis.rst:482
msgid ""
"bytecode index of the jump target if this is a jump operation, otherwise "
"``None``"
msgstr ""
"índice de código de bytes del objetivo del salto si se trata de una "
"operación de salto, de lo contrario ``None``"

#: ../Doc/library/dis.rst:488
msgid ""
":class:`dis.Positions` object holding the start and end locations that are "
"covered by this instruction."
msgstr ""
"Objeto :class:`dis.Positions` que contiene las ubicaciones de inicio y "
"finalización cubiertas por esta instrucción."

#: ../Doc/library/dis.rst:503
msgid "Field ``positions`` is added."
msgstr "Se agrega el campo ``positions``."

#: ../Doc/library/dis.rst:507
msgid "Changed field ``starts_line``."
msgstr "Se modificó el campo ``starts_line``."

#: ../Doc/library/dis.rst:509
msgid ""
"Added fields ``start_offset``, ``cache_offset``, ``end_offset``, "
"``baseopname``, ``baseopcode``, ``jump_target``, ``oparg``, ``line_number`` "
"and ``cache_info``."
msgstr ""
"Se agregaron los campos ``start_offset``, ``cache_offset``, ``end_offset``, "
"``baseopname``, ``baseopcode``, ``jump_target``, ``oparg``, ``line_number`` "
"y ``cache_info``."

#: ../Doc/library/dis.rst:516
msgid ""
"In case the information is not available, some fields might be ``None``."
msgstr ""
"En caso de que la información no esté disponible, algunos campos pueden ser "
"``None``."

#: ../Doc/library/dis.rst:526
msgid ""
"The Python compiler currently generates the following bytecode instructions."
msgstr ""
"El compilador de Python actualmente genera las siguientes instrucciones de "
"bytecode."

#: ../Doc/library/dis.rst:529
msgid "**General instructions**"
msgstr "**Instrucciones generales**"

#: ../Doc/library/dis.rst:531
msgid ""
"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."
msgstr ""
"A continuación, nos referiremos a la pila del intérprete como ``STACK`` y "
"describiremos las operaciones en ella como si fuera una lista de Python. La "
"parte superior de la pila corresponde a ``STACK[-1]`` en este lenguaje."

#: ../Doc/library/dis.rst:537
msgid ""
"Do nothing code.  Used as a placeholder by the bytecode optimizer, and to "
"generate line tracing events."
msgstr ""
"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."

#: ../Doc/library/dis.rst:543
msgid "Removes the top-of-stack item::"
msgstr "Elimina el elemento de la parte superior de la pila::"

#: ../Doc/library/dis.rst:545
msgid "STACK.pop()"
msgstr "STACK.pop()"

#: ../Doc/library/dis.rst:550
msgid ""
"Removes the top-of-stack item. Equivalent to ``POP_TOP``. Used to clean up "
"at the end of loops, hence the name."
msgstr ""
"Elimina el elemento superior de la pila. Equivale a ``POP_TOP``. Se utiliza "
"para limpiar al final de los bucles, de ahí el nombre."

#: ../Doc/library/dis.rst:559
msgid "Implements ``del STACK[-2]``. Used to clean up when a generator exits."
msgstr ""
"Implementa ``del STACK[-2]``. Se utiliza para limpiar cuando finaliza un "
"generador."

#: ../Doc/library/dis.rst:567
msgid ""
"Push the i-th item to the top of the stack without removing it from its "
"original location::"
msgstr ""
"Empuja el elemento i-ésimo hacia la parte superior de la pila sin quitarlo "
"de su ubicación original::"

#: ../Doc/library/dis.rst:570
msgid ""
"assert i > 0\n"
"STACK.append(STACK[-i])"
msgstr ""
"assert i > 0\n"
"STACK.append(STACK[-i])"

#: ../Doc/library/dis.rst:578
msgid "Swap the top of the stack with the i-th element::"
msgstr "Intercambia la parte superior de la pila con el elemento i-ésimo::"

#: ../Doc/library/dis.rst:580
msgid "STACK[-i], STACK[-1] = STACK[-1], STACK[-i]"
msgstr "STACK[-i], STACK[-1] = STACK[-1], STACK[-i]"

#: ../Doc/library/dis.rst:587
msgid ""
"Rather than being an actual instruction, this opcode is used to mark extra "
"space for the interpreter to cache useful data directly in the bytecode "
"itself. It is automatically hidden by all ``dis`` utilities, but can be "
"viewed with ``show_caches=True``."
msgstr ""
"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``."

#: ../Doc/library/dis.rst:592
msgid ""
"Logically, this space is part of the preceding instruction. Many opcodes "
"expect to be followed by an exact number of caches, and will instruct the "
"interpreter to skip over them at runtime."
msgstr ""
"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."

#: ../Doc/library/dis.rst:596
msgid ""
"Populated caches can look like arbitrary instructions, so great care should "
"be taken when reading or modifying raw, adaptive bytecode containing "
"quickened data."
msgstr ""
"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."

#: ../Doc/library/dis.rst:603
msgid "**Unary operations**"
msgstr "**Operaciones unarias**"

#: ../Doc/library/dis.rst:605
msgid ""
"Unary operations take the top of the stack, apply the operation, and push "
"the result back on the stack."
msgstr ""
"Las operaciones unarias toman la parte superior de la pila, aplican la "
"operación y retornan el resultado a la pila."

#: ../Doc/library/dis.rst:611
msgid "Implements ``STACK[-1] = -STACK[-1]``."
msgstr "Implementa ``STACK[-1] = -STACK[-1]``."

#: ../Doc/library/dis.rst:616
msgid "Implements ``STACK[-1] = not STACK[-1]``."
msgstr "Implementa ``STACK[-1] = not STACK[-1]``."

#: ../Doc/library/dis.rst:618 ../Doc/library/dis.rst:1313
#: ../Doc/library/dis.rst:1329
msgid "This instruction now requires an exact :class:`bool` operand."
msgstr "Esta instrucción ahora requiere un operando :class:`bool` exacto."

#: ../Doc/library/dis.rst:624
msgid "Implements ``STACK[-1] = ~STACK[-1]``."
msgstr "Implementa ``STACK[-1] = ~STACK[-1]``."

#: ../Doc/library/dis.rst:629
msgid "Implements ``STACK[-1] = iter(STACK[-1])``."
msgstr "Implementa ``STACK[-1] = iter(STACK[-1])``."

#: ../Doc/library/dis.rst:634
msgid ""
"If ``STACK[-1]`` is a :term:`generator iterator` or :term:`coroutine` object "
"it is left as is.  Otherwise, implements ``STACK[-1] = iter(STACK[-1])``."
msgstr ""
"Si ``STACK[-1]`` es un objeto :term:`generator iterator` o :term:"
"`coroutine`, se deja como está. De lo contrario, se implementa ``STACK[-1] = "
"iter(STACK[-1])``."

#: ../Doc/library/dis.rst:642
msgid "Implements ``STACK[-1] = bool(STACK[-1])``."
msgstr "Implementa ``STACK[-1] = bool(STACK[-1])``."

#: ../Doc/library/dis.rst:647
msgid "**Binary and in-place operations**"
msgstr "**Operaciones binarias e in situ**"

#: ../Doc/library/dis.rst:649
msgid ""
"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."
msgstr ""
"Las operaciones binarias eliminan los dos elementos superiores de la pila "
"(``STACK[-1]`` y ``STACK[-2]``). Realizan la operación y luego vuelven a "
"colocar el resultado en la pila."

#: ../Doc/library/dis.rst:652
msgid ""
"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]``."
msgstr ""
"Las operaciones en el lugar son como operaciones binarias, pero la operación "
"se realiza en el lugar cuando ``STACK[-2]`` la admite, y el ``STACK[-1]`` "
"resultante puede ser (pero no tiene que ser) el ``STACK[-2]`` original."

#: ../Doc/library/dis.rst:659
msgid ""
"Implements the binary and in-place operators (depending on the value of "
"*op*)::"
msgstr ""
"Implementa los operadores binarios y locales (según el valor de *op*)::"

#: ../Doc/library/dis.rst:662
msgid ""
"rhs = STACK.pop()\n"
"lhs = STACK.pop()\n"
"STACK.append(lhs op rhs)"
msgstr ""
"rhs = STACK.pop()\n"
"lhs = STACK.pop()\n"
"STACK.append(lhs op rhs)"

#: ../Doc/library/dis.rst:671 ../Doc/library/dis.rst:680
#: ../Doc/library/dis.rst:690 ../Doc/library/dis.rst:698
#: ../Doc/library/dis.rst:710 ../Doc/library/dis.rst:798
#: ../Doc/library/dis.rst:808 ../Doc/library/dis.rst:818
#: ../Doc/library/dis.rst:1041 ../Doc/library/dis.rst:1052
#: ../Doc/library/dis.rst:1156 ../Doc/library/dis.rst:1168
#: ../Doc/library/dis.rst:1180
msgid "Implements::"
msgstr "Implementos::"

#: ../Doc/library/dis.rst:673
msgid ""
"key = STACK.pop()\n"
"container = STACK.pop()\n"
"STACK.append(container[key])"
msgstr ""
"key = STACK.pop()\n"
"container = STACK.pop()\n"
"STACK.append(container[key])"

#: ../Doc/library/dis.rst:682
msgid ""
"key = STACK.pop()\n"
"container = STACK.pop()\n"
"value = STACK.pop()\n"
"container[key] = value"
msgstr ""
"key = STACK.pop()\n"
"container = STACK.pop()\n"
"value = STACK.pop()\n"
"container[key] = value"

#: ../Doc/library/dis.rst:692
msgid ""
"key = STACK.pop()\n"
"container = STACK.pop()\n"
"del container[key]"
msgstr ""
"key = STACK.pop()\n"
"container = STACK.pop()\n"
"del container[key]"

#: ../Doc/library/dis.rst:700
msgid ""
"end = STACK.pop()\n"
"start = STACK.pop()\n"
"container = STACK.pop()\n"
"STACK.append(container[start:end])"
msgstr ""
"end = STACK.pop()\n"
"start = STACK.pop()\n"
"container = STACK.pop()\n"
"STACK.append(container[start:end])"

#: ../Doc/library/dis.rst:712
msgid ""
"end = STACK.pop()\n"
"start = STACK.pop()\n"
"container = STACK.pop()\n"
"values = STACK.pop()\n"
"container[start:end] = value"
msgstr ""
"end = STACK.pop()\n"
"start = STACK.pop()\n"
"container = STACK.pop()\n"
"values = STACK.pop()\n"
"container[start:end] = value"

#: ../Doc/library/dis.rst:721
msgid "**Coroutine opcodes**"
msgstr "**Opcodes de corutinas**"

#: ../Doc/library/dis.rst:725
msgid ""
"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 :data:`~inspect.CO_ITERABLE_COROUTINE` flag, or "
"resolves ``o.__await__``."
msgstr ""
"Implementa ``STACK[-1] = get_awaitable(STACK[-1])``, donde "
"``get_awaitable(o)`` devuelve ``o`` si ``o`` es un objeto de corrutina o un "
"objeto generador con el indicador :data:`~inspect.CO_ITERABLE_COROUTINE`, o "
"resuelve ``o.__await__``."

#: ../Doc/library/dis.rst:730
msgid ""
"If the ``where`` operand is nonzero, it indicates where the instruction "
"occurs:"
msgstr ""
"Si el operando ``where`` es distinto de cero, indica dónde ocurre la "
"instrucción:"

#: ../Doc/library/dis.rst:733
msgid "``1``: After a call to ``__aenter__``"
msgstr "``1``: Después de una llamada a ``__aenter__``"

#: ../Doc/library/dis.rst:734
msgid "``2``: After a call to ``__aexit__``"
msgstr "``2``: Después de una llamada a ``__aexit__``"

#: ../Doc/library/dis.rst:738
msgid "Previously, this instruction did not have an oparg."
msgstr "Anteriormente, esta instrucción no tenía un oparg."

#: ../Doc/library/dis.rst:744
msgid "Implements ``STACK[-1] = STACK[-1].__aiter__()``."
msgstr "Implementa ``STACK[-1] = STACK[-1].__aiter__()``."

#: ../Doc/library/dis.rst:747
msgid "Returning awaitable objects from ``__aiter__`` is no longer supported."
msgstr "Ya no se admite el retorno de objetos *awaitable* de ``__aiter__``."

#: ../Doc/library/dis.rst:754
msgid ""
"Implement ``STACK.append(get_awaitable(STACK[-1].__anext__()))`` to the "
"stack. See ``GET_AWAITABLE`` for details about ``get_awaitable``."
msgstr ""
"Implemente ``STACK.append(get_awaitable(STACK[-1].__anext__()))`` en la "
"pila. Consulte ``GET_AWAITABLE`` para obtener más detalles sobre "
"``get_awaitable``."

#: ../Doc/library/dis.rst:762
msgid ""
"Terminates an :keyword:`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 :exc:`StopAsyncIteration`, it is re-raised."
msgstr ""
"Finaliza un bucle :keyword:`async for`. Controla una excepción generada al "
"esperar un elemento siguiente. La pila contiene el iterable asincrónico en "
"``STACK[-2]`` y la excepción generada en ``STACK[-1]``. Ambos se eliminan. "
"Si la excepción no es :exc:`StopAsyncIteration`, se vuelve a generar."

#: ../Doc/library/dis.rst:769 ../Doc/library/dis.rst:877
#: ../Doc/library/dis.rst:888
msgid ""
"Exception representation on the stack now consist of one, not three, items."
msgstr ""
"La representación de excepciones en la pila ahora consta de uno, no de tres "
"elementos."

#: ../Doc/library/dis.rst:775
msgid ""
"Handles an exception raised during a :meth:`~generator.throw` or :meth:"
"`~generator.close` call through the current frame.  If ``STACK[-1]`` is an "
"instance of :exc:`StopIteration`, pop three values from the stack and push "
"its ``value`` member.  Otherwise, re-raise ``STACK[-1]``."
msgstr ""
"Maneja una excepción generada durante una llamada :meth:`~generator.throw` "
"o :meth:`~generator.close` a través del marco actual. Si ``STACK[-1]`` es "
"una instancia de :exc:`StopIteration`, extrae tres valores de la pila y "
"envía su miembro ``value``. De lo contrario, vuelve a generar ``STACK[-1]``."

#: ../Doc/library/dis.rst:785
msgid ""
"Resolves ``__aenter__`` and ``__aexit__`` from ``STACK[-1]``. Pushes "
"``__aexit__`` and result of ``__aenter__()`` to the stack::"
msgstr ""
"Resuelve ``__aenter__`` y ``__aexit__`` a partir de ``STACK[-1]``. Envía "
"``__aexit__`` y el resultado de ``__aenter__()`` a la pila:"

#: ../Doc/library/dis.rst:788
msgid "STACK.extend((__aexit__, __aenter__())"
msgstr "STACK.extend((__aexit__, __aenter__())"

#: ../Doc/library/dis.rst:794
msgid "**Miscellaneous opcodes**"
msgstr "**Opcodes misceláneos**"

#: ../Doc/library/dis.rst:800
msgid ""
"item = STACK.pop()\n"
"set.add(STACK[-i], item)"
msgstr ""
"item = STACK.pop()\n"
"set.add(STACK[-i], item)"

#: ../Doc/library/dis.rst:803
msgid "Used to implement set comprehensions."
msgstr "Se utiliza para implementar comprensiones de conjuntos."

#: ../Doc/library/dis.rst:810
msgid ""
"item = STACK.pop()\n"
"list.append(STACK[-i], item)"
msgstr ""
"item = STACK.pop()\n"
"list.append(STACK[-i], item)"

#: ../Doc/library/dis.rst:813
msgid "Used to implement list comprehensions."
msgstr "Se utiliza para implementar listas por comprensión."

#: ../Doc/library/dis.rst:820
msgid ""
"value = STACK.pop()\n"
"key = STACK.pop()\n"
"dict.__setitem__(STACK[-i], key, value)"
msgstr ""
"value = STACK.pop()\n"
"key = STACK.pop()\n"
"dict.__setitem__(STACK[-i], key, value)"

#: ../Doc/library/dis.rst:824
msgid "Used to implement dict comprehensions."
msgstr "Se utiliza para implementar comprensiones de diccionarios."

#: ../Doc/library/dis.rst:827
msgid ""
"Map value is ``STACK[-1]`` and map key is ``STACK[-2]``. Before, those were "
"reversed."
msgstr ""
"El valor del mapa es ``STACK[-1]`` y la clave del mapa es ``STACK[-2]``. "
"Antes, estaban invertidos."

#: ../Doc/library/dis.rst:831
msgid ""
"For all of the :opcode:`SET_ADD`, :opcode:`LIST_APPEND` and :opcode:"
"`MAP_ADD` instructions, while the added value or key/value pair is popped "
"off, the container object remains on the stack so that it is available for "
"further iterations of the loop."
msgstr ""
"Para todas las instrucciones :opcode:`SET_ADD`, :opcode:`LIST_APPEND` y :"
"opcode:`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."

#: ../Doc/library/dis.rst:839
msgid "Returns with ``STACK[-1]`` to the caller of the function."
msgstr "Regresa con ``STACK[-1]`` al llamador de la función."

#: ../Doc/library/dis.rst:844
msgid "Returns with ``co_consts[consti]`` to the caller of the function."
msgstr "Regresa con ``co_consts[consti]`` al llamador de la función."

#: ../Doc/library/dis.rst:851
msgid "Yields ``STACK.pop()`` from a :term:`generator`."
msgstr "Produce ``STACK.pop()`` a partir de un :term:`generator`."

#: ../Doc/library/dis.rst:853
msgid "oparg set to be the stack depth."
msgstr "oparg establecido para ser la profundidad de la pila."

#: ../Doc/library/dis.rst:856
msgid ""
"oparg set to be the exception block depth, for efficient closing of "
"generators."
msgstr ""
"oparg está configurado para ser la profundidad del bloque de excepción, para "
"el cierre eficiente de los generadores."

#: ../Doc/library/dis.rst:859
msgid ""
"oparg is ``1`` if this instruction is part of a yield-from or await, and "
"``0`` otherwise."
msgstr ""
"oparg es ``1`` si esta instrucción es parte de un yield-from o await, y "
"``0`` en caso contrario."

#: ../Doc/library/dis.rst:865
msgid ""
"Checks whether ``__annotations__`` is defined in ``locals()``, if not it is "
"set up to an empty ``dict``. This opcode is only emitted if a class or "
"module body contains :term:`variable annotations <variable annotation>` "
"statically."
msgstr ""
"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 :term:`anotaciones de variables "
"<variable annotation>` estáticamente."

#: ../Doc/library/dis.rst:875
msgid ""
"Pops a value from the stack, which is used to restore the exception state."
msgstr ""
"Extrae un valor de la pila, que se utiliza para restaurar el estado de "
"excepción."

#: ../Doc/library/dis.rst:882
msgid ""
"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 :attr:`~frame."
"f_lasti` of the current frame."
msgstr ""
"Vuelve a generar la excepción que se encuentra actualmente en la parte "
"superior de la pila. Si oparg no es cero, extrae un valor adicional de la "
"pila que se utiliza para establecer :attr:`~frame.f_lasti` del marco actual."

#: ../Doc/library/dis.rst:893
msgid ""
"Pops a value from the stack. Pushes the current exception to the top of the "
"stack. Pushes the value originally popped back to the stack. Used in "
"exception handlers."
msgstr ""
"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."

#: ../Doc/library/dis.rst:901
msgid ""
"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."
msgstr ""
"Realiza una comparación de excepciones para ``except``. Comprueba si "
"``STACK[-2]`` es una comparación de excepciones con ``STACK[-1]``. Extrae "
"``STACK[-1]`` y envía el resultado booleano de la prueba."

#: ../Doc/library/dis.rst:909
msgid ""
"Performs exception matching for ``except*``. Applies ``split(STACK[-1])`` on "
"the exception group representing ``STACK[-2]``."
msgstr ""
"Realiza la coincidencia de excepciones para ``except*``. Aplica "
"``split(STACK[-1])`` en el grupo de excepciones que representa a "
"``STACK[-2]``."

#: ../Doc/library/dis.rst:912
msgid ""
"In case of a match, pops two items from the stack and pushes the non-"
"matching subgroup (``None`` in case of full match) followed by the matching "
"subgroup. When there is no match, pops one item (the match type) and pushes "
"``None``."
msgstr ""
"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``."

#: ../Doc/library/dis.rst:921
msgid ""
"Calls the function in position 4 on the stack with arguments (type, val, tb) "
"representing the exception at the top of the stack. Used to implement the "
"call ``context_manager.__exit__(*exc_info())`` when an exception has "
"occurred in a :keyword:`with` statement."
msgstr ""
"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 :keyword:`with`."

#: ../Doc/library/dis.rst:928
msgid ""
"The ``__exit__`` function is in position 4 of the stack rather than 7. "
"Exception representation on the stack now consist of one, not three, items."
msgstr ""
"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."

#: ../Doc/library/dis.rst:935
msgid ""
"Pushes :exc:`AssertionError` onto the stack.  Used by the :keyword:`assert` "
"statement."
msgstr ""
"Inserta :exc:`AssertionError` en la pila. Utilizado por la declaración :"
"keyword:`assert`."

#: ../Doc/library/dis.rst:943
msgid ""
"Pushes :func:`!builtins.__build_class__` onto the stack.  It is later called "
"to construct a class."
msgstr ""
"Coloca :func:`!builtins.__build_class__` en la pila. Luego se lo llama para "
"construir una clase."

#: ../Doc/library/dis.rst:949
msgid ""
"This opcode performs several operations before a with block starts.  First, "
"it loads :meth:`~object.__exit__` from the context manager and pushes it "
"onto the stack for later use by :opcode:`WITH_EXCEPT_START`.  Then, :meth:"
"`~object.__enter__` is called. Finally, the result of calling the "
"``__enter__()`` method is pushed onto the stack."
msgstr ""
"Este código de operación realiza varias operaciones antes de que comience un "
"bloque with. Primero, carga :meth:`~object.__exit__` desde el administrador "
"de contexto y lo agrega a la pila para que :opcode:`WITH_EXCEPT_START` lo "
"use más tarde. Entonces, se llama :meth:`~object.__enter__`. Finalmente, el "
"resultado de llamar al método ``__enter__()`` se agrega en la pila."

#: ../Doc/library/dis.rst:960
msgid "Perform ``STACK.append(len(STACK[-1]))``."
msgstr "Ejecutar ``STACK.append(len(STACK[-1]))``."

#: ../Doc/library/dis.rst:967
msgid ""
"If ``STACK[-1]`` is an instance of :class:`collections.abc.Mapping` (or, "
"more technically: if it has the :c:macro:`Py_TPFLAGS_MAPPING` flag set in "
"its :c:member:`~PyTypeObject.tp_flags`), push ``True`` onto the stack.  "
"Otherwise, push ``False``."
msgstr ""
"Si ``STACK[-1]`` es una instancia de :class:`collections.abc.Mapping` (o, "
"más técnicamente: si tiene el indicador :c:macro:`Py_TPFLAGS_MAPPING` "
"establecido en su :c:member:`~PyTypeObject.tp_flags`), inserte ``True`` en "
"la pila. De lo contrario, inserte ``False``."

#: ../Doc/library/dis.rst:977
msgid ""
"If ``STACK[-1]`` is an instance of :class:`collections.abc.Sequence` and is "
"*not* an instance of :class:`str`/:class:`bytes`/:class:`bytearray` (or, "
"more technically: if it has the :c:macro:`Py_TPFLAGS_SEQUENCE` flag set in "
"its :c:member:`~PyTypeObject.tp_flags`), push ``True`` onto the stack.  "
"Otherwise, push ``False``."
msgstr ""
"Si ``STACK[-1]`` es una instancia de :class:`collections.abc.Sequence` y "
"*not* es una instancia de :class:`str`/:class:`bytes`/:class:`bytearray` (o, "
"más técnicamente: si tiene el indicador :c:macro:`Py_TPFLAGS_SEQUENCE` "
"establecido en su :c:member:`~PyTypeObject.tp_flags`), inserte ``True`` en "
"la pila. De lo contrario, inserte ``False``."

#: ../Doc/library/dis.rst:987
msgid ""
"``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 :"
"class:`tuple` containing the corresponding values. Otherwise, push ``None``."
msgstr ""
"``STACK[-1]`` es una tupla de claves de mapeo y ``STACK[-2]`` es el sujeto "
"de la coincidencia. Si ``STACK[-2]`` contiene todas las claves de "
"``STACK[-1]``, inserte un :class:`tuple` que contenga los valores "
"correspondientes. De lo contrario, inserte ``None``."

#: ../Doc/library/dis.rst:993 ../Doc/library/dis.rst:1664
msgid ""
"Previously, this instruction also pushed a boolean value indicating success "
"(``True``) or failure (``False``)."
msgstr ""
"Anteriormente, esta instrucción también generaba un valor booleano que "
"indicaba éxito (``True``) o falla (``False``)."

#: ../Doc/library/dis.rst:1000
msgid ""
"Implements ``name = STACK.pop()``. *namei* is the index of *name* in the "
"attribute :attr:`~codeobject.co_names` of the :ref:`code object <code-"
"objects>`. The compiler tries to use :opcode:`STORE_FAST` or :opcode:"
"`STORE_GLOBAL` if possible."
msgstr ""
"Implementa ``name = STACK.pop()``. *namei* es el índice de *name* en el "
"atributo :attr:`~codeobject.co_names` de :ref:`code object <code-objects>`. "
"El compilador intenta utilizar :opcode:`STORE_FAST` o :opcode:`STORE_GLOBAL` "
"si es posible."

#: ../Doc/library/dis.rst:1007
msgid ""
"Implements ``del name``, where *namei* is the index into :attr:`~codeobject."
"co_names` attribute of the :ref:`code object <code-objects>`."
msgstr ""
"Implementa ``del name``, donde *namei* es el índice en el atributo :attr:"
"`~codeobject.co_names` del :ref:`code object <code-objects>`."

#: ../Doc/library/dis.rst:1013
msgid ""
"Unpacks ``STACK[-1]`` into *count* individual values, which are put onto the "
"stack right-to-left. Require there to be exactly *count* values.::"
msgstr ""
"Descomprime ``STACK[-1]`` en valores individuales *count*, que se colocan en "
"la pila de derecha a izquierda. Requiere que haya exactamente valores "
"*count*.::"

#: ../Doc/library/dis.rst:1016
msgid ""
"assert(len(STACK[-1]) == count)\n"
"STACK.extend(STACK.pop()[:-count-1:-1])"
msgstr ""
"assert(len(STACK[-1]) == count)\n"
"STACK.extend(STACK.pop()[:-count-1:-1])"

#: ../Doc/library/dis.rst:1022
msgid ""
"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."
msgstr ""
"Implementa la asignación con un objetivo destacado: descomprime un iterable "
"en ``STACK[-1]`` en valores individuales, donde la cantidad total de valores "
"puede ser menor que la cantidad de elementos en el iterable: uno de los "
"nuevos valores será una lista de todos los elementos restantes."

#: ../Doc/library/dis.rst:1027
msgid "The number of values before and after the list value is limited to 255."
msgstr ""
"El número de valores antes y después del valor de la lista está limitado a "
"255."

#: ../Doc/library/dis.rst:1029
msgid ""
"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."
msgstr ""
"La cantidad de valores antes del valor de la lista se codifica en el "
"argumento del código de operación. La cantidad de valores después de la "
"lista, si los hay, se codifica utilizando un ``EXTENDED_ARG``. Como "
"consecuencia, el argumento puede verse como valores de dos bytes, donde el "
"byte bajo de *counts* es la cantidad de valores antes del valor de la lista "
"y el byte alto de *counts*, la cantidad de valores después de este."

#: ../Doc/library/dis.rst:1035
msgid ""
"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))``."
msgstr ""
"Los valores extraídos se colocan en la pila de derecha a izquierda, es "
"decir, ``a, *b, c = d`` se almacenará después de la ejecución como ``STACK."
"extend((a, b, c))``."

#: ../Doc/library/dis.rst:1043
msgid ""
"obj = STACK.pop()\n"
"value = STACK.pop()\n"
"obj.name = value"
msgstr ""
"obj = STACK.pop()\n"
"value = STACK.pop()\n"
"obj.name = value"

#: ../Doc/library/dis.rst:1047
msgid ""
"where *namei* is the index of name in :attr:`~codeobject.co_names` of the :"
"ref:`code object <code-objects>`."
msgstr ""
"donde *namei* es el índice del nombre en :attr:`~codeobject.co_names` del :"
"ref:`code object <code-objects>`."

#: ../Doc/library/dis.rst:1054
msgid ""
"obj = STACK.pop()\n"
"del obj.name"
msgstr ""
"obj = STACK.pop()\n"
"del obj.name"

#: ../Doc/library/dis.rst:1057
msgid ""
"where *namei* is the index of name into :attr:`~codeobject.co_names` of the :"
"ref:`code object <code-objects>`."
msgstr ""
"donde *namei* es el índice del nombre en :attr:`~codeobject.co_names` del :"
"ref:`code object <code-objects>`."

#: ../Doc/library/dis.rst:1063
msgid "Works as :opcode:`STORE_NAME`, but stores the name as a global."
msgstr ""
"Funciona como :opcode:`STORE_NAME`, pero almacena el nombre como global."

#: ../Doc/library/dis.rst:1068
msgid "Works as :opcode:`DELETE_NAME`, but deletes a global name."
msgstr "Funciona como :opcode:`DELETE_NAME`, pero elimina un nombre global."

#: ../Doc/library/dis.rst:1073
msgid "Pushes ``co_consts[consti]`` onto the stack."
msgstr "Apila ``co_consts[consti]`` en la pila."

#: ../Doc/library/dis.rst:1078
msgid ""
"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."
msgstr ""
"Introduce el valor asociado con ``co_names[namei]`` en la pila. El nombre se "
"busca en las variables locales, luego en las variables globales y luego en "
"las integradas."

#: ../Doc/library/dis.rst:1084
msgid ""
"Pushes a reference to the locals dictionary onto the stack.  This is used to "
"prepare namespace dictionaries for :opcode:`LOAD_FROM_DICT_OR_DEREF` and :"
"opcode:`LOAD_FROM_DICT_OR_GLOBALS`."
msgstr ""
"Introduce una referencia al diccionario de variables locales en la pila. "
"Esto se utiliza para preparar diccionarios de espacios de nombres para :"
"opcode:`LOAD_FROM_DICT_OR_DEREF` y :opcode:`LOAD_FROM_DICT_OR_GLOBALS`."

#: ../Doc/library/dis.rst:1093
msgid ""
"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 :opcode:`LOAD_GLOBAL`. This is used for loading global "
"variables in :ref:`annotation scopes <annotation-scopes>` within class "
"bodies."
msgstr ""
"Extrae una asignación de la pila y busca el valor de ``co_names[namei]``. Si "
"no se encuentra el nombre allí, lo busca en las variables globales y luego "
"en las integradas, de forma similar a :opcode:`LOAD_GLOBAL`. Esto se utiliza "
"para cargar variables globales en :ref:`annotation scopes <annotation-"
"scopes>` dentro de los cuerpos de clase."

#: ../Doc/library/dis.rst:1104
msgid ""
"Creates a tuple consuming *count* items from the stack, and pushes the "
"resulting tuple onto the stack::"
msgstr ""
"Crea una tupla que consume elementos *count* de la pila y envía la tupla "
"resultante a la pila::"

#: ../Doc/library/dis.rst:1107
msgid ""
"if count == 0:\n"
"    value = ()\n"
"else:\n"
"    value = tuple(STACK[-count:])\n"
"    STACK = STACK[:-count]\n"
"\n"
"STACK.append(value)"
msgstr ""
"if count == 0:\n"
"    value = ()\n"
"else:\n"
"    value = tuple(STACK[-count:])\n"
"    STACK = STACK[:-count]\n"
"\n"
"STACK.append(value)"

#: ../Doc/library/dis.rst:1118
msgid "Works as :opcode:`BUILD_TUPLE`, but creates a list."
msgstr "Funciona como :opcode:`BUILD_TUPLE`, pero crea una lista."

#: ../Doc/library/dis.rst:1123
msgid "Works as :opcode:`BUILD_TUPLE`, but creates a set."
msgstr "Funciona como :opcode:`BUILD_TUPLE`, pero crea un conjunto."

#: ../Doc/library/dis.rst:1128
msgid ""
"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]}``."
msgstr ""
"Inserta un nuevo objeto de diccionario en la pila. Extrae elementos ``2 * "
"count`` para que el diccionario contenga entradas *count*: ``{..., "
"STACK[-4]: STACK[-3], STACK[-2]: STACK[-1]}``."

#: ../Doc/library/dis.rst:1132
msgid ""
"The dictionary is created from stack items instead of creating an empty "
"dictionary pre-sized to hold *count* items."
msgstr ""
"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."

#: ../Doc/library/dis.rst:1139
msgid ""
"The version of :opcode:`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."
msgstr ""
"La versión de :opcode:`BUILD_MAP` especializada para claves constantes. "
"Extrae el elemento superior de la pila que contiene una tupla de claves y, a "
"partir de ``STACK[-2]``, extrae los valores de *count* para formar valores "
"en el diccionario creado."

#: ../Doc/library/dis.rst:1148
msgid ""
"Concatenates *count* strings from the stack and pushes the resulting string "
"onto the stack."
msgstr ""
"Concatena *count* cadenas de caracteres de la pila y empuja la cadena de "
"caracteres resultante en la pila."

#: ../Doc/library/dis.rst:1158
msgid ""
"seq = STACK.pop()\n"
"list.extend(STACK[-i], seq)"
msgstr ""
"seq = STACK.pop()\n"
"list.extend(STACK[-i], seq)"

#: ../Doc/library/dis.rst:1161
msgid "Used to build lists."
msgstr "Se utiliza para crear listas."

#: ../Doc/library/dis.rst:1170
msgid ""
"seq = STACK.pop()\n"
"set.update(STACK[-i], seq)"
msgstr ""
"seq = STACK.pop()\n"
"set.update(STACK[-i], seq)"

#: ../Doc/library/dis.rst:1173
msgid "Used to build sets."
msgstr "Se utiliza para construir decorados."

#: ../Doc/library/dis.rst:1182
msgid ""
"map = STACK.pop()\n"
"dict.update(STACK[-i], map)"
msgstr ""
"map = STACK.pop()\n"
"dict.update(STACK[-i], map)"

#: ../Doc/library/dis.rst:1185
msgid "Used to build dicts."
msgstr "Se utiliza para crear diccionarios."

#: ../Doc/library/dis.rst:1192
msgid "Like :opcode:`DICT_UPDATE` but raises an exception for duplicate keys."
msgstr ""
"Como :opcode:`DICT_UPDATE` pero lanza una excepción para claves duplicadas."

#: ../Doc/library/dis.rst:1199
msgid ""
"If the low bit of ``namei`` is not set, this replaces ``STACK[-1]`` with "
"``getattr(STACK[-1], co_names[namei>>1])``."
msgstr ""
"Si el bit bajo de ``namei`` no está configurado, esto reemplaza "
"``STACK[-1]`` con ``getattr(STACK[-1], co_names[namei>>1])``."

#: ../Doc/library/dis.rst:1202
msgid ""
"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 :opcode:`CALL` or :opcode:`CALL_KW` when calling the unbound method. "
"Otherwise, ``NULL`` and the object returned by the attribute lookup are "
"pushed."
msgstr ""
"Si se establece el bit bajo de ``namei``, se intentará cargar un método "
"llamado ``co_names[namei>>1]`` desde el objeto ``STACK[-1]``. Se extrae "
"``STACK[-1]``. Este código de bytes distingue dos casos: si ``STACK[-1]`` "
"tiene un método con el nombre correcto, el código de bytes inserta el método "
"no vinculado y ``STACK[-1]``. :opcode:`CALL` o :opcode:`CALL_KW` utilizarán "
"``STACK[-1]`` como primer argumento (``self``) al llamar al método no "
"vinculado. De lo contrario, se insertan ``NULL`` y el objeto devuelto por la "
"búsqueda de atributos."

#: ../Doc/library/dis.rst:1211
msgid ""
"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."
msgstr ""
"Si se establece el bit bajo de ``namei``, entonces se inserta un ``NULL`` o "
"``self`` en la pila antes del atributo o el método no vinculado "
"respectivamente."

#: ../Doc/library/dis.rst:1218
msgid ""
"This opcode implements :func:`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``)."
msgstr ""
"Este código de operación implementa :func:`super`, tanto en su forma de cero "
"argumentos como de dos argumentos (por ejemplo, ``super().method()``, "
"``super().attr`` y ``super(cls, self).method()``, ``super(cls, self).attr``)."

#: ../Doc/library/dis.rst:1222
msgid "It pops three values from the stack (from top of stack down):"
msgstr ""
"Extrae tres valores de la pila (desde la parte superior de la pila hacia "
"abajo):"

#: ../Doc/library/dis.rst:1224
msgid "``self``: the first argument to the current method"
msgstr "``self``: el primer argumento del método actual"

#: ../Doc/library/dis.rst:1225
msgid "``cls``: the class within which the current method was defined"
msgstr "``cls``: la clase dentro de la cual se definió el método actual"

#: ../Doc/library/dis.rst:1226
msgid "the global ``super``"
msgstr "El ``super`` global"

#: ../Doc/library/dis.rst:1228
msgid ""
"With respect to its argument, it works similarly to :opcode:`LOAD_ATTR`, "
"except that ``namei`` is shifted left by 2 bits instead of 1."
msgstr ""
"Con respecto a su argumento, funciona de manera similar a :opcode:"
"`LOAD_ATTR`, excepto que ``namei`` se desplaza hacia la izquierda 2 bits en "
"lugar de 1."

#: ../Doc/library/dis.rst:1231
msgid ""
"The low bit of ``namei`` signals to attempt a method load, as with :opcode:"
"`LOAD_ATTR`, which results in pushing ``NULL`` and the loaded method. When "
"it is unset a single value is pushed to the stack."
msgstr ""
"El bit bajo de ``namei`` indica que se debe intentar cargar un método, como "
"en el caso de :opcode:`LOAD_ATTR`, lo que da como resultado la inserción de "
"``NULL`` y el método cargado. Cuando no está configurado, se inserta un solo "
"valor en la pila."

#: ../Doc/library/dis.rst:1235
msgid ""
"The second-low bit of ``namei``, if set, means that this was a two-argument "
"call to :func:`super` (unset means zero-argument)."
msgstr ""
"El segundo bit bajo de ``namei``, si está configurado, significa que esta "
"fue una llamada de dos argumentos a :func:`super` (si no está configurado "
"significa cero argumentos)."

#: ../Doc/library/dis.rst:1243
msgid ""
"Performs a Boolean operation.  The operation name can be found in "
"``cmp_op[opname >> 5]``. If the fifth-lowest bit of ``opname`` is set "
"(``opname & 16``), the result should be coerced to ``bool``."
msgstr ""
"Realiza una operación booleana. El nombre de la operación se puede encontrar "
"en ``cmp_op[opname >> 5]``. Si se establece el quinto bit más bajo de "
"``opname`` (``opname & 16``), el resultado se debe convertir a ``bool``."

#: ../Doc/library/dis.rst:1247
msgid ""
"The fifth-lowest bit of the oparg now indicates a forced conversion to :"
"class:`bool`."
msgstr ""
"El quinto bit más bajo del oparg ahora indica una conversión forzada a :"
"class:`bool`."

#: ../Doc/library/dis.rst:1254
msgid "Performs ``is`` comparison, or ``is not`` if ``invert`` is 1."
msgstr "Realiza una comparación ``is`` o ``is not`` si ``invert`` es 1."

#: ../Doc/library/dis.rst:1261
msgid "Performs ``in`` comparison, or ``not in`` if ``invert`` is 1."
msgstr "Realiza una comparación ``in`` o ``not in`` si ``invert`` es 1."

#: ../Doc/library/dis.rst:1268
msgid ""
"Imports the module ``co_names[namei]``.  ``STACK[-1]`` and ``STACK[-2]`` are "
"popped and provide the *fromlist* and *level* arguments of :func:"
"`__import__`. The module object is pushed onto the stack.  The current "
"namespace is not affected: for a proper import statement, a subsequent :"
"opcode:`STORE_FAST` instruction modifies the namespace."
msgstr ""
"Importa el módulo ``co_names[namei]``. Se extraen ``STACK[-1]`` y "
"``STACK[-2]`` y proporcionan los argumentos *fromlist* y *level* de :func:"
"`__import__`. El objeto del módulo se coloca en la pila. El espacio de "
"nombres actual no se ve afectado: para una declaración de importación "
"adecuada, una instrucción :opcode:`STORE_FAST` posterior modifica el espacio "
"de nombres."

#: ../Doc/library/dis.rst:1276
msgid ""
"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 :opcode:`STORE_FAST` instruction."
msgstr ""
"Carga el atributo ``co_names[namei]`` del módulo que se encuentra en "
"``STACK[-1]``. El objeto resultante se coloca en la pila para ser almacenado "
"posteriormente mediante una instrucción :opcode:`STORE_FAST`."

#: ../Doc/library/dis.rst:1283
msgid "Increments bytecode counter by *delta*."
msgstr "Incrementa el contador de bytecode en *delta*."

#: ../Doc/library/dis.rst:1288
msgid "Decrements bytecode counter by *delta*. Checks for interrupts."
msgstr ""
"Decrementa el contador de bytecode en *delta*. Comprueba si hay "
"interrupciones."

#: ../Doc/library/dis.rst:1295
msgid "Decrements bytecode counter by *delta*. Does not check for interrupts."
msgstr ""
"Decrementa el contador de bytecode en *delta*. No busca interrupciones."

#: ../Doc/library/dis.rst:1302
msgid ""
"If ``STACK[-1]`` is true, increments the bytecode counter by *delta*. "
"``STACK[-1]`` is popped."
msgstr ""
"Si ``STACK[-1]`` es verdadero, incrementa el contador de bytecode en "
"*delta*. Se elimina ``STACK[-1]``."

#: ../Doc/library/dis.rst:1305 ../Doc/library/dis.rst:1321
msgid ""
"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)."
msgstr ""
"El oparg ahora es un delta relativo en lugar de un objetivo absoluto. Este "
"código de operación es una pseudoinstrucción, reemplazada en el bytecode "
"final por las versiones dirigidas (hacia adelante/hacia atrás)."

#: ../Doc/library/dis.rst:1310 ../Doc/library/dis.rst:1326
#: ../Doc/library/dis.rst:1342 ../Doc/library/dis.rst:1356
msgid "This is no longer a pseudo-instruction."
msgstr "Esto ya no es una pseudoinstrucción."

#: ../Doc/library/dis.rst:1318
msgid ""
"If ``STACK[-1]`` is false, increments the bytecode counter by *delta*. "
"``STACK[-1]`` is popped."
msgstr ""
"Si ``STACK[-1]`` es falso, incrementa el contador de bytecode en *delta*. Se "
"elimina ``STACK[-1]``."

#: ../Doc/library/dis.rst:1334
msgid ""
"If ``STACK[-1]`` is not ``None``, increments the bytecode counter by "
"*delta*. ``STACK[-1]`` is popped."
msgstr ""
"Si ``STACK[-1]`` no es ``None``, incrementa el contador de bytecode en "
"*delta*. Se elimina ``STACK[-1]``."

#: ../Doc/library/dis.rst:1337 ../Doc/library/dis.rst:1351
msgid ""
"This opcode is a pseudo-instruction, replaced in final bytecode by the "
"directed versions (forward/backward)."
msgstr ""
"Este código de operación es una pseudoinstrucción, reemplazada en el código "
"de bytes final por las versiones dirigidas (adelante/atrás)."

#: ../Doc/library/dis.rst:1348
msgid ""
"If ``STACK[-1]`` is ``None``, increments the bytecode counter by *delta*. "
"``STACK[-1]`` is popped."
msgstr ""
"Si ``STACK[-1]`` es ``None``, incrementa el contador de bytecode en *delta*. "
"Se elimina ``STACK[-1]``."

#: ../Doc/library/dis.rst:1361
msgid ""
"``STACK[-1]`` is an :term:`iterator`.  Call its :meth:`~iterator.__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*."
msgstr ""
"``STACK[-1]`` es un :term:`iterator`. Llama a su método :meth:`~iterator."
"__next__`. Si esto produce un nuevo valor, colócalo en la pila (dejando el "
"iterador debajo de él). Si el iterador indica que está agotado, el contador "
"de código de bytes se incrementa en *delta*."

#: ../Doc/library/dis.rst:1366
msgid "Up until 3.11 the iterator was popped when it was exhausted."
msgstr "Hasta la versión 3.11, el iterador se activaba cuando se agotaba."

#: ../Doc/library/dis.rst:1371
msgid "Loads the global named ``co_names[namei>>1]`` onto the stack."
msgstr "Carga el ``co_names[namei>>1]`` global llamado en la pila."

#: ../Doc/library/dis.rst:1373
msgid ""
"If the low bit of ``namei`` is set, then a ``NULL`` is pushed to the stack "
"before the global variable."
msgstr ""
"Si se establece el bit bajo de ``namei``, se agrega un ``NULL`` a la pila "
"antes de la variable global."

#: ../Doc/library/dis.rst:1379
msgid ""
"Pushes a reference to the local ``co_varnames[var_num]`` onto the stack."
msgstr "Apila una referencia al local ``co_varnames[var_num]`` sobre la pila."

#: ../Doc/library/dis.rst:1381
msgid ""
"This opcode is now only used in situations where the local variable is "
"guaranteed to be initialized. It cannot raise :exc:`UnboundLocalError`."
msgstr ""
"Este código de operación ahora solo se utiliza en situaciones en las que se "
"garantiza que la variable local se inicializará. No puede generar :exc:"
"`UnboundLocalError`."

#: ../Doc/library/dis.rst:1387
msgid ""
"Pushes a reference to the local ``co_varnames[var_num]`` onto the stack, "
"raising an :exc:`UnboundLocalError` if the local variable has not been "
"initialized."
msgstr ""
"Inserta una referencia al ``co_varnames[var_num]`` local en la pila y genera "
"un :exc:`UnboundLocalError` si la variable local no se ha inicializado."

#: ../Doc/library/dis.rst:1395
msgid ""
"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``."
msgstr ""
"Inserta una referencia al ``co_varnames[var_num]`` local en la pila (o "
"inserta ``NULL`` en la pila si la variable local no se ha inicializado) y "
"establece ``co_varnames[var_num]`` en ``NULL``."

#: ../Doc/library/dis.rst:1403
msgid "Stores ``STACK.pop()`` into the local ``co_varnames[var_num]``."
msgstr "Almacena ``STACK.pop()`` en el ``co_varnames[var_num]`` local."

#: ../Doc/library/dis.rst:1408
msgid "Deletes local ``co_varnames[var_num]``."
msgstr "Elimina la ``co_varnames[var_num]`` local."

#: ../Doc/library/dis.rst:1413
msgid ""
"Creates a new cell in slot ``i``.  If that slot is nonempty then that value "
"is stored into the new cell."
msgstr ""
"Crea una nueva celda en la ranura ``i``. Si esa ranura no está vacía, ese "
"valor se almacena en la nueva celda."

#: ../Doc/library/dis.rst:1421
msgid ""
"Loads the cell contained in slot ``i`` of the \"fast locals\" storage. "
"Pushes a reference to the object the cell contains on the stack."
msgstr ""
"Carga la celda contenida en el slot ``i`` del almacenamiento \"fast "
"locals\". Agrega una referencia al objeto que contiene la celda en la pila."

#: ../Doc/library/dis.rst:1424 ../Doc/library/dis.rst:1446
#: ../Doc/library/dis.rst:1457
msgid ""
"``i`` is no longer offset by the length of :attr:`~codeobject.co_varnames`."
msgstr ""
"``i`` ya no está compensado por la longitud de :attr:`~codeobject."
"co_varnames`."

#: ../Doc/library/dis.rst:1430
msgid ""
"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 :"
"opcode:`LOAD_DEREF`. This is used for loading free variables in class bodies "
"(which previously used :opcode:`!LOAD_CLASSDEREF`) and in :ref:`annotation "
"scopes <annotation-scopes>` within class bodies."
msgstr ""
"Extrae una asignación de la pila y busca el nombre asociado con la ranura "
"``i`` del almacenamiento de \"variables locales rápidas\" en esta "
"asignación. Si no se encuentra el nombre allí, lo carga desde la celda "
"contenida en la ranura ``i``, de manera similar a :opcode:`LOAD_DEREF`. Esto "
"se utiliza para cargar variables libres en cuerpos de clase (que "
"anteriormente utilizaban :opcode:`!LOAD_CLASSDEREF`) y en :ref:`annotation "
"scopes <annotation-scopes>` dentro de cuerpos de clase."

#: ../Doc/library/dis.rst:1443
msgid ""
"Stores ``STACK.pop()`` into the cell contained in slot ``i`` of the \"fast "
"locals\" storage."
msgstr ""
"Almacena ``STACK.pop()`` en la celda contenida en la ranura ``i`` del "
"almacenamiento de \"locales rápidos\"."

#: ../Doc/library/dis.rst:1452
msgid ""
"Empties the cell contained in slot ``i`` of the \"fast locals\" storage. "
"Used by the :keyword:`del` statement."
msgstr ""
"Vacía la celda contenida en la ranura ``i`` del almacenamiento de \"locales "
"rápidos\". Utilizado por la instrucción :keyword:`del`."

#: ../Doc/library/dis.rst:1463
msgid ""
"Copies the ``n`` free variables from the closure into the frame. Removes the "
"need for special code on the caller's side when calling closures."
msgstr ""
"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."

#: ../Doc/library/dis.rst:1472
msgid ""
"Raises an exception using one of the 3 forms of the ``raise`` statement, "
"depending on the value of *argc*:"
msgstr ""
"Provoca una excepción utilizando una de las 3 formas de la declaración "
"``raise``, dependiendo del valor de *argc*:"

#: ../Doc/library/dis.rst:1475
msgid "0: ``raise`` (re-raise previous exception)"
msgstr "0: ``raise`` (vuelve a lanzar la excepción anterior)"

#: ../Doc/library/dis.rst:1476
msgid ""
"1: ``raise STACK[-1]`` (raise exception instance or type at ``STACK[-1]``)"
msgstr ""
"1: ``raise STACK[-1]`` (generar instancia o tipo de excepción en "
"``STACK[-1]``)"

#: ../Doc/library/dis.rst:1477
msgid ""
"2: ``raise STACK[-2] from STACK[-1]`` (raise exception instance or type at "
"``STACK[-2]`` with ``__cause__`` set to ``STACK[-1]``)"
msgstr ""
"2: ``raise STACK[-2] from STACK[-1]`` (generar una instancia o tipo de "
"excepción en ``STACK[-2]`` con ``__cause__`` establecido en ``STACK[-1]``)"

#: ../Doc/library/dis.rst:1483
msgid ""
"Calls a callable object with the number of arguments specified by ``argc``. "
"On the stack are (in ascending order):"
msgstr ""
"Llama a un objeto invocable con la cantidad de argumentos especificados por "
"``argc``. En la pila se encuentran (en orden ascendente):"

#: ../Doc/library/dis.rst:1486 ../Doc/library/dis.rst:1510
msgid "The callable"
msgstr "El llamable"

#: ../Doc/library/dis.rst:1487 ../Doc/library/dis.rst:1511
msgid "``self`` or ``NULL``"
msgstr "``self`` o ``NULL``"

#: ../Doc/library/dis.rst:1488 ../Doc/library/dis.rst:1512
msgid "The remaining positional arguments"
msgstr "Los argumentos posicionales restantes"

#: ../Doc/library/dis.rst:1490
msgid "``argc`` is the total of the positional arguments, excluding ``self``."
msgstr ""
"``argc`` es el total de los argumentos posicionales, excluyendo ``self``."

#: ../Doc/library/dis.rst:1492
msgid ""
"``CALL`` pops all arguments and the callable object off the stack, calls the "
"callable object with those arguments, and pushes the return value returned "
"by the callable object."
msgstr ""
"``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."

#: ../Doc/library/dis.rst:1498
msgid "The callable now always appears at the same position on the stack."
msgstr ""
"El objeto invocable ahora siempre aparece en la misma posición en la pila."

#: ../Doc/library/dis.rst:1501
msgid "Calls with keyword arguments are now handled by :opcode:`CALL_KW`."
msgstr ""
"Las llamadas con argumentos de palabras clave ahora son manejadas por :"
"opcode:`CALL_KW`."

#: ../Doc/library/dis.rst:1507
msgid ""
"Calls a callable object with the number of arguments specified by ``argc``, "
"including one or more named arguments. On the stack are (in ascending order):"
msgstr ""
"Llama a un objeto invocable con la cantidad de argumentos especificados por "
"``argc``, incluidos uno o más argumentos nombrados. En la pila se encuentran "
"(en orden ascendente):"

#: ../Doc/library/dis.rst:1513
msgid "The named arguments"
msgstr "Los argumentos nombrados"

#: ../Doc/library/dis.rst:1514
msgid "A :class:`tuple` of keyword argument names"
msgstr "Un :class:`tuple` de nombres de argumentos de palabras clave"

#: ../Doc/library/dis.rst:1516
msgid ""
"``argc`` is the total of the positional and named arguments, excluding "
"``self``. The length of the tuple of keyword argument names is the number of "
"named arguments."
msgstr ""
"``argc`` es el total de argumentos posicionales y nombrados, excluido "
"``self``. La longitud de la tupla de nombres de argumentos de palabras clave "
"es la cantidad de argumentos nombrados."

#: ../Doc/library/dis.rst:1519
msgid ""
"``CALL_KW`` pops all arguments, the keyword names, and the callable object "
"off the stack, calls the callable object with those arguments, and pushes "
"the return value returned by the callable object."
msgstr ""
"``CALL_KW`` extrae todos los argumentos, los nombres de palabras clave y el "
"objeto invocable de la pila, llama al objeto invocable con esos argumentos y "
"envía el valor de retorno devuelto por el objeto invocable."

#: ../Doc/library/dis.rst:1528
msgid ""
"Calls a callable object with variable set of positional and keyword "
"arguments.  If the lowest bit of *flags* is set, the top of the stack "
"contains a mapping object containing additional keyword arguments. Before "
"the callable is called, the mapping object and iterable object are each "
"\"unpacked\" and their contents passed in as keyword and positional "
"arguments respectively. ``CALL_FUNCTION_EX`` pops all arguments and the "
"callable object off the stack, calls the callable object with those "
"arguments, and pushes the return value returned by the callable object."
msgstr ""
"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."

#: ../Doc/library/dis.rst:1543
msgid ""
"Pushes a ``NULL`` to the stack. Used in the call sequence to match the "
"``NULL`` pushed by :opcode:`LOAD_METHOD` for non-method calls."
msgstr ""
"Agrega un ``NULL`` a la pila. Se usa en la secuencia de llamadas para hacer "
"coincidir el ``NULL`` enviado por :opcode:`LOAD_METHOD` para llamadas que no "
"son de método."

#: ../Doc/library/dis.rst:1552
msgid ""
"Pushes a new function object on the stack built from the code object at "
"``STACK[1]``."
msgstr ""
"Inserta un nuevo objeto de función en la pila creado a partir del objeto de "
"código en ``STACK[1]``."

#: ../Doc/library/dis.rst:1554
msgid "Flag value ``0x04`` is a tuple of strings instead of dictionary"
msgstr ""
"El valor indicador ``0x04`` es una tupla de cadena de caracteres en vez de "
"un diccionario"

#: ../Doc/library/dis.rst:1557
msgid "Qualified name at ``STACK[-1]`` was removed."
msgstr "Se eliminó el nombre calificado en ``STACK[-1]``."

#: ../Doc/library/dis.rst:1560
msgid ""
"Extra function attributes on the stack, signaled by oparg flags, were "
"removed. They now use :opcode:`SET_FUNCTION_ATTRIBUTE`."
msgstr ""
"Se eliminaron los atributos de funciones adicionales en la pila, señalados "
"por indicadores oparg. Ahora utilizan :opcode:`SET_FUNCTION_ATTRIBUTE`."

#: ../Doc/library/dis.rst:1567
msgid ""
"Sets an attribute on a function object. Expects the function at "
"``STACK[-1]`` and the attribute value to set at ``STACK[-2]``; consumes both "
"and leaves the function at ``STACK[-1]``. The flag determines which "
"attribute to set:"
msgstr ""
"Establece un atributo en un objeto de función. Espera que la función esté en "
"``STACK[-1]`` y que el valor del atributo esté establecido en ``STACK[-2]``; "
"consume ambos y deja la función en ``STACK[-1]``. El indicador determina qué "
"atributo se debe establecer:"

#: ../Doc/library/dis.rst:1571
msgid ""
"``0x01`` a tuple of default values for positional-only and positional-or-"
"keyword parameters in positional order"
msgstr ""
"``0x01``, una tupla de valores predeterminados para solo parámetros "
"posicionales y posicionales o de palabras clave en orden posicional"

#: ../Doc/library/dis.rst:1573
msgid "``0x02`` a dictionary of keyword-only parameters' default values"
msgstr ""
"``0x02`` un diccionario de valores predeterminados de solo palabras clave"

#: ../Doc/library/dis.rst:1574
msgid "``0x04`` a tuple of strings containing parameters' annotations"
msgstr ""
"``0x04`` una tupla de cadenas de caracteres que contiene anotaciones de "
"parámetros"

#: ../Doc/library/dis.rst:1575
msgid "``0x08`` a tuple containing cells for free variables, making a closure"
msgstr ""
"``0x08`` una tupla que contiene celdas para variables libres, haciendo un "
"cierre (*closure*)"

#: ../Doc/library/dis.rst:1584
msgid ""
"Pushes a slice object on the stack.  *argc* must be 2 or 3.  If it is 2, "
"implements::"
msgstr ""
"Coloca un objeto de segmento en la pila. *argc* debe ser 2 o 3. Si es 2, "
"implementa:"

#: ../Doc/library/dis.rst:1586
msgid ""
"end = STACK.pop()\n"
"start = STACK.pop()\n"
"STACK.append(slice(start, end))"
msgstr ""
"end = STACK.pop()\n"
"start = STACK.pop()\n"
"STACK.append(slice(start, end))"

#: ../Doc/library/dis.rst:1590
msgid "if it is 3, implements::"
msgstr "Si es 3, implementa::"

#: ../Doc/library/dis.rst:1592
msgid ""
"step = STACK.pop()\n"
"end = STACK.pop()\n"
"start = STACK.pop()\n"
"STACK.append(slice(start, end, step))"
msgstr ""
"step = STACK.pop()\n"
"end = STACK.pop()\n"
"start = STACK.pop()\n"
"STACK.append(slice(start, end, step))"

#: ../Doc/library/dis.rst:1597
msgid "See the :func:`slice` built-in function for more information."
msgstr ""
"Consulte la función incorporada :func:`slice` para obtener más información."

#: ../Doc/library/dis.rst:1602
msgid ""
"Prefixes any opcode which has an argument too big to fit into the default "
"one byte. *ext* holds an additional byte which act as higher bits in the "
"argument. For each opcode, at most three prefixal ``EXTENDED_ARG`` are "
"allowed, forming an argument from two-byte to four-byte."
msgstr ""
"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."

#: ../Doc/library/dis.rst:1610
msgid "Convert value to a string, depending on ``oparg``::"
msgstr "Convertir valor a cadena, dependiendo de ``oparg``::"

#: ../Doc/library/dis.rst:1612
msgid ""
"value = STACK.pop()\n"
"result = func(value)\n"
"STACK.append(result)"
msgstr ""
"value = STACK.pop()\n"
"result = func(value)\n"
"STACK.append(result)"

#: ../Doc/library/dis.rst:1616
msgid "``oparg == 1``: call :func:`str` on *value*"
msgstr "``oparg == 1``: llama :func:`str` con *value*"

#: ../Doc/library/dis.rst:1617
msgid "``oparg == 2``: call :func:`repr` on *value*"
msgstr "``oparg == 2``: llama :func:`repr` con *value*"

#: ../Doc/library/dis.rst:1618
msgid "``oparg == 3``: call :func:`ascii` on *value*"
msgstr "``oparg == 3``: llama :func:`ascii` con *value*"

#: ../Doc/library/dis.rst:1620 ../Doc/library/dis.rst:1633
#: ../Doc/library/dis.rst:1646
msgid "Used for implementing formatted literal strings (f-strings)."
msgstr "Se utiliza para implementar cadenas literales formateadas (f-strings)."

#: ../Doc/library/dis.rst:1627
msgid "Formats the value on top of stack::"
msgstr "Formatea el valor en la parte superior de la pila::"

#: ../Doc/library/dis.rst:1629
msgid ""
"value = STACK.pop()\n"
"result = value.__format__(\"\")\n"
"STACK.append(result)"
msgstr ""
"value = STACK.pop()\n"
"result = value.__format__(\"\")\n"
"STACK.append(result)"

#: ../Doc/library/dis.rst:1639
msgid "Formats the given value with the given format spec::"
msgstr "Formatea el valor dado con la especificación de formato dada::"

#: ../Doc/library/dis.rst:1641
msgid ""
"spec = STACK.pop()\n"
"value = STACK.pop()\n"
"result = value.__format__(spec)\n"
"STACK.append(result)"
msgstr ""
"spec = STACK.pop()\n"
"value = STACK.pop()\n"
"result = value.__format__(spec)\n"
"STACK.append(result)"

#: ../Doc/library/dis.rst:1653
msgid ""
"``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."
msgstr ""
"``STACK[-1]`` es una tupla de nombres de atributos de palabras clave, "
"``STACK[-2]`` es la clase con la que se realiza la comparación y "
"``STACK[-3]`` es el sujeto de la comparación. *count* es la cantidad de "
"subpatrones posicionales."

#: ../Doc/library/dis.rst:1657
msgid ""
"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``."
msgstr ""
"Inserte ``STACK[-1]``, ``STACK[-2]`` y ``STACK[-3]``. Si ``STACK[-3]`` es "
"una instancia de ``STACK[-2]`` y tiene los atributos posicionales y de "
"palabras clave requeridos por *count* y ``STACK[-1]``, inserte una tupla de "
"atributos extraídos. De lo contrario, inserte ``None``."

#: ../Doc/library/dis.rst:1671
msgid "A no-op. Performs internal tracing, debugging and optimization checks."
msgstr ""
"Un no-op. Realiza comprobaciones internas de seguimiento, depuración y "
"optimización."

#: ../Doc/library/dis.rst:1673
msgid ""
"The ``context`` oparand consists of two parts. The lowest two bits indicate "
"where the ``RESUME`` occurs:"
msgstr ""
"El operando ``context`` consta de dos partes. Los dos bits más bajos indican "
"dónde se encuentra el ``RESUME``:"

#: ../Doc/library/dis.rst:1676
msgid ""
"``0`` The start of a function, which is neither a generator, coroutine nor "
"an async generator"
msgstr ""
"``0`` El inicio de una función, que no es un generador, ni una corrutina ni "
"un generador asíncrono"

#: ../Doc/library/dis.rst:1678
msgid "``1`` After a ``yield`` expression"
msgstr "``1`` Después de una expresión ``yield``"

#: ../Doc/library/dis.rst:1679
msgid "``2`` After a ``yield from`` expression"
msgstr "``2`` Después de una expresión ``yield from``"

#: ../Doc/library/dis.rst:1680
msgid "``3`` After an ``await`` expression"
msgstr "``3`` Después de una expresión ``await``"

#: ../Doc/library/dis.rst:1682
msgid ""
"The next bit is ``1`` if the RESUME is at except-depth ``1``, and ``0`` "
"otherwise."
msgstr ""
"El siguiente bit es ``1`` si RESUME está en la profundidad de excepción "
"``1``, y ``0`` en caso contrario."

#: ../Doc/library/dis.rst:1687
msgid "The oparg value changed to include information about except-depth"
msgstr "El valor de oparg cambió para incluir información sobre except-depth"

#: ../Doc/library/dis.rst:1693
msgid ""
"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."
msgstr ""
"Crea un generador, una corrutina o un generador asincrónico a partir del "
"marco actual. Se utiliza como primer código de operación del objeto de "
"código para los elementos invocables mencionados anteriormente. Borra el "
"marco actual y devuelve el generador recién creado."

#: ../Doc/library/dis.rst:1702
msgid ""
"Equivalent to ``STACK[-1] = STACK[-2].send(STACK[-1])``. Used in ``yield "
"from`` and ``await`` statements."
msgstr ""
"Equivalente a ``STACK[-1] = STACK[-2].send(STACK[-1])``. Se utiliza en las "
"instrucciones ``yield from`` y ``await``."

#: ../Doc/library/dis.rst:1705
msgid ""
"If the call raises :exc:`StopIteration`, pop the top value from the stack, "
"push the exception's ``value`` attribute, and increment the bytecode counter "
"by *delta*."
msgstr ""
"Si la llamada genera :exc:`StopIteration`, extrae el valor superior de la "
"pila, inserta el atributo ``value`` de la excepción e incrementa el contador "
"de bytecode en *delta*."

#: ../Doc/library/dis.rst:1714
msgid ""
"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)."
msgstr ""
"En realidad, no se trata de un código de operación. Identifica la línea "
"divisoria entre los códigos de operación en el rango [0,255] que no utilizan "
"su argumento y los que sí lo hacen (``< HAVE_ARGUMENT`` y ``>= "
"HAVE_ARGUMENT``, respectivamente)."

#: ../Doc/library/dis.rst:1718
msgid ""
"If your application uses pseudo instructions or specialized instructions, "
"use the :data:`hasarg` collection instead."
msgstr ""
"Si su aplicación utiliza pseudoinstrucciones o instrucciones especializadas, "
"utilice la colección :data:`hasarg` en su lugar."

#: ../Doc/library/dis.rst:1721
msgid ""
"Now every instruction has an argument, but opcodes ``< HAVE_ARGUMENT`` "
"ignore it. Before, only opcodes ``>= HAVE_ARGUMENT`` had an argument."
msgstr ""
"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."

#: ../Doc/library/dis.rst:1725
msgid ""
"Pseudo instructions were added to the :mod:`dis` module, and for them it is "
"not true that comparison with ``HAVE_ARGUMENT`` indicates whether they use "
"their arg."
msgstr ""
"Se agregaron instrucciones pseudo al módulo :mod:`dis`, y para ellos no es "
"cierto que la comparación con ``HAVE_ARGUMENT`` indique si usan su argumento."

#: ../Doc/library/dis.rst:1730
msgid "Use :data:`hasarg` instead."
msgstr "Utilice :data:`hasarg` en su lugar."

#: ../Doc/library/dis.rst:1735
msgid ""
"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."
msgstr ""
"Llama a una función intrínseca con un argumento. Pasa ``STACK[-1]`` como "
"argumento y establece ``STACK[-1]`` como resultado. Se utiliza para "
"implementar una funcionalidad que no es crítica para el rendimiento."

#: ../Doc/library/dis.rst:1739 ../Doc/library/dis.rst:1793
msgid "The operand determines which intrinsic function is called:"
msgstr "El operando determina qué función intrínseca se llama:"

#: ../Doc/library/dis.rst:1742 ../Doc/library/dis.rst:1796
msgid "Operand"
msgstr "Operando"

#: ../Doc/library/dis.rst:1742 ../Doc/library/dis.rst:1796
msgid "Description"
msgstr "Descripción"

#: ../Doc/library/dis.rst:1744
msgid "``INTRINSIC_1_INVALID``"
msgstr "``INTRINSIC_1_INVALID``"

#: ../Doc/library/dis.rst:1744 ../Doc/library/dis.rst:1798
msgid "Not valid"
msgstr "No válido"

#: ../Doc/library/dis.rst:1746
msgid "``INTRINSIC_PRINT``"
msgstr "``INTRINSIC_PRINT``"

#: ../Doc/library/dis.rst:1746
msgid "Prints the argument to standard out. Used in the REPL."
msgstr "Imprime el argumento en la salida estándar. Se utiliza en REPL."

#: ../Doc/library/dis.rst:1749
msgid "``INTRINSIC_IMPORT_STAR``"
msgstr "``INTRINSIC_IMPORT_STAR``"

#: ../Doc/library/dis.rst:1749
msgid "Performs ``import *`` for the named module."
msgstr "Ejecuta ``import *`` para el módulo nombrado."

#: ../Doc/library/dis.rst:1752
msgid "``INTRINSIC_STOPITERATION_ERROR``"
msgstr "``INTRINSIC_STOPITERATION_ERROR``"

#: ../Doc/library/dis.rst:1752
msgid "Extracts the return value from a ``StopIteration`` exception."
msgstr "Extrae el valor de retorno de una excepción ``StopIteration``."

#: ../Doc/library/dis.rst:1755
msgid "``INTRINSIC_ASYNC_GEN_WRAP``"
msgstr "``INTRINSIC_ASYNC_GEN_WRAP``"

#: ../Doc/library/dis.rst:1755
msgid "Wraps an async generator value"
msgstr "Envuelve un valor de generador asincrónico"

#: ../Doc/library/dis.rst:1757
msgid "``INTRINSIC_UNARY_POSITIVE``"
msgstr "``INTRINSIC_UNARY_POSITIVE``"

#: ../Doc/library/dis.rst:1757
msgid "Performs the unary ``+`` operation"
msgstr "Realiza la operación unaria ``+``"

#: ../Doc/library/dis.rst:1760
msgid "``INTRINSIC_LIST_TO_TUPLE``"
msgstr "``INTRINSIC_LIST_TO_TUPLE``"

#: ../Doc/library/dis.rst:1760
msgid "Converts a list to a tuple"
msgstr "Convierte una lista en una tupla"

#: ../Doc/library/dis.rst:1762
msgid "``INTRINSIC_TYPEVAR``"
msgstr "``INTRINSIC_TYPEVAR``"

#: ../Doc/library/dis.rst:1762
msgid "Creates a :class:`typing.TypeVar`"
msgstr "Crea un :class:`typing.TypeVar`"

#: ../Doc/library/dis.rst:1764
msgid "``INTRINSIC_PARAMSPEC``"
msgstr "``INTRINSIC_PARAMSPEC``"

#: ../Doc/library/dis.rst:1764
msgid "Creates a :class:`typing.ParamSpec`"
msgstr "Crea un :class:`typing.ParamSpec`"

#: ../Doc/library/dis.rst:1767
msgid "``INTRINSIC_TYPEVARTUPLE``"
msgstr "``INTRINSIC_TYPEVARTUPLE``"

#: ../Doc/library/dis.rst:1767
msgid "Creates a :class:`typing.TypeVarTuple`"
msgstr "Crea un :class:`typing.TypeVarTuple`"

#: ../Doc/library/dis.rst:1770
msgid "``INTRINSIC_SUBSCRIPT_GENERIC``"
msgstr "``INTRINSIC_SUBSCRIPT_GENERIC``"

#: ../Doc/library/dis.rst:1770
msgid "Returns :class:`typing.Generic` subscripted with the argument"
msgstr "Devuelve :class:`typing.Generic` subíndice con el argumento"

#: ../Doc/library/dis.rst:1773
msgid "``INTRINSIC_TYPEALIAS``"
msgstr "``INTRINSIC_TYPEALIAS``"

#: ../Doc/library/dis.rst:1773
msgid ""
"Creates a :class:`typing.TypeAliasType`; used in the :keyword:`type` "
"statement. The argument is a tuple of the type alias's name, type "
"parameters, and value."
msgstr ""
"Crea un :class:`typing.TypeAliasType`; se utiliza en la declaración :keyword:"
"`type`. El argumento es una tupla con el nombre del alias de tipo, los "
"parámetros de tipo y el valor."

#: ../Doc/library/dis.rst:1785
msgid ""
"Calls an intrinsic function with two arguments. Used to implement "
"functionality that is not performance critical::"
msgstr ""
"Llama a una función intrínseca con dos argumentos. Se utiliza para "
"implementar una funcionalidad que no es crítica para el rendimiento:"

#: ../Doc/library/dis.rst:1788
msgid ""
"arg2 = STACK.pop()\n"
"arg1 = STACK.pop()\n"
"result = intrinsic2(arg1, arg2)\n"
"STACK.append(result)"
msgstr ""
"arg2 = STACK.pop()\n"
"arg1 = STACK.pop()\n"
"result = intrinsic2(arg1, arg2)\n"
"STACK.append(result)"

#: ../Doc/library/dis.rst:1798
msgid "``INTRINSIC_2_INVALID``"
msgstr "``INTRINSIC_2_INVALID``"

#: ../Doc/library/dis.rst:1800
msgid "``INTRINSIC_PREP_RERAISE_STAR``"
msgstr "``INTRINSIC_PREP_RERAISE_STAR``"

#: ../Doc/library/dis.rst:1800
msgid "Calculates the :exc:`ExceptionGroup` to raise from a ``try-except*``."
msgstr ""
"Calcula el :exc:`ExceptionGroup` que se debe aumentar desde un ``try-"
"except*``."

#: ../Doc/library/dis.rst:1804
msgid "``INTRINSIC_TYPEVAR_WITH_BOUND``"
msgstr "``INTRINSIC_TYPEVAR_WITH_BOUND``"

#: ../Doc/library/dis.rst:1804
msgid "Creates a :class:`typing.TypeVar` with a bound."
msgstr "Crea un :class:`typing.TypeVar` con un límite."

#: ../Doc/library/dis.rst:1807
msgid "``INTRINSIC_TYPEVAR_WITH_CONSTRAINTS``"
msgstr "``INTRINSIC_TYPEVAR_WITH_CONSTRAINTS``"

#: ../Doc/library/dis.rst:1807
msgid "Creates a :class:`typing.TypeVar` with constraints."
msgstr "Crea un :class:`typing.TypeVar` con restricciones."

#: ../Doc/library/dis.rst:1811
msgid "``INTRINSIC_SET_FUNCTION_TYPE_PARAMS``"
msgstr "``INTRINSIC_SET_FUNCTION_TYPE_PARAMS``"

#: ../Doc/library/dis.rst:1811
msgid "Sets the ``__type_params__`` attribute of a function."
msgstr "Establece el atributo ``__type_params__`` de una función."

#: ../Doc/library/dis.rst:1818
msgid "**Pseudo-instructions**"
msgstr "**Pseudo-instrucciones**"

#: ../Doc/library/dis.rst:1820
msgid ""
"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."
msgstr ""
"Estos códigos de operación no aparecen en el código de bytes de Python. El "
"compilador los utiliza, pero se reemplazan por códigos de operación reales o "
"se eliminan antes de que se genere el código de bytes."

#: ../Doc/library/dis.rst:1825
msgid ""
"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``."
msgstr ""
"Configure un controlador de excepciones para el siguiente bloque de código. "
"Si se produce una excepción, el nivel de pila de valores se restaura a su "
"estado actual y el control se transfiere al controlador de excepciones en "
"``target``."

#: ../Doc/library/dis.rst:1832
msgid ""
"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``."
msgstr ""
"Como ``SETUP_FINALLY``, pero en caso de excepción también envía la última "
"instrucción (``lasti``) a la pila para que ``RERAISE`` pueda restaurarla. Si "
"se produce una excepción, el nivel de pila de valores y la última "
"instrucción del marco se restauran a su estado actual y el control se "
"transfiere al controlador de excepciones en ``target``."

#: ../Doc/library/dis.rst:1841
msgid ""
"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``."
msgstr ""
"Como ``SETUP_CLEANUP``, pero en caso de una excepción, se extrae un elemento "
"más de la pila antes de que el control se transfiera al controlador de "
"excepciones en ``target``."

#: ../Doc/library/dis.rst:1845
msgid ""
"This variant is used in :keyword:`with` and :keyword:`async with` "
"constructs, which push the return value of the context manager's :meth:"
"`~object.__enter__` or :meth:`~object.__aenter__` to the stack."
msgstr ""
"Esta variante se utiliza en las construcciones :keyword:`with` y :keyword:"
"`async with`, que envían el valor de retorno de :meth:`~object.__enter__` o :"
"meth:`~object.__aenter__` del administrador de contexto a la pila."

#: ../Doc/library/dis.rst:1852
msgid ""
"Marks the end of the code block associated with the last ``SETUP_FINALLY``, "
"``SETUP_CLEANUP`` or ``SETUP_WITH``."
msgstr ""
"Marca el final del bloque de código asociado con el último "
"``SETUP_FINALLY``, ``SETUP_CLEANUP`` o ``SETUP_WITH``."

#: ../Doc/library/dis.rst:1858
msgid ""
"Undirected relative jump instructions which are replaced by their directed "
"(forward/backward) counterparts by the assembler."
msgstr ""
"Instrucciones de salto relativo no dirigido que son reemplazadas por sus "
"contrapartes dirigidas (hacia adelante/hacia atrás) por el ensamblador."

#: ../Doc/library/dis.rst:1863
msgid ""
"Pushes a reference to the cell contained in slot ``i`` of the \"fast "
"locals\" storage."
msgstr ""
"Envía una referencia a la celda contenida en la ranura ``i`` del "
"almacenamiento de \"valores locales rápidos\"."

#: ../Doc/library/dis.rst:1866
msgid ""
"Note that ``LOAD_CLOSURE`` is replaced with ``LOAD_FAST`` in the assembler."
msgstr ""
"Tenga en cuenta que ``LOAD_CLOSURE`` se reemplaza con ``LOAD_FAST`` en el "
"ensamblador."

#: ../Doc/library/dis.rst:1868
msgid "This opcode is now a pseudo-instruction."
msgstr "Este código de operación ahora es una pseudoinstrucción."

#: ../Doc/library/dis.rst:1874
msgid ""
"Optimized unbound method lookup. Emitted as a ``LOAD_ATTR`` opcode with a "
"flag set in the arg."
msgstr ""
"Búsqueda de método no enlazado optimizada. Se emite como un código de "
"operación ``LOAD_ATTR`` con un indicador establecido en el argumento."

#: ../Doc/library/dis.rst:1881
msgid "Opcode collections"
msgstr "Colecciones opcode"

#: ../Doc/library/dis.rst:1883
msgid ""
"These collections are provided for automatic introspection of bytecode "
"instructions:"
msgstr ""
"Estas colecciones se proporcionan para la introspección automática de "
"instrucciones de bytecode:"

#: ../Doc/library/dis.rst:1886
msgid ""
"The collections now contain pseudo instructions and instrumented "
"instructions as well. These are opcodes with values ``>= MIN_PSEUDO_OPCODE`` "
"and ``>= MIN_INSTRUMENTED_OPCODE``."
msgstr ""
"Las colecciones ahora también contienen pseudoinstrucciones e instrucciones "
"instrumentadas. Se trata de códigos de operación con valores ``>= "
"MIN_PSEUDO_OPCODE`` y ``>= MIN_INSTRUMENTED_OPCODE``."

#: ../Doc/library/dis.rst:1893
msgid "Sequence of operation names, indexable using the bytecode."
msgstr "Secuencia de nombres de operaciones, indexable utilizando el bytecode."

#: ../Doc/library/dis.rst:1898
msgid "Dictionary mapping operation names to bytecodes."
msgstr "Nombres de operaciones de mapeo de diccionario a bytecodes."

#: ../Doc/library/dis.rst:1903
msgid "Sequence of all compare operation names."
msgstr "Secuencia de todos los nombres de operaciones de comparación."

#: ../Doc/library/dis.rst:1908
msgid "Sequence of bytecodes that use their argument."
msgstr "Secuencia de códigos de bytes que utilizan su argumento."

#: ../Doc/library/dis.rst:1915
msgid "Sequence of bytecodes that access a constant."
msgstr "Secuencia de bytecodes que acceden a una constante."

#: ../Doc/library/dis.rst:1920
msgid ""
"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."
msgstr ""
"Secuencia de códigos de bytes que acceden a una variable libre. \"libre\" en "
"este contexto se refiere a nombres en el ámbito actual a los que hacen "
"referencia los ámbitos internos o a nombres en ámbitos externos a los que "
"hace referencia este ámbito. *not* incluye referencias a ámbitos globales o "
"integrados."

#: ../Doc/library/dis.rst:1928
msgid "Sequence of bytecodes that access an attribute by name."
msgstr "Secuencia de bytecodes que acceden a un atributo por nombre."

#: ../Doc/library/dis.rst:1933
msgid "Sequence of bytecodes that have a jump target. All jumps are relative."
msgstr ""
"Secuencia de códigos de bytes que tienen un destino de salto. Todos los "
"saltos son relativos."

#: ../Doc/library/dis.rst:1940
msgid "Sequence of bytecodes that access a local variable."
msgstr "Secuencia de códigos de bytes que acceden a una variable local."

#: ../Doc/library/dis.rst:1945
msgid "Sequence of bytecodes of Boolean operations."
msgstr "Secuencia de bytecodes de operaciones booleanas."

#: ../Doc/library/dis.rst:1949
msgid "Sequence of bytecodes that set an exception handler."
msgstr ""
"Secuencia de códigos de bytes que establecen un controlador de excepciones."

#: ../Doc/library/dis.rst:1956
msgid "Sequence of bytecodes that have a relative jump target."
msgstr "Secuencia de bytecodes que tienen un objetivo de salto relativo."

#: ../Doc/library/dis.rst:1958
msgid "All jumps are now relative. Use :data:`hasjump`."
msgstr "Ahora todos los saltos son relativos. Utilice :data:`hasjump`."

#: ../Doc/library/dis.rst:1964
msgid "Sequence of bytecodes that have an absolute jump target."
msgstr "Secuencia de bytecodes que tienen un objetivo de salto absoluto."

#: ../Doc/library/dis.rst:1966
msgid "All jumps are now relative. This list is empty."
msgstr "Ahora todos los saltos son relativos. Esta lista está vacía."

#: ../Doc/library/dis.rst:1582
msgid "built-in function"
msgstr "función incorporada"

#: ../Doc/library/dis.rst:1582
msgid "slice"
msgstr "rebanada"