# 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-01-01 17:41-0500\n"

"Last-Translator: Carlos A. Crespo <lvccrespo@gmail.com>\n"

"Language-Team: python-doc-es\n"

"Language: es_AR\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/compound_stmts.rst:5

msgid "Compound statements"

msgstr "Sentencias compuestas"

#: ../Doc/reference/compound_stmts.rst:9

msgid ""

"Compound statements contain (groups of) other statements; they affect or "

"control the execution of those other statements in some way. In general, "

"compound statements span multiple lines, although in simple incarnations a "

"whole compound statement may be contained in one line."

msgstr ""

"Las sentencias compuestas contienen (grupos de) otras sentencias; estas "

"afectan o controlan la ejecución de esas otras sentencias de alguna manera. "

"En general, las sentencias compuestas abarcan varias líneas, aunque en "

"representaciones simples una sentencia compuesta completa puede estar "

"contenida en una línea."

#: ../Doc/reference/compound_stmts.rst:14

msgid ""

"The :keyword:`if`, :keyword:`while` and :keyword:`for` statements implement "

"traditional control flow constructs. :keyword:`try` specifies exception "

"handlers and/or cleanup code for a group of statements, while the :keyword:"

"`with` statement allows the execution of initialization and finalization "

"code around a block of code. Function and class definitions are also "

"syntactically compound statements."

msgstr ""

"Las sentencias :keyword:`if`, :keyword:`while` y :keyword:`for` implementan "

"construcciones de control de flujo tradicionales. :keyword:`try` especifica "

"gestores de excepción o código de limpieza para un grupo de sentencias, "

"mientras que las sentencias :keyword:`with` permite la ejecución del código "

"de inicialización y finalización alrededor de un bloque de código. Las "

"definiciones de función y clase también son sentencias sintácticamente "

"compuestas."

#: ../Doc/reference/compound_stmts.rst:26

msgid ""

"A compound statement consists of one or more 'clauses.' A clause consists "

"of a header and a 'suite.' The clause headers of a particular compound "

"statement are all at the same indentation level. Each clause header begins "

"with a uniquely identifying keyword and ends with a colon. A suite is a "

"group of statements controlled by a clause. A suite can be one or more "

"semicolon-separated simple statements on the same line as the header, "

"following the header's colon, or it can be one or more indented statements "

"on subsequent lines. Only the latter form of a suite can contain nested "

"compound statements; the following is illegal, mostly because it wouldn't be "

"clear to which :keyword:`if` clause a following :keyword:`else` clause would "

"belong::"

msgstr ""

"Una sentencia compuesta consta de una o más 'cláusulas'. Una cláusula consta "

"de un encabezado y una 'suite'. Los encabezados de cláusula de una "

"declaración compuesta particular están todos en el mismo nivel de "

"indentación. Cada encabezado de cláusula comienza con una palabra clave de "

"identificación única y termina con dos puntos. Una suite es un grupo de "

"sentencias controladas por una cláusula. Una suite puede ser una o más "

"sentencias simples separadas por punto y coma en la misma línea como el "

"encabezado, siguiendo los dos puntos del encabezado, o puede ser una o puede "

"ser una o más declaraciones indentadas en líneas posteriores. Solo la última "

"forma de una suite puede contener sentencias compuestas anidadas; lo "

"siguiente es ilegal, principalmente porque no estaría claro a qué cláusula :"

"keyword:`if` seguido de la cláusula :keyword:`else` hace referencia::"

#: ../Doc/reference/compound_stmts.rst:37

msgid "if test1: if test2: print(x)"

msgstr "if test1: if test2: print(x)"

#: ../Doc/reference/compound_stmts.rst:39

msgid ""

"Also note that the semicolon binds tighter than the colon in this context, "

"so that in the following example, either all or none of the :func:`print` "

"calls are executed::"

msgstr ""

"También tenga en cuenta que el punto y coma se une más apretado que los dos "

"puntos en este contexto, de modo que en el siguiente ejemplo, todas o "

"ninguna de las llamadas :func:`print` se ejecutan::"

#: ../Doc/reference/compound_stmts.rst:43

msgid "if x < y < z: print(x); print(y); print(z)"

msgstr "if x < y < z: print(x); print(y); print(z)"

#: ../Doc/reference/compound_stmts.rst:45

msgid "Summarizing:"

msgstr "Resumiendo:"

#: ../Doc/reference/compound_stmts.rst:69

msgid ""

"Note that statements always end in a ``NEWLINE`` possibly followed by a "

"``DEDENT``. Also note that optional continuation clauses always begin with "

"a keyword that cannot start a statement, thus there are no ambiguities (the "

"'dangling :keyword:`else`' problem is solved in Python by requiring nested :"

"keyword:`if` statements to be indented)."

msgstr ""

"Tenga en cuenta que las sentencias siempre terminan en un ``NEWLINE`` "

"posiblemente seguida de ``DEDENT``. También tenga en cuenta que las "

"cláusulas de continuación opcionales siempre comienzan con una palabra clave "

"que no puede iniciar una sentencia, por lo tanto, no hay ambigüedades (el "

"problema de 'colgado :keyword:`if`' se resuelve en Python al requerir que "

"las sentencias anidadas :keyword:`if` deben estar indentadas)."

#: ../Doc/reference/compound_stmts.rst:75

msgid ""

"The formatting of the grammar rules in the following sections places each "

"clause on a separate line for clarity."

msgstr ""

"El formato de las reglas gramaticales en las siguientes secciones coloca "

"cada cláusula en una línea separada para mayor claridad."

#: ../Doc/reference/compound_stmts.rst:84

msgid "The :keyword:`!if` statement"

msgstr "La sentencia :keyword:`!if`"

#: ../Doc/reference/compound_stmts.rst:92

msgid "The :keyword:`if` statement is used for conditional execution:"

msgstr "La sentencia :keyword:`if` se usa para la ejecución condicional:"

#: ../Doc/reference/compound_stmts.rst:99

msgid ""

"It selects exactly one of the suites by evaluating the expressions one by "

"one until one is found to be true (see section :ref:`booleans` for the "

"definition of true and false); then that suite is executed (and no other "

"part of the :keyword:`if` statement is executed or evaluated). If all "

"expressions are false, the suite of the :keyword:`else` clause, if present, "

"is executed."

msgstr ""

"Selecciona exactamente una de las suites evaluando las expresiones una por "

"una hasta que se encuentre una verdadera (vea la sección :ref:`booleans` "

"para la definición de verdadero y falso); entonces esa suite se ejecuta (y "

"ninguna otra parte de la sentencia :keyword:`if` se ejecuta o evalúa). Si "

"todas las expresiones son falsas, se ejecuta la suite de cláusulas :keyword:"

"`else`, si está presente."

#: ../Doc/reference/compound_stmts.rst:109

msgid "The :keyword:`!while` statement"

msgstr "La sentencia :keyword:`!while`"

#: ../Doc/reference/compound_stmts.rst:117

msgid ""

"The :keyword:`while` statement is used for repeated execution as long as an "

"expression is true:"

msgstr ""

"La sentencia :keyword:`while` se usa para la ejecución repetida siempre que "

"una expresión sea verdadera:"

#: ../Doc/reference/compound_stmts.rst:124

msgid ""

"This repeatedly tests the expression and, if it is true, executes the first "

"suite; if the expression is false (which may be the first time it is tested) "

"the suite of the :keyword:`!else` clause, if present, is executed and the "

"loop terminates."

msgstr ""

"Esto prueba repetidamente la expresión y, si es verdadera, ejecuta la "

"primera suite; si la expresión es falsa (que puede ser la primera vez que se "

"prueba), se ejecuta el conjunto de cláusulas :keyword:`!else`, si está "

"presente, y el bucle termina."

#: ../Doc/reference/compound_stmts.rst:133

msgid ""

"A :keyword:`break` statement executed in the first suite terminates the loop "

"without executing the :keyword:`!else` clause's suite. A :keyword:"

"`continue` statement executed in the first suite skips the rest of the suite "

"and goes back to testing the expression."

msgstr ""

"La sentencia :keyword:`break` ejecutada en la primer suite termina el bucle "

"sin ejecutar la suite de cláusulas :keyword:`!else`. La sentencia :keyword:"

"`continue` ejecutada en la primera suite omite el resto de la suite y vuelve "

"a probar la expresión."

#: ../Doc/reference/compound_stmts.rst:142

msgid "The :keyword:`!for` statement"

msgstr "La sentencia :keyword:`!for`"

#: ../Doc/reference/compound_stmts.rst:153

msgid ""

"The :keyword:`for` statement is used to iterate over the elements of a "

"sequence (such as a string, tuple or list) or other iterable object:"

msgstr ""

"La sentencia :keyword:`for` se usa para iterar sobre los elementos de una "

"secuencia (como una cadena de caracteres, tupla o lista) u otro objeto "

"iterable:"

#: ../Doc/reference/compound_stmts.rst:160

msgid ""

"The ``starred_list`` expression is evaluated once; it should yield an :term:"

"`iterable` object. An :term:`iterator` is created for that iterable. The "

"first item provided by the iterator is then assigned to the target list "

"using the standard rules for assignments (see :ref:`assignment`), and the "

"suite is executed. This repeats for each item provided by the iterator. "

"When the iterator is exhausted, the suite in the :keyword:`!else` clause, if "

"present, is executed, and the loop terminates."

msgstr ""

"La expresión ``starred_list`` se evalúa una vez; debería producir un objeto :"

"term:`iterable`. Se crea un :term:`iterator` para ese iterable. A "

"continuación, el primer elemento proporcionado por el iterador se asigna a "

"la lista de destino utilizando las reglas estándar para las asignaciones "

"(consulte :ref:`assignment`) y se ejecuta la suite. Esto se repite para cada "

"elemento proporcionado por el iterador. Cuando se agota el iterador, se "

"ejecuta el conjunto de la cláusula :keyword:`!else`, si está presente, y el "

"ciclo termina."

#: ../Doc/reference/compound_stmts.rst:173

msgid ""

"A :keyword:`break` statement executed in the first suite terminates the loop "

"without executing the :keyword:`!else` clause's suite. A :keyword:"

"`continue` statement executed in the first suite skips the rest of the suite "

"and continues with the next item, or with the :keyword:`!else` clause if "

"there is no next item."

msgstr ""

"La sentencia :keyword:`break` ejecutada en la primera suite termina el bucle "

"sin ejecutar el conjunto de cláusulas :keyword:`!else`. La sentencia :"

"keyword:`continue` ejecutada en la primera suite omite el resto de las "

"cláusulas y continúa con el siguiente elemento, o con la cláusula :keyword:`!"

"else` si no hay un elemento siguiente."

#: ../Doc/reference/compound_stmts.rst:179

msgid ""

"The for-loop makes assignments to the variables in the target list. This "

"overwrites all previous assignments to those variables including those made "

"in the suite of the for-loop::"

msgstr ""

"El bucle ``for`` realiza asignaciones a las variables en la lista. Esto "

"sobrescribe todas las asignaciones anteriores a esas variables, incluidas "

"las realizadas en la suite del bucle ``for``::"

# No se pueden traducir los commentarios hasta que pospell tenga la habilidad

# de entender líneas de código.

#: ../Doc/reference/compound_stmts.rst:183

msgid ""

"for i in range(10):\n"

" print(i)\n"

" i = 5 # this will not affect the for-loop\n"

" # because i will be overwritten with the next\n"

" # index in the range"

msgstr ""

"for i in range(10):\n"

" print(i)\n"

" i = 5 # this will not affect the for-loop\n"

" # because i will be overwritten with the next\n"

" # index in the range"

#: ../Doc/reference/compound_stmts.rst:193

msgid ""

"Names in the target list are not deleted when the loop is finished, but if "

"the sequence is empty, they will not have been assigned to at all by the "

"loop. Hint: the built-in type :func:`range` represents immutable arithmetic "

"sequences of integers. For instance, iterating ``range(3)`` successively "

"yields 0, 1, and then 2."

msgstr ""

"Los nombres en la lista no se eliminan cuando finaliza el bucle, pero si la "

"secuencia está vacía, el bucle no les habrá asignado nada. Sugerencia: el "

"tipo incorporado :func:`range` representa secuencias aritméticas inmutables "

"de números enteros; por ejemplo, iterar sobre ``range(3)`` genera "

"sucesivamente 0, 1, y luego 2."

#: ../Doc/reference/compound_stmts.rst:198

msgid "Starred elements are now allowed in the expression list."

msgstr ""

"Los elementos destacados ahora están permitidos en la lista de expresiones."

#: ../Doc/reference/compound_stmts.rst:205

msgid "The :keyword:`!try` statement"

msgstr "La sentencia :keyword:`!try`"

#: ../Doc/reference/compound_stmts.rst:215

msgid ""

"The :keyword:`!try` statement specifies exception handlers and/or cleanup "

"code for a group of statements:"

msgstr ""

"La sentencia :keyword:`!try` especifica controladores de excepciones y/o "

"código de limpieza para un grupo de sentencias:"

#: ../Doc/reference/compound_stmts.rst:231

msgid ""

"Additional information on exceptions can be found in section :ref:"

"`exceptions`, and information on using the :keyword:`raise` statement to "

"generate exceptions may be found in section :ref:`raise`."

msgstr ""

"Se puede encontrar información adicional sobre las excepciones en la "

"sección :ref:`exceptions`, e información sobre el uso de la sentencia :"

"keyword:`raise`, para lanzar excepciones se puede encontrar en la sección :"

"ref:`raise`."

#: ../Doc/reference/compound_stmts.rst:239

msgid ":keyword:`!except` clause"

msgstr "Cláusula :keyword:`!except`"

#: ../Doc/reference/compound_stmts.rst:241

msgid ""

"The :keyword:`!except` clause(s) specify one or more exception handlers. "

"When no exception occurs in the :keyword:`try` clause, no exception handler "

"is executed. When an exception occurs in the :keyword:`!try` suite, a search "

"for an exception handler is started. This search inspects the :keyword:`!"

"except` clauses in turn until one is found that matches the exception. An "

"expression-less :keyword:`!except` clause, if present, must be last; it "

"matches any exception."

msgstr ""

"Las cláusulas :keyword:`!except` especifican uno o más controladores de "

"excepciones. Cuando no se produce ninguna excepción en la cláusula :keyword:"

"`try`, no se ejecuta ningún controlador de excepciones. Cuando ocurre una "

"excepción en la suite :keyword:`!try`, se inicia una búsqueda de un "

"controlador de excepciones. Esta búsqueda inspecciona las cláusulas :keyword:"

"`!except` a su vez hasta que se encuentra una que coincida con la excepción. "

"Una cláusula :keyword:`!except` sin expresión, si está presente, debe ser la "

"última; coincide con cualquier excepción."

#: ../Doc/reference/compound_stmts.rst:249

msgid ""

"For an :keyword:`!except` clause with an expression, the expression must "

"evaluate to an exception type or a tuple of exception types. The raised "

"exception matches an :keyword:`!except` clause whose expression evaluates to "

"the class or a :term:`non-virtual base class <abstract base class>` of the "

"exception object, or to a tuple that contains such a class."

msgstr ""

"Para una cláusula de :keyword:`!except`con una expresión, la expresión debe "

"evaluar a un tipo de excepción o un tupla de tipos de excepciones. La "

"excepción generada coincide con una cláusula :keyword:`!except` cuya "

"expresión evalúa a la clase o una :term:`clase base no virtual <abstract "

"base class>` del objeto excepción, o una tupla que contiene dicha clase."

#: ../Doc/reference/compound_stmts.rst:255

msgid ""

"If no :keyword:`!except` clause matches the exception, the search for an "

"exception handler continues in the surrounding code and on the invocation "

"stack. [#]_"

msgstr ""

"Si ninguna cláusula :keyword:`!except` coincide con la excepción, la "

"búsqueda de un controlador de excepciones continúa en el código circundante "

"y en la pila de invocaciones. [#]_"

#: ../Doc/reference/compound_stmts.rst:259

msgid ""

"If the evaluation of an expression in the header of an :keyword:`!except` "

"clause raises an exception, the original search for a handler is canceled "

"and a search starts for the new exception in the surrounding code and on the "

"call stack (it is treated as if the entire :keyword:`try` statement raised "

"the exception)."

msgstr ""

"Si la evaluación de una expresión en el encabezado de una cláusula :keyword:"

"`!except` genera una excepción, la búsqueda original de un controlador se "

"cancela y comienza una búsqueda de la nueva excepción en el código "

"circundante y en la pila de llamadas (se trata como si toda la sentencia :"

"keyword:`try` generara la excepción)."

#: ../Doc/reference/compound_stmts.rst:267

msgid ""

"When a matching :keyword:`!except` clause is found, the exception is "

"assigned to the target specified after the :keyword:`!as` keyword in that :"

"keyword:`!except` clause, if present, and the :keyword:`!except` clause's "

"suite is executed. All :keyword:`!except` clauses must have an executable "

"block. When the end of this block is reached, execution continues normally "

"after the entire :keyword:`try` statement. (This means that if two nested "

"handlers exist for the same exception, and the exception occurs in the :"

"keyword:`!try` clause of the inner handler, the outer handler will not "

"handle the exception.)"

msgstr ""

"Cuando se encuentra una cláusula :keyword:`!except` coincidente, la "

"excepción se asigna al destino especificado después de la palabra clave :"

"keyword:`!as` en esa cláusula :keyword:`!except`, si está presente, y se "

"ejecuta el conjunto de la cláusula :keyword:`!except`. Todas las cláusulas :"

"keyword:`!except` deben tener un bloque ejecutable. Cuando se alcanza el "

"final de este bloque, la ejecución continúa normalmente después de la "

"instrucción :keyword:`try` completa. (Esto significa que si existen dos "

"controladores anidados para la misma excepción y la excepción se produce en "

"la cláusula :keyword:`!try` del controlador interno, el controlador externo "

"no controlará la excepción)."

#: ../Doc/reference/compound_stmts.rst:278

msgid ""

"When an exception has been assigned using ``as target``, it is cleared at "

"the end of the :keyword:`!except` clause. This is as if ::"

msgstr ""

"Cuando se ha asignado una excepción mediante ``as target``, se borra al "

"final de la cláusula :keyword:`!except`. Esto es como si ::"

#: ../Doc/reference/compound_stmts.rst:281

msgid ""

"except E as N:\n"

" foo"

msgstr ""

"except E as N:\n"

" foo"

#: ../Doc/reference/compound_stmts.rst:284

msgid "was translated to ::"

msgstr "fue traducido a ::"

#: ../Doc/reference/compound_stmts.rst:286

msgid ""

"except E as N:\n"

" try:\n"

" foo\n"

" finally:\n"

" del N"

msgstr ""

"except E as N:\n"

" try:\n"

" foo\n"

" finally:\n"

" del N"

#: ../Doc/reference/compound_stmts.rst:292

msgid ""

"This means the exception must be assigned to a different name to be able to "

"refer to it after the :keyword:`!except` clause. Exceptions are cleared "

"because with the traceback attached to them, they form a reference cycle "

"with the stack frame, keeping all locals in that frame alive until the next "

"garbage collection occurs."

msgstr ""

"Esto significa que la excepción debe asignarse a un nombre diferente para "

"poder hacer referencia a ella después de la cláusula :keyword:`!except`. Las "

"excepciones se borran porque con el rastreo adjunto, forman un ciclo de "

"referencia con el marco de la pila, manteniendo todos los locales en ese "

"marco vivos hasta que ocurra la próxima recolección de elementos no "

"utilizados."

#: ../Doc/reference/compound_stmts.rst:302

msgid ""

"Before an :keyword:`!except` clause's suite is executed, the exception is "

"stored in the :mod:`sys` module, where it can be accessed from within the "

"body of the :keyword:`!except` clause by calling :func:`sys.exception`. When "

"leaving an exception handler, the exception stored in the :mod:`sys` module "

"is reset to its previous value::"

msgstr ""

"Antes de que se ejecute el conjunto de una cláusula :keyword:`!except` , la "

"excepción se almacena en el módulo :mod:`sys`, donde puede ser accesible "

"desde dentro del cuerpo de la cláusula :keyword:`!except` llamando a la :"

"func:`sys.excepcion`. Cuando se sale de un *handler* de excepciones, la "

"excepción almacenada en el módulo :mod:`sys` se restablece a su valor "

"anterior::"

#: ../Doc/reference/compound_stmts.rst:308

msgid ""

">>> print(sys.exception())\n"

"None\n"

">>> try:\n"

"... raise TypeError\n"

"... except:\n"

"... print(repr(sys.exception()))\n"

"... try:\n"

"... raise ValueError\n"

"... except:\n"

"... print(repr(sys.exception()))\n"

"... print(repr(sys.exception()))\n"

"...\n"

"TypeError()\n"

"ValueError()\n"

"TypeError()\n"

">>> print(sys.exception())\n"

"None"

msgstr ""

">>> print(sys.exception())\n"

"None\n"

">>> try:\n"

"... raise TypeError\n"

"... except:\n"

"... print(repr(sys.exception()))\n"

"... try:\n"

"... raise ValueError\n"

"... except:\n"

"... print(repr(sys.exception()))\n"

"... print(repr(sys.exception()))\n"

"...\n"

"TypeError()\n"

"ValueError()\n"

"TypeError()\n"

">>> print(sys.exception())\n"

"None"

#: ../Doc/reference/compound_stmts.rst:333

msgid ":keyword:`!except*` clause"

msgstr "Cláusula :keyword:`!except*`"

#: ../Doc/reference/compound_stmts.rst:335

msgid ""

"The :keyword:`!except*` clause(s) are used for handling :exc:`ExceptionGroup`"

"\\s. The exception type for matching is interpreted as in the case of :"

"keyword:`except`, but in the case of exception groups we can have partial "

"matches when the type matches some of the exceptions in the group. This "

"means that multiple :keyword:`!except*` clauses can execute, each handling "

"part of the exception group. Each clause executes at most once and handles "

"an exception group of all matching exceptions. Each exception in the group "

"is handled by at most one :keyword:`!except*` clause, the first that matches "

"it. ::"

msgstr ""

"La(s) cláusula(s) :keyword:`!except*` se utilizan para manejar :exc:"

"`ExceptionGroup`\\s. El tipo de excepción para la coincidencia se interpreta "

"como en el caso de :keyword:`except`, pero en el caso de los grupos de "

"excepción podemos tener coincidencias parciales cuando el tipo coincide con "

"algunas de las excepciones del grupo. Esto significa que se pueden ejecutar "

"varias cláusulas :keyword:`!except*`, cada una de las cuales maneja parte "

"del grupo de excepciones. Cada cláusula se ejecuta como máximo una vez y "

"maneja un grupo de excepciones de todas las excepciones coincidentes. Cada "

"excepción en el grupo es manejada por una cláusula :keyword:`!except*` como "

"máximo, la primera que coincida. ::"

#: ../Doc/reference/compound_stmts.rst:345

msgid ""

">>> try:\n"

"... raise ExceptionGroup(\"eg\",\n"

"... [ValueError(1), TypeError(2), OSError(3), OSError(4)])\n"

"... except* TypeError as e:\n"

"... print(f'caught {type(e)} with nested {e.exceptions}')\n"

"... except* OSError as e:\n"

"... print(f'caught {type(e)} with nested {e.exceptions}')\n"

"...\n"

"caught <class 'ExceptionGroup'> with nested (TypeError(2),)\n"

"caught <class 'ExceptionGroup'> with nested (OSError(3), OSError(4))\n"

" + Exception Group Traceback (most recent call last):\n"

" | File \"<stdin>\", line 2, in <module>\n"

" | ExceptionGroup: eg\n"

" +-+---------------- 1 ----------------\n"

" | ValueError: 1\n"

" +------------------------------------"

msgstr ""

">>> try:\n"

"... raise ExceptionGroup(\"eg\",\n"

"... [ValueError(1), TypeError(2), OSError(3), OSError(4)])\n"

"... except* TypeError as e:\n"

"... print(f'caught {type(e)} with nested {e.exceptions}')\n"

"... except* OSError as e:\n"

"... print(f'caught {type(e)} with nested {e.exceptions}')\n"

"...\n"

"caught <class 'ExceptionGroup'> with nested (TypeError(2),)\n"

"caught <class 'ExceptionGroup'> with nested (OSError(3), OSError(4))\n"

" + Exception Group Traceback (most recent call last):\n"

" | File \"<stdin>\", line 2, in <module>\n"

" | ExceptionGroup: eg\n"

" +-+---------------- 1 ----------------\n"

" | ValueError: 1\n"

" +------------------------------------"

#: ../Doc/reference/compound_stmts.rst:363

msgid ""

"Any remaining exceptions that were not handled by any :keyword:`!except*` "

"clause are re-raised at the end, along with all exceptions that were raised "

"from within the :keyword:`!except*` clauses. If this list contains more than "

"one exception to reraise, they are combined into an exception group."

msgstr ""

"Cualquier excepción restante que no haya sido manejada por ninguna cláusula :"

"keyword:`!except*` se vuelve a lanzar al final, junto con todas las "

"excepciones que se lanzaron desde dentro de las cláusulas :keyword:`!"

"except*`. Si esta lista contiene más de una excepción a relanzar, se "

"combinan en un grupo de excepciones."

#: ../Doc/reference/compound_stmts.rst:369

msgid ""

"If the raised exception is not an exception group and its type matches one "

"of the :keyword:`!except*` clauses, it is caught and wrapped by an exception "

"group with an empty message string. ::"

msgstr ""

"Si la excepción generada no es un grupo de excepciones y su tipo coincide "

"con una de las cláusulas :keyword:`!except*`, un grupo de excepciones la "

"captura y la encapsula con una cadena de mensaje vacía. ::"

#: ../Doc/reference/compound_stmts.rst:373

msgid ""

">>> try:\n"

"... raise BlockingIOError\n"

"... except* BlockingIOError as e:\n"

"... print(repr(e))\n"

"...\n"

"ExceptionGroup('', (BlockingIOError()))"

msgstr ""

">>> try:\n"

"... raise BlockingIOError\n"

"... except* BlockingIOError as e:\n"

"... print(repr(e))\n"

"...\n"

"ExceptionGroup('', (BlockingIOError()))"

#: ../Doc/reference/compound_stmts.rst:380

msgid ""

"An :keyword:`!except*` clause must have a matching expression; it cannot be "

"``except*:``. Furthermore, this expression cannot contain exception group "

"types, because that would have ambiguous semantics."

msgstr ""

"Una cláusula :keyword:`!except*` debe tener una expresión coincidente; no "

"puede ser ``except*:``. Además, esta expresión no puede contener tipos de "

"excepción grupal. porque esto tendría semánticas ambiguas."

#: ../Doc/reference/compound_stmts.rst:384

msgid ""

"It is not possible to mix :keyword:`except` and :keyword:`!except*` in the "

"same :keyword:`try`. :keyword:`break`, :keyword:`continue` and :keyword:"

"`return` cannot appear in an :keyword:`!except*` clause."

msgstr ""

"No se puede mezclar :keyword:`except` y :keyword:`!except*` en el mismo "

":keyword:`try`. :keyword:`break`, :keyword:`continue` y :keyword:`return` no "

"puede aparecer en una cláusula :keyword:`!except*`."

#: ../Doc/reference/compound_stmts.rst:399

msgid ":keyword:`!else` clause"

msgstr "La sentencia :keyword:`!else`"

#: ../Doc/reference/compound_stmts.rst:401

msgid ""

"The optional :keyword:`!else` clause is executed if the control flow leaves "

"the :keyword:`try` suite, no exception was raised, and no :keyword:"

"`return`, :keyword:`continue`, or :keyword:`break` statement was executed. "

"Exceptions in the :keyword:`!else` clause are not handled by the preceding :"

"keyword:`except` clauses."

msgstr ""

"La cláusula opcional :keyword:`!else` se ejecuta si el flujo de control sale "

"de la suite :keyword:`try`, no se produjo ninguna excepción, y no se ejecutó "

"la sentencia :keyword:`return`, :keyword:`continue` o :keyword:`break`. Las "

"excepciones en la cláusula :keyword:`!else` no se gestionaron con las "

"cláusulas precedentes :keyword:`except`."

#: ../Doc/reference/compound_stmts.rst:413

msgid ":keyword:`!finally` clause"

msgstr "Cláusula :keyword:`!finally`"

#: ../Doc/reference/compound_stmts.rst:415

msgid ""

"If :keyword:`!finally` is present, it specifies a 'cleanup' handler. The :"

"keyword:`try` clause is executed, including any :keyword:`except` and :"

"keyword:`else` clauses. If an exception occurs in any of the clauses and is "

"not handled, the exception is temporarily saved. The :keyword:`!finally` "

"clause is executed. If there is a saved exception it is re-raised at the "

"end of the :keyword:`!finally` clause. If the :keyword:`!finally` clause "

"raises another exception, the saved exception is set as the context of the "

"new exception. If the :keyword:`!finally` clause executes a :keyword:"

"`return`, :keyword:`break` or :keyword:`continue` statement, the saved "

"exception is discarded::"

msgstr ""

"Si :keyword:`!finally` está presente, especifica un controlador de "

"'limpieza'. Se ejecuta la cláusula :keyword:`try`, incluidas las cláusulas :"

"keyword:`except` y :keyword:`else`. Si ocurre una excepción en cualquiera de "

"las cláusulas y no se maneja, la excepción se guarda temporalmente. Se "

"ejecuta la cláusula :keyword:`!finally`. Si hay una excepción guardada, se "

"vuelve a generar al final de la cláusula :keyword:`!finally`. Si la "

"cláusula :keyword:`!finally` genera otra excepción, la excepción guardada se "

"establece como el contexto de la nueva excepción. Si la cláusula :keyword:`!"

"finally` ejecuta una sentencia :keyword:`return`, :keyword:`break` o :"

"keyword:`continue`, la excepción guardada se descarta:"

#: ../Doc/reference/compound_stmts.rst:425

msgid ""

">>> def f():\n"

"... try:\n"

"... 1/0\n"

"... finally:\n"

"... return 42\n"

"...\n"

">>> f()\n"

"42"

msgstr ""

">>> def f():\n"

"... try:\n"

"... 1/0\n"

"... finally:\n"

"... return 42\n"

"...\n"

">>> f()\n"

"42"

#: ../Doc/reference/compound_stmts.rst:434

msgid ""

"The exception information is not available to the program during execution "

"of the :keyword:`!finally` clause."

msgstr ""

"La información de excepción no está disponible para el programa durante la "

"ejecución de la cláusula :keyword:`!finally`."

#: ../Doc/reference/compound_stmts.rst:442

msgid ""

"When a :keyword:`return`, :keyword:`break` or :keyword:`continue` statement "

"is executed in the :keyword:`try` suite of a :keyword:`!try`...\\ :keyword:`!"

"finally` statement, the :keyword:`!finally` clause is also executed 'on the "

"way out.'"

msgstr ""

"Cuando se ejecuta una sentencia :keyword:`return`, :keyword:`break` o :"

"keyword:`continue` en el conjunto :keyword:`try` de una sentencia :keyword:`!"

"try`...\\ :keyword:`!finally`, la cláusula :keyword:`!finally` también se "

"ejecuta 'al salir'."

#: ../Doc/reference/compound_stmts.rst:446

msgid ""

"The return value of a function is determined by the last :keyword:`return` "

"statement executed. Since the :keyword:`!finally` clause always executes, "

"a :keyword:`!return` statement executed in the :keyword:`!finally` clause "

"will always be the last one executed::"

msgstr ""

"El valor de retorno de una función está determinado por la última "

"instrucción :keyword:`return` ejecutada. Dado que la cláusula :keyword:`!"

"finally` siempre se ejecuta, una sentencia :keyword:`!return` ejecutada en "

"la cláusula :keyword:`!finally` siempre será la última en ejecutarse:"

#: ../Doc/reference/compound_stmts.rst:451

msgid ""

">>> def foo():\n"

"... try:\n"

"... return 'try'\n"

"... finally:\n"

"... return 'finally'\n"

"...\n"

">>> foo()\n"

"'finally'"

msgstr ""

">>> def foo():\n"

"... try:\n"

"... return 'try'\n"

"... finally:\n"

"... return 'finally'\n"

"...\n"

">>> foo()\n"

"'finally'"

#: ../Doc/reference/compound_stmts.rst:460

msgid ""

"Prior to Python 3.8, a :keyword:`continue` statement was illegal in the :"

"keyword:`!finally` clause due to a problem with the implementation."

msgstr ""

"Antes de Python 3.8, una declaración :keyword:`continue` era ilegal en la "

"cláusula :keyword:`!finally` debido a un problema con la implementación."

#: ../Doc/reference/compound_stmts.rst:469

msgid "The :keyword:`!with` statement"

msgstr "La sentencia :keyword:`!with`"

#: ../Doc/reference/compound_stmts.rst:478

msgid ""

"The :keyword:`with` statement is used to wrap the execution of a block with "

"methods defined by a context manager (see section :ref:`context-managers`). "

"This allows common :keyword:`try`...\\ :keyword:`except`...\\ :keyword:"

"`finally` usage patterns to be encapsulated for convenient reuse."

msgstr ""

"La sentencia :keyword:`with` se usa para ajustar la ejecución de un bloque "

"con métodos definidos por un administrador de contexto (ver sección :ref:"

"`context-managers`). Esto permite que los patrones de uso comunes :keyword:"

"`try`...\\ :keyword:`except`...\\ :keyword:`finally` se encapsulen para una "

"reutilización conveniente."

#: ../Doc/reference/compound_stmts.rst:488

msgid ""

"The execution of the :keyword:`with` statement with one \"item\" proceeds as "

"follows:"

msgstr ""

"La ejecución de la sentencia :keyword:`with` con un \"item\" se realiza de "

"la siguiente manera:"

#: ../Doc/reference/compound_stmts.rst:490

msgid ""

"The context expression (the expression given in the :token:`~python-grammar:"

"with_item`) is evaluated to obtain a context manager."

msgstr ""

"La expresión de contexto (la expresión dada en :token:`~python-grammar:"

"with_item`) se evalúa para obtener un administrador de contexto."

#: ../Doc/reference/compound_stmts.rst:493

msgid ""

"The context manager's :meth:`~object.__enter__` is loaded for later use."

msgstr ""

"El administrador de contexto :meth:`~object.__enter__` se carga para su uso "

"posterior."

#: ../Doc/reference/compound_stmts.rst:495

msgid "The context manager's :meth:`~object.__exit__` is loaded for later use."

msgstr ""

"El administrador de contexto :meth:`~object.__exit__` se carga para su uso posterior."

#: ../Doc/reference/compound_stmts.rst:497

msgid "The context manager's :meth:`~object.__enter__` method is invoked."

msgstr "Se invoca el método :meth:`__enter__` del administrador de contexto."

#: ../Doc/reference/compound_stmts.rst:499

msgid ""

"If a target was included in the :keyword:`with` statement, the return value "

"from :meth:`~object.__enter__` is assigned to it."

msgstr ""

"Si se incluyó el destino en la declaración :keyword:`with`, se le asigna el "

"valor de retorno de :meth:`~object.__enter__`."

#: ../Doc/reference/compound_stmts.rst:504

msgid ""

"The :keyword:`with` statement guarantees that if the :meth:`~object."

"__enter__` method returns without an error, then :meth:`~object.__exit__` "

"will always be called. Thus, if an error occurs during the assignment to the "

"target list, it will be treated the same as an error occurring within the "

"suite would be. See step 7 below."

msgstr ""

"La declaración :keyword:`with` garantiza que si el método :meth:`~object."

"__enter__` regresa sin error, entonces siempre se llamará a :meth:`~object."

"__exit__`. Por lo tanto, si se produce un error durante la asignación a la "

"lista de destino, se trataría de la misma manera que si el error ocurriera "

"dentro del suite. Consulte el paso 7 a continuación."

#: ../Doc/reference/compound_stmts.rst:510

msgid "The suite is executed."

msgstr "La suite se ejecuta."

#: ../Doc/reference/compound_stmts.rst:512

msgid ""

"The context manager's :meth:`~object.__exit__` method is invoked. If an "

"exception caused the suite to be exited, its type, value, and traceback are "

"passed as arguments to :meth:`~object.__exit__`. Otherwise, three :const:"

"`None` arguments are supplied."

msgstr ""

"Se invoca el método :meth:`~object.__exit__` del administrador de contexto. "

"Si una excepción causó la salida de la suite, su tipo, valor y rastreo se "

"pasan como argumentos a :meth:`~object.__exit__`. De lo contrario, se "

"proporcionan tres argumentos :const:`None`."

#: ../Doc/reference/compound_stmts.rst:517

msgid ""

"If the suite was exited due to an exception, and the return value from the :"

"meth:`~object.__exit__` method was false, the exception is reraised. If the "

"return value was true, the exception is suppressed, and execution continues "

"with the statement following the :keyword:`with` statement."

msgstr ""

"Si se salió de la suite debido a una excepción, y el valor de retorno del "

"método :meth:`~object.__exit__` fue falso, la excepción se vuelve a "

"plantear. Si el valor de retorno era verdadero, la excepción se suprime y la "

"ejecución continúa con la declaración que sigue a la declaración :keyword:"

"`with`."

#: ../Doc/reference/compound_stmts.rst:522

msgid ""

"If the suite was exited for any reason other than an exception, the return "

"value from :meth:`~object.__exit__` is ignored, and execution proceeds at "

"the normal location for the kind of exit that was taken."

msgstr ""

"Si se salió de la suite por cualquier motivo que no sea una excepción, el "

"valor de retorno de :meth:`~object.__exit__` se ignora y la ejecución continúa en "

"la ubicación normal para el tipo de salida que se tomó."

#: ../Doc/reference/compound_stmts.rst:526

#: ../Doc/reference/compound_stmts.rst:1547

#: ../Doc/reference/compound_stmts.rst:1588

msgid "The following code::"

msgstr "El siguiente código::"

#: ../Doc/reference/compound_stmts.rst:528

msgid ""

"with EXPRESSION as TARGET:\n"

" SUITE"

msgstr ""

"with EXPRESSION as TARGET:\n"

" SUITE"

#: ../Doc/reference/compound_stmts.rst:531

#: ../Doc/reference/compound_stmts.rst:556

#: ../Doc/reference/compound_stmts.rst:1593

msgid "is semantically equivalent to::"

msgstr "es semánticamente equivalente a::"

#: ../Doc/reference/compound_stmts.rst:533

msgid ""

"manager = (EXPRESSION)\n"

"enter = type(manager).__enter__\n"

"exit = type(manager).__exit__\n"

"value = enter(manager)\n"

"hit_except = False\n"

"\n"

"try:\n"

" TARGET = value\n"

" SUITE\n"

"except:\n"

" hit_except = True\n"

" if not exit(manager, *sys.exc_info()):\n"

" raise\n"

"finally:\n"

" if not hit_except:\n"

" exit(manager, None, None, None)"

msgstr ""

"manager = (EXPRESSION)\n"

"enter = type(manager).__enter__\n"

"exit = type(manager).__exit__\n"

"value = enter(manager)\n"

"hit_except = False\n"

"\n"

"try:\n"

" TARGET = value\n"

" SUITE\n"

"except:\n"

" hit_except = True\n"

" if not exit(manager, *sys.exc_info()):\n"

" raise\n"

"finally:\n"

" if not hit_except:\n"

" exit(manager, None, None, None)"

#: ../Doc/reference/compound_stmts.rst:550

msgid ""

"With more than one item, the context managers are processed as if multiple :"

"keyword:`with` statements were nested::"

msgstr ""

"Con más de un elemento, los administradores de contexto se procesan como si "

"varias sentencias :keyword:`with` estuvieran anidadas::"

#: ../Doc/reference/compound_stmts.rst:553

msgid ""

"with A() as a, B() as b:\n"

" SUITE"

msgstr ""

"with A() as a, B() as b:\n"

" SUITE"

#: ../Doc/reference/compound_stmts.rst:558

msgid ""

"with A() as a:\n"

" with B() as b:\n"

" SUITE"

msgstr ""

"with A() as a:\n"

" with B() as b:\n"

" SUITE"

#: ../Doc/reference/compound_stmts.rst:562

msgid ""

"You can also write multi-item context managers in multiple lines if the "

"items are surrounded by parentheses. For example::"

msgstr ""

"También puedes escribir administradores de contexto de múltiples ítems en "

"múltiples lineas si los ítems están entre paréntesis. Por ejemplo::"

#: ../Doc/reference/compound_stmts.rst:565

msgid ""

"with (\n"

" A() as a,\n"

" B() as b,\n"

"):\n"

" SUITE"

msgstr ""

"with (\n"

" A() as a,\n"

" B() as b,\n"

"):\n"

" SUITE"

#: ../Doc/reference/compound_stmts.rst:571

msgid "Support for multiple context expressions."

msgstr "Soporte para múltiples expresiones de contexto."

#: ../Doc/reference/compound_stmts.rst:574

msgid ""

"Support for using grouping parentheses to break the statement in multiple "

"lines."

msgstr ""

"Soporte para el uso de paréntesis de agrupación para separar la declaración "

"en múltiples líneas."

#: ../Doc/reference/compound_stmts.rst:580

msgid ":pep:`343` - The \"with\" statement"

msgstr ":pep:`343` - La sentencia \"with\""

#: ../Doc/reference/compound_stmts.rst:580

msgid ""

"The specification, background, and examples for the Python :keyword:`with` "

"statement."

msgstr ""

"La especificación, antecedentes y ejemplos de la sentencia de Python :"

"keyword:`with`."

#: ../Doc/reference/compound_stmts.rst:586

msgid "The :keyword:`!match` statement"

msgstr "La sentencia :keyword:`!match`"

#: ../Doc/reference/compound_stmts.rst:600

msgid "The match statement is used for pattern matching. Syntax:"

msgstr ""

"La declaración match es usada para coincidencia de patrones. Sintaxis:"

#: ../Doc/reference/compound_stmts.rst:609

msgid ""

"This section uses single quotes to denote :ref:`soft keywords <soft-"

"keywords>`."

msgstr ""

"Esta sección utiliza comillas simples para denotar las :ref:`palabras clave "

"suaves <soft-keywords>`."

# Se utilizó valor de búsqueda para traducir *subject value* basándose en la

# traducción francesa *champ de recherche*.

#: ../Doc/reference/compound_stmts.rst:612

msgid ""

"Pattern matching takes a pattern as input (following ``case``) and a subject "

"value (following ``match``). The pattern (which may contain subpatterns) is "

"matched against the subject value. The outcomes are:"