executionmodel.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: 2025-02-17 16:37-0500\n"
"Last-Translator: Francisco Mora <fr.morac@duocuc.cl>\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.5\n"

#: ../Doc/reference/executionmodel.rst:6
msgid "Execution model"
msgstr "Modelo de ejecución"

#: ../Doc/reference/executionmodel.rst:15
msgid "Structure of a program"
msgstr "Estructura de un programa"

#: ../Doc/reference/executionmodel.rst:19
msgid ""
"A Python program is constructed from code blocks. A :dfn:`block` is a piece "
"of Python program text that is executed as a unit. The following are blocks: "
"a module, a function body, and a class definition. Each command typed "
"interactively is a block.  A script file (a file given as standard input to "
"the interpreter or specified as a command line argument to the interpreter) "
"is a code block.  A script command (a command specified on the interpreter "
"command line with the :option:`-c` option) is a code block. A module run as "
"a top level script (as module ``__main__``) from the command line using a :"
"option:`-m` argument is also a code block. The string argument passed to the "
"built-in functions :func:`eval` and :func:`exec` is a code block."
msgstr ""
"Un programa de Python se construye a partir de bloques de código. Un :dfn:"
"`block` es una parte del texto del programa Python que se ejecuta como una "
"unidad. Los siguientes son bloques: un módulo, un cuerpo de función y una "
"definición de clase. Cada comando escrito de forma interactiva es un bloque. "
"Un archivo de secuencia de comandos (un archivo proporcionado como entrada "
"estándar al intérprete o especificado como un argumento de línea de comando "
"para el intérprete) es un bloque de código. Un comando de secuencia de "
"comandos (un comando especificado en la línea de comandos del intérprete con "
"la opción: :option:`-c`) es un bloque de código. Un módulo que se ejecuta "
"como un script de nivel superior (como módulo ``__main__``) desde la línea "
"de comando usando un argumento :option:`-m` también es un bloque de código. "
"El argumento de cadena pasado a las funciones integradas :func:`eval` y :"
"func:`exec` es un bloque de código."

#: ../Doc/reference/executionmodel.rst:33
msgid ""
"A code block is executed in an :dfn:`execution frame`.  A frame contains "
"some administrative information (used for debugging) and determines where "
"and how execution continues after the code block's execution has completed."
msgstr ""
"Un bloque de código se ejecuta en un :dfn:`execution frame`. Un marco "
"contiene alguna información administrativa (que se usa para depuración) y "
"determina dónde y cómo continuará la ejecución una vez que el bloque de "
"código se haya completado."

#: ../Doc/reference/executionmodel.rst:40
msgid "Naming and binding"
msgstr "Nombres y vínculos"

#: ../Doc/reference/executionmodel.rst:49
msgid "Binding of names"
msgstr "Vinculación de nombres"

#: ../Doc/reference/executionmodel.rst:55
msgid ""
":dfn:`Names` refer to objects.  Names are introduced by name binding "
"operations."
msgstr ""
"Los :dfn:`Names` refieren a objetos. Los nombres se introducen por las "
"operaciones de vinculación de nombre (*name binding operations*)."

#: ../Doc/reference/executionmodel.rst:59
msgid "The following constructs bind names:"
msgstr "Las siguientes construcciones enlazan nombres:"

#: ../Doc/reference/executionmodel.rst:61
msgid "formal parameters to functions,"
msgstr "parámetros formales de las funciones,"

#: ../Doc/reference/executionmodel.rst:62
msgid "class definitions,"
msgstr "definiciones de clase,"

#: ../Doc/reference/executionmodel.rst:63
msgid "function definitions,"
msgstr "definiciones de funciones,"

#: ../Doc/reference/executionmodel.rst:64
msgid "assignment expressions,"
msgstr "expresiones de asignación,"

#: ../Doc/reference/executionmodel.rst:65
msgid ""
":ref:`targets <assignment>` that are identifiers if occurring in an "
"assignment:"
msgstr ""
":ref:`targets <assignment>` que son identificadores si aparecen en una "
"asignación:"

#: ../Doc/reference/executionmodel.rst:68
msgid ":keyword:`for` loop header,"
msgstr "cabecera del bucle :keyword:`for`,"

#: ../Doc/reference/executionmodel.rst:69
msgid ""
"after :keyword:`!as` in a :keyword:`with` statement, :keyword:`except` "
"clause, :keyword:`except* <except_star>` clause, or in the as-pattern in "
"structural pattern matching,"
msgstr ""
"después de :keyword:`!as` en una declaración :keyword:`with`, cláusula :"
"keyword:`except`, cláusula :keyword:`except* <except_star>`, o en el patrón "
"as en la concordancia de patrones estructurales,"

#: ../Doc/reference/executionmodel.rst:71
msgid "in a capture pattern in structural pattern matching"
msgstr "en un patrón de captura en la concordancia de patrones estructurales"

#: ../Doc/reference/executionmodel.rst:73
msgid ":keyword:`import` statements."
msgstr "declaraciones :keyword:`import`."

#: ../Doc/reference/executionmodel.rst:74
msgid ":keyword:`type` statements."
msgstr "declaraciones :keyword:`type`."

#: ../Doc/reference/executionmodel.rst:75
msgid ":ref:`type parameter lists <type-params>`."
msgstr ":ref:`listas tipo de parámetros <type-params>`."

#: ../Doc/reference/executionmodel.rst:77
msgid ""
"The :keyword:`!import` statement of the form ``from ... import *`` binds all "
"names defined in the imported module, except those beginning with an "
"underscore. This form may only be used at the module level."
msgstr ""
"La declaración :keyword:`!import` de la forma ``from ... import *`` vincula "
"todos los nombres definidos en el módulo importado, excepto los que empiezan "
"por guión bajo. Esta forma sólo puede utilizarse a nivel de módulo."

#: ../Doc/reference/executionmodel.rst:81
msgid ""
"A target occurring in a :keyword:`del` statement is also considered bound "
"for this purpose (though the actual semantics are to unbind the name)."
msgstr ""
"Un objetivo que aparece en una sentencia :keyword:`del` también se considera "
"vinculado para este propósito (aunque la semántica real es desvincular el "
"nombre)."

#: ../Doc/reference/executionmodel.rst:84
msgid ""
"Each assignment or import statement occurs within a block defined by a class "
"or function definition or at the module level (the top-level code block)."
msgstr ""
"Cada declaración de asignación o importación ocurre dentro de un bloque "
"determinado por una definición de clase o de función, o a nivel de módulo "
"(el bloque de código de máximo nivel)."

#: ../Doc/reference/executionmodel.rst:89
msgid ""
"If a name is bound in a block, it is a local variable of that block, unless "
"declared as :keyword:`nonlocal` or :keyword:`global`.  If a name is bound at "
"the module level, it is a global variable.  (The variables of the module "
"code block are local and global.)  If a variable is used in a code block but "
"not defined there, it is a :dfn:`free variable`."
msgstr ""
"Si un nombre está vinculado en un bloque, es una variable local en ese "
"bloque, salvo que sea declarado como :keyword:`nonlocal` o :keyword:"
"`global`. Si un nombre está vinculado a nivel de módulo, es una variable "
"global. (Las variables del bloque de código del módulo son locales y "
"globales.) Si una variable se una en un bloque de código pero no está "
"definida ahí, es una :dfn:`free variable`."

#: ../Doc/reference/executionmodel.rst:95
msgid ""
"Each occurrence of a name in the program text refers to the :dfn:`binding` "
"of that name established by the following name resolution rules."
msgstr ""
"Cada ocurrencia de un nombre en el texto del programa se refiere al :dfn:"
"`binding` de ese nombre, establecido por las siguientes reglas de resolución "
"de nombres."

#: ../Doc/reference/executionmodel.rst:101
msgid "Resolution of names"
msgstr "Resolución de nombres"

#: ../Doc/reference/executionmodel.rst:105
msgid ""
"A :dfn:`scope` defines the visibility of a name within a block.  If a local "
"variable is defined in a block, its scope includes that block.  If the "
"definition occurs in a function block, the scope extends to any blocks "
"contained within the defining one, unless a contained block introduces a "
"different binding for the name."
msgstr ""
"Un :dfn:`scope` define la visibilidad de un nombre en un bloque. Si una "
"variable local se define en un bloque, su ámbito incluye ese bloque. Si la "
"definición ocurre en un bloque de función, el ámbito se extiende a cualquier "
"bloque contenido en el bloque en donde está la definición, a menos que uno "
"de los bloques contenidos introduzca un vínculo diferente para el nombre."

#: ../Doc/reference/executionmodel.rst:113
msgid ""
"When a name is used in a code block, it is resolved using the nearest "
"enclosing scope.  The set of all such scopes visible to a code block is "
"called the block's :dfn:`environment`."
msgstr ""
"Cuando un nombre es utilizado en un bloque de código, se resuelve utilizando "
"el ámbito de cierre más cercano. El conjunto de todos esos ámbitos visibles "
"para un bloque de código se llama el :dfn:`environment` del bloque."

#: ../Doc/reference/executionmodel.rst:121
msgid ""
"When a name is not found at all, a :exc:`NameError` exception is raised. If "
"the current scope is a function scope, and the name refers to a local "
"variable that has not yet been bound to a value at the point where the name "
"is used, an :exc:`UnboundLocalError` exception is raised. :exc:"
"`UnboundLocalError` is a subclass of :exc:`NameError`."
msgstr ""
"Cuando un nombre no se encuentra, se lanza una excepción :exc:`NameError`. "
"Si el ámbito actual es una función, y el nombre se refiere a una variable "
"local que todavía no ha sido vinculada a un valor en el punto en el que "
"nombre es utilizado, se lanza una excepción :exc:`UnboundLocalError`. :exc:"
"`UnboundLocalError` es una subclase de :exc:`NameError`."

#: ../Doc/reference/executionmodel.rst:127
msgid ""
"If a name binding operation occurs anywhere within a code block, all uses of "
"the name within the block are treated as references to the current block.  "
"This can lead to errors when a name is used within a block before it is "
"bound.  This rule is subtle.  Python lacks declarations and allows name "
"binding operations to occur anywhere within a code block.  The local "
"variables of a code block can be determined by scanning the entire text of "
"the block for name binding operations. See :ref:`the FAQ entry on "
"UnboundLocalError <faq-unboundlocalerror>` for examples."
msgstr ""
"Si una operación de vinculación de nombre ocurre en cualquier parte dentro "
"de un bloque de código, todos los usos del nombre dentro de ese bloque son "
"tratados como referencias al bloque actual. Esto puede llevar a errores "
"cuando el nombre es utilizado dentro del bloque antes de su vinculación. "
"Esta regla es sutil. Python carece de declaraciones y permite que las "
"operaciones de vinculación de nombres ocurran en cualquier lugar dentro del "
"bloque de código. Las variables locales de un bloque de código pueden "
"determinarse buscando operaciones de vinculación de nombres en el texto "
"completo del bloque. Ver :ref:`la entrada del FAQ sobre UnboundLocalError "
"<faq-unboundlocalerror>` para ejemplos."

#: ../Doc/reference/executionmodel.rst:136
msgid ""
"If the :keyword:`global` statement occurs within a block, all uses of the "
"names specified in the statement refer to the bindings of those names in the "
"top-level namespace.  Names are resolved in the top-level namespace by "
"searching the global namespace, i.e. the namespace of the module containing "
"the code block, and the builtins namespace, the namespace of the module :mod:"
"`builtins`.  The global namespace is searched first.  If the names are not "
"found there, the builtins namespace is searched next. If the names are also "
"not found in the builtins namespace, new variables are created in the global "
"namespace. The global statement must precede all uses of the listed names."
msgstr ""
"Si la declaración :keyword:`global` ocurre dentro de un bloque, todos los "
"usos del nombre especificado en la declaración se refieren a la vinculación "
"que ese nombre tiene en el espacio de nombres (*namespace*) de nivel "
"superior. Los nombres se resuelven en el espacio de nombres de nivel "
"superior buscando en el espacio de nombres global, es decir, el espacio de "
"nombres del módulo que contiene el bloque de código, y en el espacio de "
"nombres incorporado, el *namespace* del módulo :mod:`builtins`. La búsqueda "
"se realiza primero en el espacio de nombres global. Si el nombre no se "
"encuentra ahí, se busca en el espacio de nombres incorporado (*builtins "
"namespace*) próximamente. Si tampoco se encuentran los nombres en el espacio "
"de nombres incorporado, se crean variables nuevas en el espacio de nombres "
"global. La declaración global debe preceder a todos los usos de los nombres "
"listados."

#: ../Doc/reference/executionmodel.rst:146
msgid ""
"The :keyword:`global` statement has the same scope as a name binding "
"operation in the same block.  If the nearest enclosing scope for a free "
"variable contains a global statement, the free variable is treated as a "
"global."
msgstr ""
"La declaración :keyword:`global` tiene el mismo ámbito que una operación de "
"vinculación de nombre en el mismo bloque. Si el ámbito de cierre más cercano "
"para una variable libre contiene una declaración global, se trata a la "
"variable libre como global."

#: ../Doc/reference/executionmodel.rst:152
msgid ""
"The :keyword:`nonlocal` statement causes corresponding names to refer to "
"previously bound variables in the nearest enclosing function scope. :exc:"
"`SyntaxError` is raised at compile time if the given name does not exist in "
"any enclosing function scope. :ref:`Type parameters <type-params>` cannot be "
"rebound with the :keyword:`!nonlocal` statement."
msgstr ""
"La declaración :keyword:`nonlocal` causa que los nombre correspondientes se "
"refieran a variables previamente vinculadas en el ámbito de la función de "
"cierre más cercano. Se lanza un :exc:`SyntaxError` en tiempo de compilación "
"si el nombre dado no existe en ningún ámbito de las funciones dentro de las "
"cuales está. :ref:`Parámetros de tipo <type-params>` no puede recuperarse "
"con la sentencia :keyword:`!nonlocal`."

#: ../Doc/reference/executionmodel.rst:160
msgid ""
"The namespace for a module is automatically created the first time a module "
"is imported.  The main module for a script is always called :mod:`__main__`."
msgstr ""
"El espacio de nombres (*namespace*) para un módulo se crea automáticamente "
"la primera vez que se importa el módulo. El módulo principal de un *script* "
"siempre se llama :mod:`__main__`."

#: ../Doc/reference/executionmodel.rst:163
msgid ""
"Class definition blocks and arguments to :func:`exec` and :func:`eval` are "
"special in the context of name resolution. A class definition is an "
"executable statement that may use and define names. These references follow "
"the normal rules for name resolution with an exception that unbound local "
"variables are looked up in the global namespace. The namespace of the class "
"definition becomes the attribute dictionary of the class. The scope of names "
"defined in a class block is limited to the class block; it does not extend "
"to the code blocks of methods. This includes comprehensions and generator "
"expressions, but it does not include :ref:`annotation scopes <annotation-"
"scopes>`, which have access to their enclosing class scopes. This means that "
"the following will fail::"
msgstr ""
"Los bloques de definición de clase y los argumentos para :func:`exec` y :"
"func:`eval` son especiales en el contexto de la resolución de nombres. Una "
"definición de clase es una declaración ejecutable que puede usar y definir "
"nombres. Estas referencias siguen las reglas normales para la resolución de "
"nombres con la excepción de que se buscan las variables locales no "
"vinculadas en el espacio de nombres global. El espacio de nombres de la "
"definición de clase se vuelve el diccionario de atributos de la clase. El "
"ámbito de nombres definido en un bloque de clase está limitado a dicho "
"bloque; no se extiende a los bloques de código de los métodos. Esto incluye "
"las comprensiones y las expresiones generadoras pero no incluye :ref:"
"`annotation scopes <annotation-scopes>`, que tienen acceso a sus ámbitos de "
"clase adjuntos. Esto significa que lo siguiente fallará::"

#: ../Doc/reference/executionmodel.rst:176
msgid ""
"class A:\n"
"    a = 42\n"
"    b = list(a + i for i in range(10))"
msgstr ""
"class A:\n"
"    a = 42\n"
"    b = list(a + i for i in range(10))"

#: ../Doc/reference/executionmodel.rst:180
msgid "However, the following will succeed::"
msgstr "Sin embargo. lo siguiente tendrá éxito::"

#: ../Doc/reference/executionmodel.rst:182
msgid ""
"class A:\n"
"    type Alias = Nested\n"
"    class Nested: pass\n"
"\n"
"print(A.Alias.__value__)  # <type 'A.Nested'>"
msgstr ""
"class A:\n"
"    type Alias = Nested\n"
"    class Nested: pass\n"
"\n"
"print(A.Alias.__value__)  # <type 'A.Nested'>"

#: ../Doc/reference/executionmodel.rst:191
msgid "Annotation scopes"
msgstr "Ámbitos de anotación"

#: ../Doc/reference/executionmodel.rst:193
msgid ""
":ref:`Type parameter lists <type-params>` and :keyword:`type` statements "
"introduce *annotation scopes*, which behave mostly like function scopes, but "
"with some exceptions discussed below. :term:`Annotations <annotation>` "
"currently do not use annotation scopes, but they are expected to use "
"annotation scopes in Python 3.13 when :pep:`649` is implemented."
msgstr ""
":ref:`Las listas de tipo de parámetros <type-params>` y las declaraciones :"
"keyword:`type` introducen *ámbitos de anotación*, que se comportan "
"principalmente como ámbitos de funciones, pero con algunas excepciones que "
"se analizan a continuación. :term:`Annotations <annotation>` actualmente no "
"usan alcances de anotación, pero se espera que los usen en Python 3.13 "
"cuando se implemente :pep:`649`."

#: ../Doc/reference/executionmodel.rst:199
msgid "Annotation scopes are used in the following contexts:"
msgstr "Los ámbitos de anotación se utilizan en los siguientes contextos:"

#: ../Doc/reference/executionmodel.rst:201
msgid ""
"Type parameter lists for :ref:`generic type aliases <generic-type-aliases>`."
msgstr ""
"Listas de tipo de parámetros para :ref:`generic type aliases <generic-type-"
"aliases>`."

#: ../Doc/reference/executionmodel.rst:202
msgid ""
"Type parameter lists for :ref:`generic functions <generic-functions>`. A "
"generic function's annotations are executed within the annotation scope, but "
"its defaults and decorators are not."
msgstr ""
"Escriba listas de parámetros para :ref:`generic functions <generic-"
"functions>`. Las anotaciones de una función genérica se ejecutan dentro del "
"alcance de la anotación, pero sus valores predeterminados y decoradores no."

#: ../Doc/reference/executionmodel.rst:205
msgid ""
"Type parameter lists for :ref:`generic classes <generic-classes>`. A generic "
"class's base classes and keyword arguments are executed within the "
"annotation scope, but its decorators are not."
msgstr ""
"Tipo de parámetros de listas para :ref:`generic classes <generic-classes>`. "
"Las clases base y los argumentos de palabra clave de una clase genérica se "
"ejecutan dentro del ámbito de la anotación, pero sus decoradores no."

#: ../Doc/reference/executionmodel.rst:208
msgid ""
"The bounds, constraints, and default values for type parameters (:ref:"
"`lazily evaluated <lazy-evaluation>`)."
msgstr ""
"Los límites, restricciones y valores predeterminados para los parámetros de "
"tipo (:ref:`evaluados de forma diferida <lazy-evaluation>`)."

#: ../Doc/reference/executionmodel.rst:210
msgid "The value of type aliases (:ref:`lazily evaluated <lazy-evaluation>`)."
msgstr ""
"El valor de los alias de tipo (:ref:`lazy evaluated <lazy-evaluation>`)."

#: ../Doc/reference/executionmodel.rst:212
msgid "Annotation scopes differ from function scopes in the following ways:"
msgstr ""
"Los ámbitos de anotación difieren de los ámbitos de función en lo siguiente:"

#: ../Doc/reference/executionmodel.rst:214
msgid ""
"Annotation scopes have access to their enclosing class namespace. If an "
"annotation scope is immediately within a class scope, or within another "
"annotation scope that is immediately within a class scope, the code in the "
"annotation scope can use names defined in the class scope as if it were "
"executed directly within the class body. This contrasts with regular "
"functions defined within classes, which cannot access names defined in the "
"class scope."
msgstr ""
"Los ámbitos de anotación tienen acceso al espacio de nombres de la clase que "
"los rodea. Si un ámbito de anotación está inmediatamente dentro de un ámbito "
"de clase, o dentro de otro ámbito de anotación que está inmediatamente "
"dentro de un ámbito de clase, el código en el ámbito de anotación puede "
"utilizar nombres definidos en el ámbito de clase como si se ejecutara "
"directamente dentro del cuerpo de la clase. Esto contrasta con las funciones "
"normales definidas dentro de las clases, que no pueden acceder a los nombres "
"definidos en el ámbito de la clase."

#: ../Doc/reference/executionmodel.rst:220
msgid ""
"Expressions in annotation scopes cannot contain :keyword:`yield`, ``yield "
"from``, :keyword:`await`, or :token:`:= <python-grammar:"
"assignment_expression>` expressions. (These expressions are allowed in other "
"scopes contained within the annotation scope.)"
msgstr ""
"Las expresiones en ámbitos de anotación no pueden contener expresiones :"
"keyword:`yield`, ``yield from``, :keyword:`await`, o :token:`:= <python-"
"grammar:assignment_expression>`. (Estas expresiones están permitidas en "
"otros ámbitos contenidos dentro del ámbito de la anotación)."

#: ../Doc/reference/executionmodel.rst:224
msgid ""
"Names defined in annotation scopes cannot be rebound with :keyword:"
"`nonlocal` statements in inner scopes. This includes only type parameters, "
"as no other syntactic elements that can appear within annotation scopes can "
"introduce new names."
msgstr ""
"Los nombres definidos en ámbitos de anotación no pueden recuperarse con "
"sentencias :keyword:`nonlocal` en ámbitos internos. Esto incluye sólo "
"parámetros de tipo, ya que ningún otro elemento sintáctico que pueda "
"aparecer dentro de ámbitos de anotación puede introducir nuevos nombres."

#: ../Doc/reference/executionmodel.rst:227
msgid ""
"While annotation scopes have an internal name, that name is not reflected in "
"the :term:`qualified name` of objects defined within the scope. Instead, "
"the :attr:`~definition.__qualname__` of such objects is as if the object "
"were defined in the enclosing scope."
msgstr ""
"Aunque los ámbitos de anotación tienen un nombre interno, ese nombre no se "
"refleja en el :term:`qualified name` de los objetos definidos dentro del "
"ámbito. En su lugar, el :attr:`~definition.__qualname__` de dichos objetos "
"es como si el objeto estuviera definido en el ámbito que lo encierra."

#: ../Doc/reference/executionmodel.rst:232
msgid "Annotation scopes were introduced in Python 3.12 as part of :pep:`695`."
msgstr ""
"Los ámbitos de anotación se introdujeron en Python 3.12 como parte de :pep:"
"`695`."

#: ../Doc/reference/executionmodel.rst:235
msgid ""
"Annotation scopes are also used for type parameter defaults, as introduced "
"by :pep:`696`."
msgstr ""
"También se usan ámbitos de anotación para parámetros de tipo "
"predeterminados, introducido por :pep:`696`."

#: ../Doc/reference/executionmodel.rst:242
msgid "Lazy evaluation"
msgstr "Evaluación perezosa"

#: ../Doc/reference/executionmodel.rst:244
msgid ""
"The values of type aliases created through the :keyword:`type` statement are "
"*lazily evaluated*. The same applies to the bounds, constraints, and default "
"values of type variables created through the :ref:`type parameter syntax "
"<type-params>`. This means that they are not evaluated when the type alias "
"or type variable is created. Instead, they are only evaluated when doing so "
"is necessary to resolve an attribute access."
msgstr ""
"Los valores de los alias de tipo creados mediante la declaración :keyword:"
"`type` *se evalúan de forma diferida*. Lo mismo se aplica a los límites, "
"restricciones y valores predeterminados de las variables de tipo creadas "
"mediante la :ref:`sintaxis de parámetros de tipo <type-params>`. Esto "
"significa que no se evalúan cuando se crea el alias de tipo o la variable de "
"tipo. En su lugar, sólo se evalúan cuando es necesario para resolver el "
"acceso a un atributo."

#: ../Doc/reference/executionmodel.rst:251
msgid "Example:"
msgstr "Ejemplo:"

#: ../Doc/reference/executionmodel.rst:253
msgid ""
">>> type Alias = 1/0\n"
">>> Alias.__value__\n"
"Traceback (most recent call last):\n"
"  ...\n"
"ZeroDivisionError: division by zero\n"
">>> def func[T: 1/0](): pass\n"
">>> T = func.__type_params__[0]\n"
">>> T.__bound__\n"
"Traceback (most recent call last):\n"
"  ...\n"
"ZeroDivisionError: division by zero"
msgstr ""
">>> type Alias = 1/0\n"
">>> Alias.__value__\n"
"Traceback (most recent call last):\n"
"  ...\n"
"ZeroDivisionError: division by zero\n"
">>> def func[T: 1/0](): pass\n"
">>> T = func.__type_params__[0]\n"
">>> T.__bound__\n"
"Traceback (most recent call last):\n"
"  ...\n"
"ZeroDivisionError: division by zero"

#: ../Doc/reference/executionmodel.rst:267
msgid ""
"Here the exception is raised only when the ``__value__`` attribute of the "
"type alias or the ``__bound__`` attribute of the type variable is accessed."
msgstr ""
"Aquí la excepción se lanza sólo cuando se accede al atributo ``__value__`` "
"del alias de tipo o al atributo ``__bound__`` de la variable de tipo."

#: ../Doc/reference/executionmodel.rst:271
msgid ""
"This behavior is primarily useful for references to types that have not yet "
"been defined when the type alias or type variable is created. For example, "
"lazy evaluation enables creation of mutually recursive type aliases::"
msgstr ""
"Este comportamiento es útil principalmente para referencias a tipos que aún "
"no se han definido cuando se crea el alias de tipo o la variable de tipo. "
"Por ejemplo, la evaluación perezosa permite la creación de alias de tipo "
"mutuamente recursivos::"

#: ../Doc/reference/executionmodel.rst:275
msgid ""
"from typing import Literal\n"
"\n"
"type SimpleExpr = int | Parenthesized\n"
"type Parenthesized = tuple[Literal[\"(\"], Expr, Literal[\")\"]]\n"
"type Expr = SimpleExpr | tuple[SimpleExpr, Literal[\"+\", \"-\"], Expr]"
msgstr ""
"from typing import Literal\n"
"\n"
"type SimpleExpr = int | Parenthesized\n"
"type Parenthesized = tuple[Literal[\"(\"], Expr, Literal[\")\"]]\n"
"type Expr = SimpleExpr | tuple[SimpleExpr, Literal[\"+\", \"-\"], Expr]"

#: ../Doc/reference/executionmodel.rst:281
msgid ""
"Lazily evaluated values are evaluated in :ref:`annotation scope <annotation-"
"scopes>`, which means that names that appear inside the lazily evaluated "
"value are looked up as if they were used in the immediately enclosing scope."
msgstr ""
"Los valores evaluados perezosamente se evalúan en :ref:`annotation scope "
"<annotation-scopes>`, lo que significa que los nombres que aparecen dentro "
"del valor evaluado se buscan como si se utilizaran en el ámbito "
"inmediatamente adyacente."

#: ../Doc/reference/executionmodel.rst:290
msgid "Builtins and restricted execution"
msgstr "Integraciones y ejecución restringida"

#: ../Doc/reference/executionmodel.rst:296
msgid ""
"Users should not touch ``__builtins__``; it is strictly an implementation "
"detail.  Users wanting to override values in the builtins namespace should :"
"keyword:`import` the :mod:`builtins` module and modify its attributes "
"appropriately."
msgstr ""
"Los usuarios no deberían tocar ``__builtins__``; es un detalle de la "
"implementación en sentido estricto. Los usuarios que quieran sobreescribir "
"valores en los espacios de nombres incorporados deberían usar :keyword:"
"`import` con el módulo :mod:`builtins` y modificar sus atributos de un modo "
"adecuado."

#: ../Doc/reference/executionmodel.rst:301
msgid ""
"The builtins namespace associated with the execution of a code block is "
"actually found by looking up the name ``__builtins__`` in its global "
"namespace; this should be a dictionary or a module (in the latter case the "
"module's dictionary is used).  By default, when in the :mod:`__main__` "
"module, ``__builtins__`` is the built-in module :mod:`builtins`; when in any "
"other module, ``__builtins__`` is an alias for the dictionary of the :mod:"
"`builtins` module itself."
msgstr ""
"El espacio de nombres incorporado (*builtin namespace*) asociado a la "
"ejecución de un bloque de código es encontrado buscando el nombre "
"``__builtins__`` en su espacio de nombres global; debería ser un diccionario "
"o un módulo (en este último caso, se usa el diccionario del módulo). Por "
"defecto, en el módulo :mod:`__main__`, ``__builtins__`` es el módulo :mod:"
"`builtins`. En cualquier otro módulo,  ``__builtins__`` es un alias para el "
"diccionario del propio módulo :mod:`builtins`."

#: ../Doc/reference/executionmodel.rst:313
msgid "Interaction with dynamic features"
msgstr "Interacción con funcionalidades dinámicas"

#: ../Doc/reference/executionmodel.rst:315
msgid ""
"Name resolution of free variables occurs at runtime, not at compile time. "
"This means that the following code will print 42::"
msgstr ""
"La resolución de variables libres sucede en tiempo de ejecución, no en "
"tiempo de compilación. Esto significa que el siguiente código va a mostrar "
"42::"

#: ../Doc/reference/executionmodel.rst:318
msgid ""
"i = 10\n"
"def f():\n"
"    print(i)\n"
"i = 42\n"
"f()"
msgstr ""
"i = 10\n"
"def f():\n"
"    print(i)\n"
"i = 42\n"
"f()"

#: ../Doc/reference/executionmodel.rst:326
msgid ""
"The :func:`eval` and :func:`exec` functions do not have access to the full "
"environment for resolving names.  Names may be resolved in the local and "
"global namespaces of the caller.  Free variables are not resolved in the "
"nearest enclosing namespace, but in the global namespace.  [#]_ The :func:"
"`exec` and :func:`eval` functions have optional arguments to override the "
"global and local namespace.  If only one namespace is specified, it is used "
"for both."
msgstr ""
"Las funciones :func:`eval` y :func:`exec` no tienen acceso al entorno "
"completo para resolver nombres. Los nombres pueden resolverse en los "
"espacios de nombres locales y globales de la persona que llama. Las "
"variables libres no se resuelven en el espacio de nombres adjunto más "
"cercano, sino en el espacio de nombres global. [#]_ Las funciones :func:"
"`exec` y :func:`eval` tienen argumentos opcionales para anular el espacio de "
"nombres global y local. Si solo se especifica un espacio de nombres, se usa "
"para ambos."

#: ../Doc/reference/executionmodel.rst:337
msgid "Exceptions"
msgstr "Excepciones"

#: ../Doc/reference/executionmodel.rst:348
msgid ""
"Exceptions are a means of breaking out of the normal flow of control of a "
"code block in order to handle errors or other exceptional conditions.  An "
"exception is *raised* at the point where the error is detected; it may be "
"*handled* by the surrounding code block or by any code block that directly "
"or indirectly invoked the code block where the error occurred."
msgstr ""
"Las excepciones son un medio para salir del flujo de control normal de un "
"bloque de código, para gestionar errores u otras condiciones excepcionales. "
"Una excepción es *lanzada* (*raised*) en el momento en que se detecta el "
"error; puede ser *gestionada* (*handled*) por el bloque de código que la "
"rodea o por cualquier bloque de código que directa o indirectamente ha "
"invocado al bloque de código en el que ocurrió el error."

#: ../Doc/reference/executionmodel.rst:354
msgid ""
"The Python interpreter raises an exception when it detects a run-time error "
"(such as division by zero).  A Python program can also explicitly raise an "
"exception with the :keyword:`raise` statement. Exception handlers are "
"specified with the :keyword:`try` ... :keyword:`except` statement.  The :"
"keyword:`finally` clause of such a statement can be used to specify cleanup "
"code which does not handle the exception, but is executed whether an "
"exception occurred or not in the preceding code."
msgstr ""
"El intérprete Python lanza una excepción cuando detecta un error en tiempo "
"de ejecución (como una división por cero). Un programa Python también puede "
"lanzar una excepción explícitamente, con la declaración :keyword:`raise`. "
"Los gestores de excepciones se especifican con la declaración :keyword:"
"`try` ... :keyword:`except`. La cláusula :keyword:`finally` de tales "
"declaraciones puede utilizarse para especificar código de limpieza que no es "
"el que gestiona la excepción, sino que se ejecutará en cualquier caso, tanto "
"cuando la excepción ha ocurrido en el código que la precede, como cuando "
"esto no ha sucedido."

#: ../Doc/reference/executionmodel.rst:364
msgid ""
"Python uses the \"termination\" model of error handling: an exception "
"handler can find out what happened and continue execution at an outer level, "
"but it cannot repair the cause of the error and retry the failing operation "
"(except by re-entering the offending piece of code from the top)."
msgstr ""
"Python usa el modelo de gestión de errores de \"terminación"
"\" (\"*termination*\"): un gestor de excepción puede descubrir qué sucedió y "
"continuar la ejecución en un nivel exterior, pero no puede reparar la causa "
"del error y reintentar la operación que ha fallado (excepto que se reingrese "
"al trozo de código fallido desde su inicio)."

#: ../Doc/reference/executionmodel.rst:371
msgid ""
"When an exception is not handled at all, the interpreter terminates "
"execution of the program, or returns to its interactive main loop.  In "
"either case, it prints a stack traceback, except when the exception is :exc:"
"`SystemExit`."
msgstr ""
"Cuando una excepción no está gestionada en absoluto, el intérprete termina "
"la ejecución del programa, o retorna a su bucle principal interactivo. En "
"cualquier caso, imprime un seguimiento de pila, excepto cuando la excepción "
"es :exc:`SystemExit`."

#: ../Doc/reference/executionmodel.rst:375
msgid ""
"Exceptions are identified by class instances.  The :keyword:`except` clause "
"is selected depending on the class of the instance: it must reference the "
"class of the instance or a :term:`non-virtual base class <abstract base "
"class>` thereof. The instance can be received by the handler and can carry "
"additional information about the exceptional condition."
msgstr ""
"Las excepciones se identifican mediante instancias de clase.  La cláusula :"
"keyword:`except` se selecciona en función de la clase de la instancia: debe "
"hacer referencia a la clase de la instancia o a un :term:`non-virtual base "
"class <abstract base class>` de la misma. La instancia puede ser recibida "
"por el manejador y puede llevar información adicional sobre la condición "
"excepcional."

#: ../Doc/reference/executionmodel.rst:383
msgid ""
"Exception messages are not part of the Python API.  Their contents may "
"change from one version of Python to the next without warning and should not "
"be relied on by code which will run under multiple versions of the "
"interpreter."
msgstr ""
"Los mensajes de excepción no forman parte de la API Python. Su contenido "
"puede cambiar entre una versión de Python y la siguiente sin ningún tipo de "
"advertencia; el código que corre bajo múltiples versiones del intérprete no "
"debería basarse en estos mensajes."

#: ../Doc/reference/executionmodel.rst:387
msgid ""
"See also the description of the :keyword:`try` statement in section :ref:"
"`try` and :keyword:`raise` statement in section :ref:`raise`."
msgstr ""
"Mira también la descripción de la declaración :keyword:`try` en la sección :"
"ref:`try`, y la declaración :keyword:`raise` en la sección :ref:`raise`."

#: ../Doc/reference/executionmodel.rst:392
msgid "Footnotes"
msgstr "Notas al pie"

#: ../Doc/reference/executionmodel.rst:393
msgid ""
"This limitation occurs because the code that is executed by these operations "
"is not available at the time the module is compiled."
msgstr ""
"Esta limitación se da porque el código ejecutado por estas operaciones no "
"está disponible en el momento en que se compila el módulo."

#: ../Doc/reference/executionmodel.rst:8
msgid "execution model"
msgstr "modelo de ejecución"

#: ../Doc/reference/executionmodel.rst:8
msgid "code"
msgstr "código"

#: ../Doc/reference/executionmodel.rst:8 ../Doc/reference/executionmodel.rst:17
msgid "block"
msgstr "bloque"

#: ../Doc/reference/executionmodel.rst:31
#: ../Doc/reference/executionmodel.rst:292
msgid "execution"
msgstr "ejecución"

#: ../Doc/reference/executionmodel.rst:31
msgid "frame"
msgstr "marco"

#: ../Doc/reference/executionmodel.rst:42
msgid "namespace"
msgstr "espacio de nombre"

#: ../Doc/reference/executionmodel.rst:42
#: ../Doc/reference/executionmodel.rst:103
msgid "scope"
msgstr "ámbito"

#: ../Doc/reference/executionmodel.rst:51
msgid "name"
msgstr "nombre"

#: ../Doc/reference/executionmodel.rst:51
msgid "binding"
msgstr "vinculación de nombres"

#: ../Doc/reference/executionmodel.rst:57
msgid "from"
msgstr "de"

#: ../Doc/reference/executionmodel.rst:57
msgid "import statement"
msgstr "declaración de importación"

#: ../Doc/reference/executionmodel.rst:87
msgid "free"
msgstr "libre"

#: ../Doc/reference/executionmodel.rst:87
msgid "variable"
msgstr "variable"

#: ../Doc/reference/executionmodel.rst:111
msgid "environment"
msgstr "ambiente"

#: ../Doc/reference/executionmodel.rst:117
msgid "NameError (built-in exception)"
msgstr "NameError (excepción incorporada)"

#: ../Doc/reference/executionmodel.rst:117
msgid "UnboundLocalError"
msgstr "UnboundLocalError"

#: ../Doc/reference/executionmodel.rst:158
msgid "module"
msgstr "módulo"

#: ../Doc/reference/executionmodel.rst:158
msgid "__main__"
msgstr "__main__"

#: ../Doc/reference/executionmodel.rst:292
msgid "restricted"
msgstr "restringido"

#: ../Doc/reference/executionmodel.rst:339
msgid "exception"
msgstr "excepciones"

#: ../Doc/reference/executionmodel.rst:341
msgid "raise an exception"
msgstr "lanzar una excepción"

#: ../Doc/reference/executionmodel.rst:341
msgid "handle an exception"
msgstr "gestionar una excepción"

#: ../Doc/reference/executionmodel.rst:341
msgid "exception handler"
msgstr "gestor de excepciones"

#: ../Doc/reference/executionmodel.rst:341
msgid "errors"
msgstr "errores"

#: ../Doc/reference/executionmodel.rst:341
msgid "error handling"
msgstr "manejo de errores"

#: ../Doc/reference/executionmodel.rst:362
msgid "termination model"
msgstr "modelo de finalización"

#: ../Doc/reference/executionmodel.rst:369
msgid "SystemExit (built-in exception)"
msgstr "SystemExit (excepción incorporada)"