From a6ca60afa1c96a49fce2732ff8029e83546d695f Mon Sep 17 00:00:00 2001 From: Marco Richetta Date: Fri, 19 Nov 2021 13:00:34 -0300 Subject: [PATCH 1/8] =?UTF-8?q?Avance=20en=20traducci=C3=B3n=20(~48%)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- dictionaries/compound_stmts.txt | 1 + reference/compound_stmts.po | 49 +++++++++++++++++++++++++++------ 2 files changed, 41 insertions(+), 9 deletions(-) create mode 100644 dictionaries/compound_stmts.txt diff --git a/dictionaries/compound_stmts.txt b/dictionaries/compound_stmts.txt new file mode 100644 index 0000000000..8bb5f3b4af --- /dev/null +++ b/dictionaries/compound_stmts.txt @@ -0,0 +1 @@ +subpatrones \ No newline at end of file diff --git a/reference/compound_stmts.po b/reference/compound_stmts.po index b7bbc1cb73..2abcce6767 100644 --- a/reference/compound_stmts.po +++ b/reference/compound_stmts.po @@ -11,15 +11,16 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2021-10-16 21:42+0200\n" -"PO-Revision-Date: 2021-08-02 19:34+0200\n" +"PO-Revision-Date: 2021-11-17 10:19-0300\n" "Last-Translator: Cristián Maureira-Fredes \n" "Language: es_AR\n" "Language-Team: python-doc-es\n" -"Plural-Forms: nplurals=2; plural=(n != 1)\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 2.9.1\n" +"X-Generator: Poedit 3.0\n" #: ../Doc/reference/compound_stmts.rst:5 msgid "Compound statements" @@ -391,7 +392,6 @@ msgstr "" "esa pila hasta que ocurra la próxima recolección de basura." #: ../Doc/reference/compound_stmts.rst:302 -#, fuzzy msgid "" "Before an except clause's suite is executed, details about the exception are " "stored in the :mod:`sys` module and can be accessed via :func:`sys." @@ -408,7 +408,7 @@ msgstr "" "rastreo (ver sección :ref:`types`) que identifica el punto en el programa " "donde ocurrió la excepción. Lo valores :func:`sys.exc_info` se restauran a " "sus valores anteriores (antes de la llamada) al regresar de una función que " -"manejó una excepción." +"manejó una excepción::" #: ../Doc/reference/compound_stmts.rst:334 msgid "" @@ -632,6 +632,8 @@ 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:502 msgid "Support for multiple context expressions." @@ -642,6 +644,8 @@ 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:511 msgid ":pep:`343` - The \"with\" statement" @@ -656,59 +660,75 @@ msgstr "" "keyword:`with`." #: ../Doc/reference/compound_stmts.rst:517 -#, fuzzy msgid "The :keyword:`!match` statement" -msgstr "La sentencia :keyword:`!with`" +msgstr "La sentencia :keyword:`!match`" #: ../Doc/reference/compound_stmts.rst:530 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:539 msgid "" "This section uses single quotes to denote :ref:`soft keywords `." msgstr "" +"Esta sección utiliza comillas simples para denotar las :ref:`palabras clave " +"` suaves." +# 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:542 +#, fuzzy 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:" msgstr "" +"La coincidencia de patrones toma un patrón como entrada (delante de " +"``case``) y un valor de búsqueda (delante de ``match``). El patrón (que " +"puede contener subpatrones) es comparado con el valor de búsqueda. Los " +"resultados son:" #: ../Doc/reference/compound_stmts.rst:546 msgid "A match success or failure (also termed a pattern success or failure)." msgstr "" +"Una coincidencia exitosa o fallida (también llamada éxito o fracaso de un " +"patrón)." #: ../Doc/reference/compound_stmts.rst:548 msgid "" "Possible binding of matched values to a name. The prerequisites for this " "are further discussed below." msgstr "" +"Una posible vinculación de los valores coincidentes con un nombre. Los " +"requisitos previos para esto se discuten abajo." #: ../Doc/reference/compound_stmts.rst:551 msgid "" "The ``match`` and ``case`` keywords are :ref:`soft keywords `." msgstr "" +"Las palabras clave ``match`` y ``case`` son :ref:`palabras clave ` suaves." #: ../Doc/reference/compound_stmts.rst:555 #: ../Doc/reference/compound_stmts.rst:1109 msgid ":pep:`634` -- Structural Pattern Matching: Specification" -msgstr "" +msgstr ":pep:`634` -- Coincidencia de patrones estructurales: Especificación" #: ../Doc/reference/compound_stmts.rst:556 #: ../Doc/reference/compound_stmts.rst:1110 msgid ":pep:`636` -- Structural Pattern Matching: Tutorial" -msgstr "" +msgstr ":pep:`636` -- Coincidencia de patrones estructurales: Tutorial" #: ../Doc/reference/compound_stmts.rst:560 msgid "Overview" -msgstr "" +msgstr "Resumen" #: ../Doc/reference/compound_stmts.rst:562 msgid "Here's an overview of the logical flow of a match statement:" msgstr "" +"A continuación, un resumen del flujo lógico de una declaración de " +"coincidencia:" #: ../Doc/reference/compound_stmts.rst:565 msgid "" @@ -716,6 +736,9 @@ msgid "" "value obtained. If the subject expression contains a comma, a tuple is " "constructed using :ref:`the standard rules `." msgstr "" +"Se evalúa la expresión ``subject_expr`` y se obtiene un valor sujeto " +"resultante. Si la expresión contiene una coma, se construye una tupla " +"utilizando :ref:`las reglas estándar `." #: ../Doc/reference/compound_stmts.rst:569 msgid "" @@ -726,6 +749,14 @@ msgid "" "specified below. **Name bindings made during a successful pattern match " "outlive the executed block and can be used after the match statement**." msgstr "" +"Se intenta coincidir cada patrón en un ``case_block`` con el valor sujeto. " +"Las reglas específicas para el éxito o el fracaso se describen abajo. El " +"intento de coincidencia también puede enlazar algunos o todos los nombres " +"independientes dentro del patrón. Las reglas precisas de enlace de patrones " +"varían según el tipo de patrón y se especifican a continuación. **Los " +"enlaces de nombre realizados durante una coincidencia de patrones exitosa " +"sobreviven al bloque ejecutado y se pueden usar después de la declaración de " +"coincidencia**." #: ../Doc/reference/compound_stmts.rst:578 msgid "" From 01839f6066b38f360d9d21b93af70c7b4efaf1cb Mon Sep 17 00:00:00 2001 From: Marco Richetta Date: Mon, 20 Dec 2021 22:08:16 -0300 Subject: [PATCH 2/8] Traducido 159/295 - 53% --- reference/compound_stmts.po | 78 ++++++++++++++++++++++++++++++------- 1 file changed, 63 insertions(+), 15 deletions(-) diff --git a/reference/compound_stmts.po b/reference/compound_stmts.po index 2abcce6767..8f5f01e6fc 100644 --- a/reference/compound_stmts.po +++ b/reference/compound_stmts.po @@ -11,8 +11,8 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2021-10-16 21:42+0200\n" -"PO-Revision-Date: 2021-11-17 10:19-0300\n" -"Last-Translator: Cristián Maureira-Fredes \n" +"PO-Revision-Date: 2021-12-20 22:05-0300\n" +"Last-Translator: Marco Richetta \n" "Language: es_AR\n" "Language-Team: python-doc-es\n" "Plural-Forms: nplurals=2; plural=(n != 1);\n" @@ -678,7 +678,6 @@ msgstr "" # 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:542 -#, fuzzy msgid "" "Pattern matching takes a pattern as input (following ``case``) and a subject " "value (following ``match``). The pattern (which may contain subpatterns) is " @@ -766,26 +765,41 @@ msgid "" "dependent on implementation and may vary. This is an intentional decision " "made to allow different implementations to add optimizations." msgstr "" +"Durante las coincidencias de patrones fallidas, algunos subpatrones pueden " +"tener éxito. No confíe en que los enlaces se realicen para una coincidencia " +"fallida. Por el contrario, no confíe en que las variables permanezcan sin " +"cambios después de una coincidencia fallida. El comportamiento exacto " +"depende de la implementación y puede variar. Esta es una decisión " +"intencional para permitir que diferentes implementaciones añadan " +"optimizaciones." #: ../Doc/reference/compound_stmts.rst:585 msgid "" "If the pattern succeeds, the corresponding guard (if present) is evaluated. " "In this case all name bindings are guaranteed to have happened." msgstr "" +"Si el patrón es exitoso, se evalúa la protección correspondiente (si está " +"presente). En este caso se garantiza que todos los enlaces de nombres han " +"ocurrido." #: ../Doc/reference/compound_stmts.rst:588 msgid "" "If the guard evaluates as true or is missing, the ``block`` inside " "``case_block`` is executed." msgstr "" +"Si la protección se evalúa como verdadera o no existe, se ejecuta el " +"``block`` dentro de ``case_block``." #: ../Doc/reference/compound_stmts.rst:591 msgid "Otherwise, the next ``case_block`` is attempted as described above." msgstr "" +"En caso contrario, se intenta con el siguiente ``case_block`` como se ha " +"descrito anteriormente." #: ../Doc/reference/compound_stmts.rst:593 msgid "If there are no further case blocks, the match statement is completed." msgstr "" +"Si no hay más bloques de casos, la declaración de coincidencia se completa." #: ../Doc/reference/compound_stmts.rst:597 msgid "" @@ -793,20 +807,26 @@ msgid "" "on implementation, the interpreter may cache values or use other " "optimizations which skip repeated evaluations." msgstr "" +"Por lo general, los usuarios no deben confiar en que se evalúe un patrón. " +"Dependiendo de la implementación, el intérprete puede almacenar en caché los " +"valores o utilizar otras optimizaciones que omitan las evaluaciones " +"repetidas." #: ../Doc/reference/compound_stmts.rst:601 msgid "A sample match statement::" -msgstr "" +msgstr "Un ejemplo de declaración de coincidencia::" #: ../Doc/reference/compound_stmts.rst:617 msgid "" "In this case, ``if flag`` is a guard. Read more about that in the next " "section." msgstr "" +"En este caso, ``if flag`` es una protección. Lea más sobre eso en la " +"siguiente sección." #: ../Doc/reference/compound_stmts.rst:620 msgid "Guards" -msgstr "" +msgstr "Protecciones" #: ../Doc/reference/compound_stmts.rst:627 msgid "" @@ -814,10 +834,14 @@ msgid "" "``case`` block to execute. It takes the form: :keyword:`if` followed by an " "expression." msgstr "" +"Una ``guard`` (que es parte del ``case``) debe ser exitosa para que el " +"código dentro de ``case`` sea ejecutado. Toma la forma: :keyword:`if` " +"seguida de una expresión." #: ../Doc/reference/compound_stmts.rst:632 msgid "The logical flow of a ``case`` block with a ``guard`` follows:" msgstr "" +"El flujo lógico de un bloque ``case`` con una ``guard`` es el siguiente:" #: ../Doc/reference/compound_stmts.rst:634 msgid "" @@ -825,27 +849,35 @@ msgid "" "failed, the ``guard`` is not evaluated and the next ``case`` block is " "checked." msgstr "" +"Se comprueba que el patrón del bloque ``case`` fue exitoso. Si el patrón " +"falló, el ``guard`` no se evalúa y se comprueba el siguiente bloque ``case``." #: ../Doc/reference/compound_stmts.rst:638 msgid "If the pattern succeeded, evaluate the ``guard``." -msgstr "" +msgstr "Si el patrón tuvo éxito, se evalúa el ``guard``." #: ../Doc/reference/compound_stmts.rst:640 msgid "" "If the ``guard`` condition evaluates as true, the case block is selected." msgstr "" +"Si la condición del ``guard`` es verdadera, se selecciona el bloque de ese " +"caso." #: ../Doc/reference/compound_stmts.rst:643 msgid "" "If the ``guard`` condition evaluates as false, the case block is not " "selected." msgstr "" +"Si la condición del ``guard`` es falsa, el bloque de ese caso no es " +"seleccionado." #: ../Doc/reference/compound_stmts.rst:646 msgid "" "If the ``guard`` raises an exception during evaluation, the exception " "bubbles up." msgstr "" +"Si el ``guard`` genera una excepción durante la evaluación, se levanta la " +"excepción." #: ../Doc/reference/compound_stmts.rst:649 msgid "" @@ -855,16 +887,25 @@ msgid "" "evaluation must happen in order.) Guard evaluation must stop once a case " "block is selected." msgstr "" +"Se permite que las protecciones tengan efectos secundarios, ya que son " +"expresiones. La evaluación de la protección debe ir desde el primer al " +"último bloque de casos, uno a la vez, saltando los bloques de casos cuyo(s) " +"patrón(es) no tenga(n) éxito. (Es decir, la evaluación de las protecciones " +"debe realizarse en orden.) La evaluación de las protecciones debe detenerse " +"una vez que se selecciona un bloque de casos." #: ../Doc/reference/compound_stmts.rst:659 msgid "Irrefutable Case Blocks" -msgstr "" +msgstr "Bloques de Casos Irrefutables" #: ../Doc/reference/compound_stmts.rst:663 msgid "" "An irrefutable case block is a match-all case block. A match statement may " "have at most one irrefutable case block, and it must be last." msgstr "" +"Un bloque de casos irrefutable es un bloque de casos que coincide con todo. " +"Una declaración de coincidencia puede tener como máximo un bloque de casos " +"irrefutable, y debe ser el último." #: ../Doc/reference/compound_stmts.rst:666 msgid "" @@ -873,46 +914,53 @@ msgid "" "syntax alone that it will always succeed. Only the following patterns are " "irrefutable:" msgstr "" +"Un bloque de casos se considera irrefutable si no tiene protección y su " +"patrón es irrefutable. Un patrón se considera irrefutable si podemos " +"demostrar, sólo por su sintaxis, que siempre tendrá éxito. Sólo los " +"siguientes patrones son irrefutables:" #: ../Doc/reference/compound_stmts.rst:671 msgid ":ref:`as-patterns` whose left-hand side is irrefutable" -msgstr "" +msgstr ":ref:`as-patterns` cuyo lado izquierdo es irrefutable" #: ../Doc/reference/compound_stmts.rst:673 msgid ":ref:`or-patterns` containing at least one irrefutable pattern" -msgstr "" +msgstr ":ref:`or-patterns` que contienen al menos un patrón irrefutable" #: ../Doc/reference/compound_stmts.rst:675 msgid ":ref:`capture-patterns`" -msgstr "" +msgstr ":ref:`capture-patterns`" #: ../Doc/reference/compound_stmts.rst:677 msgid ":ref:`wildcard-patterns`" -msgstr "" +msgstr ":ref:`wildcard-patterns`" #: ../Doc/reference/compound_stmts.rst:679 msgid "parenthesized irrefutable patterns" -msgstr "" +msgstr "patrones irrefutables entre paréntesis" #: ../Doc/reference/compound_stmts.rst:683 msgid "Patterns" -msgstr "" +msgstr "Patrones" #: ../Doc/reference/compound_stmts.rst:690 msgid "This section uses grammar notations beyond standard EBNF:" msgstr "" +"Esta sección utiliza notaciones gramaticales más allá del estándar EBNF:" #: ../Doc/reference/compound_stmts.rst:692 msgid "the notation ``SEP.RULE+`` is shorthand for ``RULE (SEP RULE)*``" -msgstr "" +msgstr "la notación ``SEP.RULE+`` es la abreviación de ``RULE (SEP RULE)*``" #: ../Doc/reference/compound_stmts.rst:694 msgid "the notation ``!RULE`` is shorthand for a negative lookahead assertion" msgstr "" +"la notación ``!RULE`` es la abreviación de una aserción de anticipación " +"negativa" #: ../Doc/reference/compound_stmts.rst:697 msgid "The top-level syntax for ``patterns`` is:" -msgstr "" +msgstr "La sintaxis de nivel superior para ``patrones`` es:" #: ../Doc/reference/compound_stmts.rst:711 msgid "" From f6cc4b7c6b823b843e2ddf3795f1da22904c45fc Mon Sep 17 00:00:00 2001 From: Marco Richetta Date: Mon, 3 Jan 2022 22:11:51 -0300 Subject: [PATCH 3/8] Apply suggestions from code review Co-authored-by: Carlos A. Crespo --- reference/compound_stmts.po | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/reference/compound_stmts.po b/reference/compound_stmts.po index 8f5f01e6fc..f6698d7bc8 100644 --- a/reference/compound_stmts.po +++ b/reference/compound_stmts.po @@ -674,7 +674,7 @@ msgid "" "keywords>`." msgstr "" "Esta sección utiliza comillas simples para denotar las :ref:`palabras clave " -"` suaves." +"suaves `." # 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:542 @@ -706,8 +706,8 @@ msgstr "" msgid "" "The ``match`` and ``case`` keywords are :ref:`soft keywords `." msgstr "" -"Las palabras clave ``match`` y ``case`` son :ref:`palabras clave ` suaves." +"Las palabras clave ``match`` y ``case`` son :ref:`palabras clave suaves `." #: ../Doc/reference/compound_stmts.rst:555 #: ../Doc/reference/compound_stmts.rst:1109 From d4ee943e1c249174f9574f1a872d94e5d1b835df Mon Sep 17 00:00:00 2001 From: Marco Richetta Date: Mon, 3 Jan 2022 22:25:10 -0300 Subject: [PATCH 4/8] Se corre powrap localmente para pasar CI --- reference/compound_stmts.po | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/reference/compound_stmts.po b/reference/compound_stmts.po index f6698d7bc8..bdeda3b49d 100644 --- a/reference/compound_stmts.po +++ b/reference/compound_stmts.po @@ -706,8 +706,8 @@ msgstr "" msgid "" "The ``match`` and ``case`` keywords are :ref:`soft keywords `." msgstr "" -"Las palabras clave ``match`` y ``case`` son :ref:`palabras clave suaves `." +"Las palabras clave ``match`` y ``case`` son :ref:`palabras clave suaves " +"`." #: ../Doc/reference/compound_stmts.rst:555 #: ../Doc/reference/compound_stmts.rst:1109 From 6e58ea8966cd46e984ca9fa40a5eabf05a18e522 Mon Sep 17 00:00:00 2001 From: "Carlos A. Crespo" Date: Thu, 6 Jan 2022 10:11:00 -0300 Subject: [PATCH 5/8] translate 100% --- reference/compound_stmts.po | 1460 +++++++++++++++++++---------------- 1 file changed, 815 insertions(+), 645 deletions(-) diff --git a/reference/compound_stmts.po b/reference/compound_stmts.po index bdeda3b49d..d2231b707d 100644 --- a/reference/compound_stmts.po +++ b/reference/compound_stmts.po @@ -11,14 +11,14 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2021-10-16 21:42+0200\n" -"PO-Revision-Date: 2021-12-20 22:05-0300\n" -"Last-Translator: Marco Richetta \n" -"Language: es_AR\n" +"PO-Revision-Date: 2022-01-06 10:10-0300\n" +"Last-Translator: Carlos A. Crespo \n" "Language-Team: python-doc-es\n" -"Plural-Forms: nplurals=2; plural=(n != 1);\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.9.1\n" "X-Generator: Poedit 3.0\n" @@ -34,8 +34,8 @@ msgid "" "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 " +"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." @@ -44,54 +44,53 @@ 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." +"`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 " +"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::" +"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::" +"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: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::" +"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::" +"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:45 msgid "Summarizing:" @@ -100,25 +99,25 @@ 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 " +"``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)." +"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." +"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" @@ -130,19 +129,18 @@ 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." +"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." +"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" @@ -160,25 +158,25 @@ msgstr "" 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." +"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." +"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." +"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." +"`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" @@ -195,90 +193,90 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:160 msgid "" -"The expression list is evaluated once; it should yield an iterable object. " -"An iterator is created for the result of the ``expression_list``. The suite " -"is then executed once for each item provided by the iterator, in the order " +"The expression list is evaluated once; it should yield an iterable object. An " +"iterator is created for the result of the ``expression_list``. The suite is " +"then executed once for each item provided by the iterator, in the order " "returned by the iterator. Each item in turn is assigned to the target list " -"using the standard rules for assignments (see :ref:`assignment`), and then " -"the suite is executed. When the items are exhausted (which is immediately " -"when the sequence is empty or an iterator raises a :exc:`StopIteration` " -"exception), the suite in the :keyword:`!else` clause, if present, is " -"executed, and the loop terminates." +"using the standard rules for assignments (see :ref:`assignment`), and then the " +"suite is executed. When the items are exhausted (which is immediately when " +"the sequence is empty or an iterator raises a :exc:`StopIteration` exception), " +"the suite in the :keyword:`!else` clause, if present, is executed, and the " +"loop terminates." msgstr "" "La lista de expresiones se evalúa una vez; debería producir un objeto " -"iterable. Se crea un iterador para el resultado de la ``expression_list``. " -"La suite se ejecuta una vez para cada elemento proporcionado por el " -"iterador, en el orden retornado por el iterador. Cada elemento a su vez se " -"asigna a la lista utilizando las reglas estándar para las asignaciones (ver :" -"ref:`assignment`), y luego se ejecuta la suite. Cuando los elementos están " +"iterable. Se crea un iterador para el resultado de la ``expression_list``. La " +"suite se ejecuta una vez para cada elemento proporcionado por el iterador, en " +"el orden retornado por el iterador. Cada elemento a su vez se asigna a la " +"lista utilizando las reglas estándar para las asignaciones (ver :ref:" +"`assignment`), y luego se ejecuta la suite. Cuando los elementos están " "agotados (que es inmediatamente cuando la secuencia está vacía o un iterador " -"genera una excepción del tipo :exc:`StopIteration`), la suite en la " -"cláusula :keyword:`!else`, si está presente, se ejecuta y el bucle termina." +"genera una excepción del tipo :exc:`StopIteration`), la suite en la cláusula :" +"keyword:`!else`, si está presente, se ejecuta y el bucle 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." +"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." +"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::" +"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``::" +"sobrescribe todas las asignaciones anteriores a esas variables, incluidas las " +"realizadas en la suite del bucle ``for``::" #: ../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 function :func:`range` returns an iterator of " -"integers suitable to emulate the effect of Pascal's ``for i := a to b do``; " -"e.g., ``list(range(3))`` returns the list ``[0, 1, 2]``." +"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 function :func:`range` returns an iterator of integers " +"suitable to emulate the effect of Pascal's ``for i := a to b do``; e.g., " +"``list(range(3))`` returns the list ``[0, 1, 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: la " -"función incorporada :func:`range` retorna un iterador de enteros adecuado " -"para emular el efecto de Pascal ``for i := a to b do``; por ejemplo, " +"función incorporada :func:`range` retorna un iterador de enteros adecuado para " +"emular el efecto de Pascal ``for i := a to b do``; por ejemplo, " "``list(range(3))`` retorna la lista ``[0, 1, 2]``." #: ../Doc/reference/compound_stmts.rst:205 msgid "" -"There is a subtlety when the sequence is being modified by the loop (this " -"can only occur for mutable sequences, e.g. lists). An internal counter is " -"used to keep track of which item is used next, and this is incremented on " -"each iteration. When this counter has reached the length of the sequence " -"the loop terminates. This means that if the suite deletes the current (or a " -"previous) item from the sequence, the next item will be skipped (since it " -"gets the index of the current item which has already been treated). " -"Likewise, if the suite inserts an item in the sequence before the current " -"item, the current item will be treated again the next time through the loop. " -"This can lead to nasty bugs that can be avoided by making a temporary copy " -"using a slice of the whole sequence, e.g., ::" -msgstr "" -"Hay una sutileza cuando la secuencia está siendo modificada por el bucle " -"(esto solo puede ocurrir para secuencias mutables, por ejemplo, listas). Se " -"utiliza un contador interno para realizar un seguimiento de qué elemento se " -"usa a continuación, y esto se incrementa en cada iteración. Cuando este " -"contador ha alcanzado la longitud de la secuencia, el bucle termina. Esto " -"significa que si la suite elimina el elemento actual (o anterior) de la " -"secuencia, se omitirá el siguiente elemento (ya que obtiene el índice del " -"elemento actual que ya ha sido tratado). Del mismo modo, si la suite inserta " -"un elemento en la secuencia anterior al elemento actual, el elemento actual " -"será tratado nuevamente la próxima vez a través del bucle. Esto puede " -"conducir a errores graves que se pueden evitar haciendo una copia temporal " -"usando una porción de la secuencia completa, por ejemplo, ::" +"There is a subtlety when the sequence is being modified by the loop (this can " +"only occur for mutable sequences, e.g. lists). An internal counter is used to " +"keep track of which item is used next, and this is incremented on each " +"iteration. When this counter has reached the length of the sequence the loop " +"terminates. This means that if the suite deletes the current (or a previous) " +"item from the sequence, the next item will be skipped (since it gets the index " +"of the current item which has already been treated). Likewise, if the suite " +"inserts an item in the sequence before the current item, the current item will " +"be treated again the next time through the loop. This can lead to nasty bugs " +"that can be avoided by making a temporary copy using a slice of the whole " +"sequence, e.g., ::" +msgstr "" +"Hay una sutileza cuando la secuencia está siendo modificada por el bucle (esto " +"solo puede ocurrir para secuencias mutables, por ejemplo, listas). Se utiliza " +"un contador interno para realizar un seguimiento de qué elemento se usa a " +"continuación, y esto se incrementa en cada iteración. Cuando este contador ha " +"alcanzado la longitud de la secuencia, el bucle termina. Esto significa que si " +"la suite elimina el elemento actual (o anterior) de la secuencia, se omitirá " +"el siguiente elemento (ya que obtiene el índice del elemento actual que ya ha " +"sido tratado). Del mismo modo, si la suite inserta un elemento en la secuencia " +"anterior al elemento actual, el elemento actual será tratado nuevamente la " +"próxima vez a través del bucle. Esto puede conducir a errores graves que se " +"pueden evitar haciendo una copia temporal usando una porción de la secuencia " +"completa, por ejemplo, ::" #: ../Doc/reference/compound_stmts.rst:226 msgid "The :keyword:`!try` statement" @@ -286,45 +284,43 @@ msgstr "La sentencia :keyword:`!try`" #: ../Doc/reference/compound_stmts.rst:236 msgid "" -"The :keyword:`try` statement specifies exception handlers and/or cleanup " -"code for a group of statements:" +"The :keyword:`try` statement specifies exception handlers and/or cleanup code " +"for a group of statements:" msgstr "" -"La sentencia :keyword:`try` es especifica para gestionar excepciones o " -"código de limpieza para un grupo de sentencias:" +"La sentencia :keyword:`try` es especifica para gestionar excepciones o código " +"de limpieza para un grupo de sentencias:" #: ../Doc/reference/compound_stmts.rst:249 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 except " -"clauses in turn until one is found that matches the exception. An " -"expression-less except clause, if present, must be last; it matches any " -"exception. For an except clause with an expression, that expression is " -"evaluated, and the clause matches the exception if the resulting object is " -"\"compatible\" with the exception. An object is compatible with an " -"exception if it is the class or a base class of the exception object, or a " -"tuple containing an item that is the class or a base class of the exception " -"object." +"executed. When an exception occurs in the :keyword:`!try` suite, a search for " +"an exception handler is started. This search inspects the except clauses in " +"turn until one is found that matches the exception. An expression-less except " +"clause, if present, must be last; it matches any exception. For an except " +"clause with an expression, that expression is evaluated, and the clause " +"matches the exception if the resulting object is \"compatible\" with the " +"exception. An object is compatible with an exception if it is the class or a " +"base class of the exception object, or a tuple containing an item that is the " +"class or a base class of the exception object." msgstr "" "Las cláusulas :keyword:`except` especifican uno o más manejadores de " "excepciones. Cuando no ocurre ninguna excepción en la palabra clave :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 " -"manejador de excepciones. Esta búsqueda inspecciona las cláusulas except a " -"su vez hasta encontrar una que coincida con la excepción. Una cláusula " -"except sin expresión, si está presente, debe ser la última; coincide con " -"cualquier excepción. Para una cláusula except con una expresión, esa " -"expresión se evalúa y la cláusula coincide con la excepción si el objeto " -"resultante es \"compatible\" con la excepción. Un objeto es compatible con " -"una excepción si es la clase o una clase base del objeto de excepción, o una " -"tupla que contiene un elemento que es la clase o una clase base del objeto " -"de excepción." +"excepción en la suite :keyword:`!try`, se inicia una búsqueda de un manejador " +"de excepciones. Esta búsqueda inspecciona las cláusulas except a su vez hasta " +"encontrar una que coincida con la excepción. Una cláusula except sin " +"expresión, si está presente, debe ser la última; coincide con cualquier " +"excepción. Para una cláusula except con una expresión, esa expresión se evalúa " +"y la cláusula coincide con la excepción si el objeto resultante es \"compatible" +"\" con la excepción. Un objeto es compatible con una excepción si es la clase " +"o una clase base del objeto de excepción, o una tupla que contiene un elemento " +"que es la clase o una clase base del objeto de excepción." #: ../Doc/reference/compound_stmts.rst:261 msgid "" -"If no except clause matches the exception, the search for an exception " -"handler continues in the surrounding code and on the invocation stack. [#]_" +"If no 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 ``except`` coincide con la excepción, la búsqueda de un " "gestor de excepciones continúa en el código circundante y en la pila de " @@ -332,17 +328,16 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:264 msgid "" -"If the evaluation of an expression in the header of an 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)." +"If the evaluation of an expression in the header of an 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 " -"``except`` genera una excepción, la búsqueda original de un gestor se " -"cancela y se inicia la 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` provocó la excepción)." +"Si la evaluación de una expresión en el encabezado de una cláusula ``except`` " +"genera una excepción, la búsqueda original de un gestor se cancela y se inicia " +"la 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` provocó la " +"excepción)." #: ../Doc/reference/compound_stmts.rst:271 msgid "" @@ -351,27 +346,27 @@ msgid "" "present, and the except clause's suite is executed. All except clauses must " "have an executable block. When the end of this block is reached, execution " "continues normally after the entire try statement. (This means that if two " -"nested handlers exist for the same exception, and the exception occurs in " -"the try clause of the inner handler, the outer handler will not handle the " +"nested handlers exist for the same exception, and the exception occurs in the " +"try clause of the inner handler, the outer handler will not handle the " "exception.)" msgstr "" "Cuando se encuentra una cláusula ``except`` coincidente, la excepción se " "asigna al destino especificado después de la palabra clave :keyword:`!as` en " -"esa cláusula ``except``, si está presente, y se ejecuta la suite de " -"cláusulas ``except``. Todas las cláusulas ``except`` deben tener un bloque " -"ejecutable. Cuando se alcanza el final de este bloque, la ejecución continúa " -"normalmente después de toda la sentencia try. (Esto significa que si existen " -"dos gestores de errores anidados para la misma excepción, y la excepción " -"ocurre en la cláusula ``try`` del gestor interno, el gestor externo no " -"gestionará la excepción)." +"esa cláusula ``except``, si está presente, y se ejecuta la suite de cláusulas " +"``except``. Todas las cláusulas ``except`` deben tener un bloque ejecutable. " +"Cuando se alcanza el final de este bloque, la ejecución continúa normalmente " +"después de toda la sentencia try. (Esto significa que si existen dos gestores " +"de errores anidados para la misma excepción, y la excepción ocurre en la " +"cláusula ``try`` del gestor interno, el gestor externo no gestionará la " +"excepción)." #: ../Doc/reference/compound_stmts.rst:279 msgid "" -"When an exception has been assigned using ``as target``, it is cleared at " -"the end of the except clause. This is as if ::" +"When an exception has been assigned using ``as target``, it is cleared at the " +"end of the except clause. This is as if ::" msgstr "" -"Cuando se ha asignado una excepción usando ``as target``, se borra al final " -"de la cláusula ``except``. Esto es como si ::" +"Cuando se ha asignado una excepción usando ``as target``, se borra al final de " +"la cláusula ``except``. Esto es como si ::" #: ../Doc/reference/compound_stmts.rst:285 msgid "was translated to ::" @@ -380,10 +375,10 @@ msgstr "fue traducido a ::" #: ../Doc/reference/compound_stmts.rst:293 msgid "" "This means the exception must be assigned to a different name to be able to " -"refer to it after the 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." +"refer to it after the 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 referirse a ella después de la cláusula ``except``. Las excepciones se " @@ -394,29 +389,29 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:302 msgid "" "Before an except clause's suite is executed, details about the exception are " -"stored in the :mod:`sys` module and can be accessed via :func:`sys." -"exc_info`. :func:`sys.exc_info` returns a 3-tuple consisting of the " -"exception class, the exception instance and a traceback object (see section :" -"ref:`types`) identifying the point in the program where the exception " -"occurred. The details about the exception accessed via :func:`sys.exc_info` " -"are restored to their previous values when leaving an exception handler::" +"stored in the :mod:`sys` module and can be accessed via :func:`sys.exc_info`. :" +"func:`sys.exc_info` returns a 3-tuple consisting of the exception class, the " +"exception instance and a traceback object (see section :ref:`types`) " +"identifying the point in the program where the exception occurred. The " +"details about the exception accessed via :func:`sys.exc_info` are restored to " +"their previous values when leaving an exception handler::" msgstr "" "Antes de que se ejecute un conjunto de cláusulas ``except``, los detalles " "sobre la excepción se almacenan en el módulo :mod:`sys` y se puede acceder a " "través de :func:`sys.exc_info`. :func:`sys.exc_info` retorna 3 tuplas que " "consisten en la clase de excepción, la instancia de excepción y un objeto de " "rastreo (ver sección :ref:`types`) que identifica el punto en el programa " -"donde ocurrió la excepción. Lo valores :func:`sys.exc_info` se restauran a " -"sus valores anteriores (antes de la llamada) al regresar de una función que " -"manejó una excepción::" +"donde ocurrió la excepción. Lo valores :func:`sys.exc_info` se restauran a sus " +"valores anteriores (antes de la llamada) al regresar de una función que manejó " +"una excepción::" #: ../Doc/reference/compound_stmts.rst:334 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." +"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ó " @@ -427,46 +422,45 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:342 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 está presente :keyword:`finally`, esto especifica un gestor de " -"'limpieza'. La cláusula :keyword:`try` se ejecuta, incluidas las cláusulas :" -"keyword:`except` y :keyword:`!else`. Si se produce 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::" +"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 está presente :keyword:`finally`, esto especifica un gestor de 'limpieza'. " +"La cláusula :keyword:`try` se ejecuta, incluidas las cláusulas :keyword:" +"`except` y :keyword:`!else`. Si se produce 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:361 msgid "" -"The exception information is not available to the program during execution " -"of the :keyword:`finally` clause." +"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:369 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.'" +"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 la suite :keyword:`try` de un :keyword:`!try`...\\ la " -"sentencia :keyword:`!finally`, la cláusula :keyword:`finally` también se " -"ejecuta 'al salir'." +"Cuando se ejecuta una sentencia :keyword:`return`, :keyword:`break` o :keyword:" +"`continue` en la suite :keyword:`try` de un :keyword:`!try`...\\ la sentencia :" +"keyword:`!finally`, la cláusula :keyword:`finally` también se ejecuta 'al " +"salir'." #: ../Doc/reference/compound_stmts.rst:373 msgid "" @@ -476,9 +470,9 @@ msgid "" "always be the last one executed::" msgstr "" "El valor de retorno de una función está determinado por la última sentencia :" -"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 ejecutada::" +"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 ejecutada::" #: ../Doc/reference/compound_stmts.rst:387 msgid "" @@ -486,10 +480,9 @@ msgid "" "`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 generar excepciones se puede encontrar en la sección :" -"ref:`raise`." +"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 generar excepciones se puede encontrar en la sección :ref:`raise`." #: ../Doc/reference/compound_stmts.rst:391 msgid "" @@ -510,19 +503,19 @@ msgid "" "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." +"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:419 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:" +"La ejecución de la sentencia :keyword:`with` con un \"item\" se realiza de la " +"siguiente manera:" #: ../Doc/reference/compound_stmts.rst:421 msgid "" @@ -535,8 +528,7 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:424 msgid "The context manager's :meth:`__enter__` is loaded for later use." msgstr "" -"El administrador de contexto :meth:`__enter__` se carga para su uso " -"posterior." +"El administrador de contexto :meth:`__enter__` se carga para su uso posterior." #: ../Doc/reference/compound_stmts.rst:426 msgid "The context manager's :meth:`__exit__` is loaded for later use." @@ -557,17 +549,17 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:435 msgid "" -"The :keyword:`with` statement guarantees that if the :meth:`__enter__` " -"method returns without an error, then :meth:`__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 6 below." +"The :keyword:`with` statement guarantees that if the :meth:`__enter__` method " +"returns without an error, then :meth:`__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 6 " +"below." msgstr "" "La sentencia :keyword:`with` garantiza que si el método :meth:`__enter__` " "regresa sin error, entonces siempre se llamará a :meth:`__exit__`. Por lo " -"tanto, si se produce un error durante la asignación a la lista de destino, " -"se tratará de la misma manera que si se produciría un error dentro de la " -"suite. Vea el paso 6 a continuación." +"tanto, si se produce un error durante la asignación a la lista de destino, se " +"tratará de la misma manera que si se produciría un error dentro de la suite. " +"Vea el paso 6 a continuación." #: ../Doc/reference/compound_stmts.rst:441 msgid "The suite is executed." @@ -581,16 +573,16 @@ msgid "" "supplied." msgstr "" "Se invoca el método del administrador de contexto :meth:`__exit__`. Si una " -"excepción causó la salida de la suite, su tipo, valor y rastreo se pasan " -"como argumentos a :meth:`__exit__`. De lo contrario, se proporcionan tres " +"excepción causó la salida de la suite, su tipo, valor y rastreo se pasan como " +"argumentos a :meth:`__exit__`. De lo contrario, se proporcionan tres " "argumentos :const:`None`." #: ../Doc/reference/compound_stmts.rst:448 msgid "" "If the suite was exited due to an exception, and the return value from the :" "meth:`__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." +"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:`__exit__` fue falso, la excepción se vuelve a plantear. Si el " @@ -629,8 +621,8 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:493 msgid "" -"You can also write multi-item context managers in multiple lines if the " -"items are surrounded by parentheses. For example::" +"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::" @@ -644,8 +636,8 @@ 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." +"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:511 msgid ":pep:`343` - The \"with\" statement" @@ -656,8 +648,8 @@ 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`." +"La especificación, antecedentes y ejemplos de la sentencia de Python :keyword:" +"`with`." #: ../Doc/reference/compound_stmts.rst:517 msgid "The :keyword:`!match` statement" @@ -665,28 +657,26 @@ msgstr "La sentencia :keyword:`!match`" #: ../Doc/reference/compound_stmts.rst:530 msgid "The match statement is used for pattern matching. Syntax:" -msgstr "" -"La declaración match es usada para coincidencia de patrones. Sintaxis:" +msgstr "La declaración match es usada para coincidencia de patrones. Sintaxis:" #: ../Doc/reference/compound_stmts.rst:539 msgid "" -"This section uses single quotes to denote :ref:`soft keywords `." +"This section uses single quotes to denote :ref:`soft keywords `." msgstr "" "Esta sección utiliza comillas simples para denotar las :ref:`palabras clave " "suaves `." -# Se utilizó valor de búsqueda para traducir *subject value* basándose en la traducción francesa *champ de recherche*. +# 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:542 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:" msgstr "" -"La coincidencia de patrones toma un patrón como entrada (delante de " -"``case``) y un valor de búsqueda (delante de ``match``). El patrón (que " -"puede contener subpatrones) es comparado con el valor de búsqueda. Los " -"resultados son:" +"La coincidencia de patrones toma un patrón como entrada (delante de ``case``) " +"y un valor de búsqueda (delante de ``match``). El patrón (que puede contener " +"subpatrones) es comparado con el valor de búsqueda. Los resultados son:" #: ../Doc/reference/compound_stmts.rst:546 msgid "A match success or failure (also termed a pattern success or failure)." @@ -696,8 +686,8 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:548 msgid "" -"Possible binding of matched values to a name. The prerequisites for this " -"are further discussed below." +"Possible binding of matched values to a name. The prerequisites for this are " +"further discussed below." msgstr "" "Una posible vinculación de los valores coincidentes con un nombre. Los " "requisitos previos para esto se discuten abajo." @@ -706,8 +696,8 @@ msgstr "" msgid "" "The ``match`` and ``case`` keywords are :ref:`soft keywords `." msgstr "" -"Las palabras clave ``match`` y ``case`` son :ref:`palabras clave suaves " -"`." +"Las palabras clave ``match`` y ``case`` son :ref:`palabras clave suaves `." #: ../Doc/reference/compound_stmts.rst:555 #: ../Doc/reference/compound_stmts.rst:1109 @@ -726,8 +716,7 @@ msgstr "Resumen" #: ../Doc/reference/compound_stmts.rst:562 msgid "Here's an overview of the logical flow of a match statement:" msgstr "" -"A continuación, un resumen del flujo lógico de una declaración de " -"coincidencia:" +"A continuación, un resumen del flujo lógico de una declaración de coincidencia:" #: ../Doc/reference/compound_stmts.rst:565 msgid "" @@ -741,42 +730,41 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:569 msgid "" -"Each pattern in a ``case_block`` is attempted to match with the subject " -"value. The specific rules for success or failure are described below. The " -"match attempt can also bind some or all of the standalone names within the " -"pattern. The precise pattern binding rules vary per pattern type and are " -"specified below. **Name bindings made during a successful pattern match " -"outlive the executed block and can be used after the match statement**." +"Each pattern in a ``case_block`` is attempted to match with the subject value. " +"The specific rules for success or failure are described below. The match " +"attempt can also bind some or all of the standalone names within the pattern. " +"The precise pattern binding rules vary per pattern type and are specified " +"below. **Name bindings made during a successful pattern match outlive the " +"executed block and can be used after the match statement**." msgstr "" -"Se intenta coincidir cada patrón en un ``case_block`` con el valor sujeto. " -"Las reglas específicas para el éxito o el fracaso se describen abajo. El " -"intento de coincidencia también puede enlazar algunos o todos los nombres " +"Se intenta coincidir cada patrón en un ``case_block`` con el valor sujeto. Las " +"reglas específicas para el éxito o el fracaso se describen abajo. El intento " +"de coincidencia también puede enlazar algunos o todos los nombres " "independientes dentro del patrón. Las reglas precisas de enlace de patrones " -"varían según el tipo de patrón y se especifican a continuación. **Los " -"enlaces de nombre realizados durante una coincidencia de patrones exitosa " -"sobreviven al bloque ejecutado y se pueden usar después de la declaración de " +"varían según el tipo de patrón y se especifican a continuación. **Los enlaces " +"de nombre realizados durante una coincidencia de patrones exitosa sobreviven " +"al bloque ejecutado y se pueden usar después de la declaración de " "coincidencia**." #: ../Doc/reference/compound_stmts.rst:578 msgid "" "During failed pattern matches, some subpatterns may succeed. Do not rely on " -"bindings being made for a failed match. Conversely, do not rely on " -"variables remaining unchanged after a failed match. The exact behavior is " -"dependent on implementation and may vary. This is an intentional decision " -"made to allow different implementations to add optimizations." +"bindings being made for a failed match. Conversely, do not rely on variables " +"remaining unchanged after a failed match. The exact behavior is dependent on " +"implementation and may vary. This is an intentional decision made to allow " +"different implementations to add optimizations." msgstr "" "Durante las coincidencias de patrones fallidas, algunos subpatrones pueden " "tener éxito. No confíe en que los enlaces se realicen para una coincidencia " "fallida. Por el contrario, no confíe en que las variables permanezcan sin " -"cambios después de una coincidencia fallida. El comportamiento exacto " -"depende de la implementación y puede variar. Esta es una decisión " -"intencional para permitir que diferentes implementaciones añadan " -"optimizaciones." +"cambios después de una coincidencia fallida. El comportamiento exacto depende " +"de la implementación y puede variar. Esta es una decisión intencional para " +"permitir que diferentes implementaciones añadan optimizaciones." #: ../Doc/reference/compound_stmts.rst:585 msgid "" -"If the pattern succeeds, the corresponding guard (if present) is evaluated. " -"In this case all name bindings are guaranteed to have happened." +"If the pattern succeeds, the corresponding guard (if present) is evaluated. In " +"this case all name bindings are guaranteed to have happened." msgstr "" "Si el patrón es exitoso, se evalúa la protección correspondiente (si está " "presente). En este caso se garantiza que todos los enlaces de nombres han " @@ -787,8 +775,8 @@ msgid "" "If the guard evaluates as true or is missing, the ``block`` inside " "``case_block`` is executed." msgstr "" -"Si la protección se evalúa como verdadera o no existe, se ejecuta el " -"``block`` dentro de ``case_block``." +"Si la protección se evalúa como verdadera o no existe, se ejecuta el ``block`` " +"dentro de ``case_block``." #: ../Doc/reference/compound_stmts.rst:591 msgid "Otherwise, the next ``case_block`` is attempted as described above." @@ -803,14 +791,13 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:597 msgid "" -"Users should generally never rely on a pattern being evaluated. Depending " -"on implementation, the interpreter may cache values or use other " -"optimizations which skip repeated evaluations." +"Users should generally never rely on a pattern being evaluated. Depending on " +"implementation, the interpreter may cache values or use other optimizations " +"which skip repeated evaluations." msgstr "" "Por lo general, los usuarios no deben confiar en que se evalúe un patrón. " "Dependiendo de la implementación, el intérprete puede almacenar en caché los " -"valores o utilizar otras optimizaciones que omitan las evaluaciones " -"repetidas." +"valores o utilizar otras optimizaciones que omitan las evaluaciones repetidas." #: ../Doc/reference/compound_stmts.rst:601 msgid "A sample match statement::" @@ -834,20 +821,18 @@ msgid "" "``case`` block to execute. It takes the form: :keyword:`if` followed by an " "expression." msgstr "" -"Una ``guard`` (que es parte del ``case``) debe ser exitosa para que el " -"código dentro de ``case`` sea ejecutado. Toma la forma: :keyword:`if` " -"seguida de una expresión." +"Una ``guard`` (que es parte del ``case``) debe ser exitosa para que el código " +"dentro de ``case`` sea ejecutado. Toma la forma: :keyword:`if` seguida de una " +"expresión." #: ../Doc/reference/compound_stmts.rst:632 msgid "The logical flow of a ``case`` block with a ``guard`` follows:" -msgstr "" -"El flujo lógico de un bloque ``case`` con una ``guard`` es el siguiente:" +msgstr "El flujo lógico de un bloque ``case`` con una ``guard`` es el siguiente:" #: ../Doc/reference/compound_stmts.rst:634 msgid "" "Check that the pattern in the ``case`` block succeeded. If the pattern " -"failed, the ``guard`` is not evaluated and the next ``case`` block is " -"checked." +"failed, the ``guard`` is not evaluated and the next ``case`` block is checked." msgstr "" "Se comprueba que el patrón del bloque ``case`` fue exitoso. Si el patrón " "falló, el ``guard`` no se evalúa y se comprueba el siguiente bloque ``case``." @@ -857,24 +842,22 @@ msgid "If the pattern succeeded, evaluate the ``guard``." msgstr "Si el patrón tuvo éxito, se evalúa el ``guard``." #: ../Doc/reference/compound_stmts.rst:640 -msgid "" -"If the ``guard`` condition evaluates as true, the case block is selected." +msgid "If the ``guard`` condition evaluates as true, the case block is selected." msgstr "" "Si la condición del ``guard`` es verdadera, se selecciona el bloque de ese " "caso." #: ../Doc/reference/compound_stmts.rst:643 msgid "" -"If the ``guard`` condition evaluates as false, the case block is not " -"selected." +"If the ``guard`` condition evaluates as false, the case block is not selected." msgstr "" "Si la condición del ``guard`` es falsa, el bloque de ese caso no es " "seleccionado." #: ../Doc/reference/compound_stmts.rst:646 msgid "" -"If the ``guard`` raises an exception during evaluation, the exception " -"bubbles up." +"If the ``guard`` raises an exception during evaluation, the exception bubbles " +"up." msgstr "" "Si el ``guard`` genera una excepción durante la evaluación, se levanta la " "excepción." @@ -882,14 +865,14 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:649 msgid "" "Guards are allowed to have side effects as they are expressions. Guard " -"evaluation must proceed from the first to the last case block, one at a " -"time, skipping case blocks whose pattern(s) don't all succeed. (I.e., guard " -"evaluation must happen in order.) Guard evaluation must stop once a case " -"block is selected." +"evaluation must proceed from the first to the last case block, one at a time, " +"skipping case blocks whose pattern(s) don't all succeed. (I.e., guard " +"evaluation must happen in order.) Guard evaluation must stop once a case block " +"is selected." msgstr "" "Se permite que las protecciones tengan efectos secundarios, ya que son " -"expresiones. La evaluación de la protección debe ir desde el primer al " -"último bloque de casos, uno a la vez, saltando los bloques de casos cuyo(s) " +"expresiones. La evaluación de la protección debe ir desde el primer al último " +"bloque de casos, uno a la vez, saltando los bloques de casos cuyo(s) " "patrón(es) no tenga(n) éxito. (Es decir, la evaluación de las protecciones " "debe realizarse en orden.) La evaluación de las protecciones debe detenerse " "una vez que se selecciona un bloque de casos." @@ -914,10 +897,10 @@ msgid "" "syntax alone that it will always succeed. Only the following patterns are " "irrefutable:" msgstr "" -"Un bloque de casos se considera irrefutable si no tiene protección y su " -"patrón es irrefutable. Un patrón se considera irrefutable si podemos " -"demostrar, sólo por su sintaxis, que siempre tendrá éxito. Sólo los " -"siguientes patrones son irrefutables:" +"Un bloque de casos se considera irrefutable si no tiene protección y su patrón " +"es irrefutable. Un patrón se considera irrefutable si podemos demostrar, sólo " +"por su sintaxis, que siempre tendrá éxito. Sólo los siguientes patrones son " +"irrefutables:" #: ../Doc/reference/compound_stmts.rst:671 msgid ":ref:`as-patterns` whose left-hand side is irrefutable" @@ -945,8 +928,7 @@ msgstr "Patrones" #: ../Doc/reference/compound_stmts.rst:690 msgid "This section uses grammar notations beyond standard EBNF:" -msgstr "" -"Esta sección utiliza notaciones gramaticales más allá del estándar EBNF:" +msgstr "Esta sección utiliza notaciones gramaticales más allá del estándar EBNF:" #: ../Doc/reference/compound_stmts.rst:692 msgid "the notation ``SEP.RULE+`` is shorthand for ``RULE (SEP RULE)*``" @@ -964,36 +946,50 @@ msgstr "La sintaxis de nivel superior para ``patrones`` es:" #: ../Doc/reference/compound_stmts.rst:711 msgid "" -"The descriptions below will include a description \"in simple terms\" of " -"what a pattern does for illustration purposes (credits to Raymond Hettinger " -"for a document that inspired most of the descriptions). Note that these " -"descriptions are purely for illustration purposes and **may not** reflect " -"the underlying implementation. Furthermore, they do not cover all valid " -"forms." +"The descriptions below will include a description \"in simple terms\" of what " +"a pattern does for illustration purposes (credits to Raymond Hettinger for a " +"document that inspired most of the descriptions). Note that these descriptions " +"are purely for illustration purposes and **may not** reflect the underlying " +"implementation. Furthermore, they do not cover all valid forms." msgstr "" +"Las descripciones a continuación incluirán una descripción \"en términos " +"simples\" de lo que hace un patrón con fines ilustrativos (créditos a Raymond " +"Hettinger por un documento que inspiró la mayoría de las descripciones). Tenga " +"en cuenta que estas descripciones tienen únicamente fines ilustrativos y que " +"**may not** refleja la implementación subyacente. Además, no cubren todos los " +"formularios válidos." #: ../Doc/reference/compound_stmts.rst:721 msgid "OR Patterns" -msgstr "" +msgstr "Patrones OR" #: ../Doc/reference/compound_stmts.rst:723 msgid "" "An OR pattern is two or more patterns separated by vertical bars ``|``. " "Syntax:" msgstr "" +"Un patrón OR son dos o más patrones separados por barras verticales ``|``. " +"Sintaxis:" #: ../Doc/reference/compound_stmts.rst:729 msgid "" "Only the final subpattern may be :ref:`irrefutable `, and " "each subpattern must bind the same set of names to avoid ambiguity." msgstr "" +"Solo el subpatrón final puede ser :ref:`irrefutable `, y " +"cada subpatrón debe vincular el mismo conjunto de nombres para evitar " +"ambigüedades." #: ../Doc/reference/compound_stmts.rst:732 msgid "" "An OR pattern matches each of its subpatterns in turn to the subject value, " -"until one succeeds. The OR pattern is then considered successful. " -"Otherwise, if none of the subpatterns succeed, the OR pattern fails." +"until one succeeds. The OR pattern is then considered successful. Otherwise, " +"if none of the subpatterns succeed, the OR pattern fails." msgstr "" +"Un patrón OR hace coincidir cada uno de sus subpatrones a su vez con el valor " +"del sujeto, hasta que uno tiene éxito. Entonces, el patrón OR se considera " +"exitoso. De lo contrario, si ninguno de los subpatrones tiene éxito, el patrón " +"OR falla." #: ../Doc/reference/compound_stmts.rst:736 msgid "" @@ -1001,16 +997,21 @@ msgid "" "will try to match ``P2``, succeeding immediately if any succeeds, failing " "otherwise." msgstr "" +"En términos simples, ``P1 | P2 | ...`` intentará igualar ``P1``, si falla, " +"intentará igualar ``P2``, teniendo éxito inmediatamente si alguno tiene éxito, " +"fallando en caso contrario." #: ../Doc/reference/compound_stmts.rst:742 msgid "AS Patterns" -msgstr "" +msgstr "Como patrones" #: ../Doc/reference/compound_stmts.rst:744 msgid "" "An AS pattern matches an OR pattern on the left of the :keyword:`as` keyword " "against a subject. Syntax:" msgstr "" +"Un patrón AS coincide con un patrón OR a la izquierda de la palabra clave :" +"keyword:`as` con un sujeto. Sintaxis:" #: ../Doc/reference/compound_stmts.rst:750 msgid "" @@ -1018,37 +1019,50 @@ msgid "" "binds the subject to the name on the right of the as keyword and succeeds. " "``capture_pattern`` cannot be a a ``_``." msgstr "" +"Si el patrón OR falla, el patrón AS falla. De lo contrario, el patrón AS " +"vincula al sujeto con el nombre a la derecha de la palabra clave as y tiene " +"éxito. ``capture_pattern`` no puede ser un ``_``." #: ../Doc/reference/compound_stmts.rst:754 msgid "" "In simple terms ``P as NAME`` will match with ``P``, and on success it will " "set ``NAME = ``." msgstr "" +"En términos simples, ``P as NAME`` coincidirá con ``P`` y, en caso de éxito, " +"establecerá ``NAME = ``." #: ../Doc/reference/compound_stmts.rst:761 msgid "Literal Patterns" -msgstr "" +msgstr "Patrones literales" #: ../Doc/reference/compound_stmts.rst:763 msgid "" "A literal pattern corresponds to most :ref:`literals ` in Python. " "Syntax:" msgstr "" +"Un patrón literal corresponde a la mayoría de :ref:`literals ` en " +"Python. Sintaxis:" #: ../Doc/reference/compound_stmts.rst:776 msgid "" "The rule ``strings`` and the token ``NUMBER`` are defined in the :doc:" -"`standard Python grammar <./grammar>`. Triple-quoted strings are " -"supported. Raw strings and byte strings are supported. :ref:`f-strings` " -"are not supported." +"`standard Python grammar <./grammar>`. Triple-quoted strings are supported. " +"Raw strings and byte strings are supported. :ref:`f-strings` are not " +"supported." msgstr "" +"La regla ``strings`` y el token ``NUMBER`` se definen en :doc:`standard Python " +"grammar <./grammar>`. Se admiten cadenas entre comillas triples. Se admiten " +"cadenas sin formato y cadenas de bytes. :ref:`f-strings` no es compatible." #: ../Doc/reference/compound_stmts.rst:781 msgid "" "The forms ``signed_number '+' NUMBER`` and ``signed_number '-' NUMBER`` are " -"for expressing :ref:`complex numbers `; they require a real " -"number on the left and an imaginary number on the right. E.g. ``3 + 4j``." +"for expressing :ref:`complex numbers `; they require a real number " +"on the left and an imaginary number on the right. E.g. ``3 + 4j``." msgstr "" +"Los formularios ``signed_number '+' NUMBER`` y ``signed_number '-' NUMBER`` " +"son para expresar :ref:`complex numbers `; requieren un número real " +"a la izquierda y un número imaginario a la derecha. P.ej. ``3 + 4j``." #: ../Doc/reference/compound_stmts.rst:785 msgid "" @@ -1056,26 +1070,33 @@ msgid "" "For the singletons ``None``, ``True`` and ``False``, the :keyword:`is` " "operator is used." msgstr "" +"En términos simples, ``LITERAL`` solo tendrá éxito si `` == " +"LITERAL``. Para los singleton ``None``, ``True`` y ``False``, se utiliza el " +"operador :keyword:`is`." #: ../Doc/reference/compound_stmts.rst:791 msgid "Capture Patterns" -msgstr "" +msgstr "Capturar patrones" #: ../Doc/reference/compound_stmts.rst:793 msgid "A capture pattern binds the subject value to a name. Syntax:" -msgstr "" +msgstr "Un patrón de captura vincula el valor del sujeto a un nombre. Sintaxis:" #: ../Doc/reference/compound_stmts.rst:799 msgid "" "A single underscore ``_`` is not a capture pattern (this is what ``!'_'`` " "expresses). It is instead treated as a :token:`wildcard_pattern`." msgstr "" +"Un solo guión bajo ``_`` no es un patrón de captura (esto es lo que expresa " +"``!'_'``). En cambio, se trata como un: token: `wildcard_pattern`." #: ../Doc/reference/compound_stmts.rst:802 msgid "" -"In a given pattern, a given name can only be bound once. E.g. ``case x, " -"x: ...`` is invalid while ``case [x] | x: ...`` is allowed." +"In a given pattern, a given name can only be bound once. E.g. ``case x, x: ..." +"`` is invalid while ``case [x] | x: ...`` is allowed." msgstr "" +"En un patrón dado, un nombre dado solo se puede vincular una vez. P.ej. ``case " +"x, x: ...`` no es válido mientras ``case [x] | x: ...`` está permitido." #: ../Doc/reference/compound_stmts.rst:805 msgid "" @@ -1084,41 +1105,54 @@ msgid "" "becomes a local variable in the closest containing function scope unless " "there's an applicable :keyword:`global` or :keyword:`nonlocal` statement." msgstr "" +"Los patrones de captura siempre tienen éxito. El enlace sigue las reglas de " +"alcance establecidas por el operador de expresión de asignación en :pep:`572`; " +"el nombre se convierte en una variable local en el alcance de la función " +"contenedora más cercana, a menos que haya una declaración :keyword:`global` o :" +"keyword:`nonlocal` aplicable." #: ../Doc/reference/compound_stmts.rst:810 msgid "" "In simple terms ``NAME`` will always succeed and it will set ``NAME = " "``." msgstr "" +"En términos simples, ``NAME`` siempre tendrá éxito y establecerá ``NAME = " +"``." #: ../Doc/reference/compound_stmts.rst:815 msgid "Wildcard Patterns" -msgstr "" +msgstr "Patrones comodín" #: ../Doc/reference/compound_stmts.rst:817 msgid "" "A wildcard pattern always succeeds (matches anything) and binds no name. " "Syntax:" msgstr "" +"Un patrón comodín siempre tiene éxito (coincide con cualquier cosa) y no " +"vincula ningún nombre. Sintaxis:" #: ../Doc/reference/compound_stmts.rst:823 msgid "" "``_`` is a :ref:`soft keyword ` within any pattern, but only " -"within patterns. It is an identifier, as usual, even within ``match`` " -"subject expressions, ``guard``\\ s, and ``case`` blocks." +"within patterns. It is an identifier, as usual, even within ``match`` subject " +"expressions, ``guard``\\ s, and ``case`` blocks." msgstr "" +"``_`` es un :ref:`soft keyword ` dentro de cualquier patrón, " +"pero solo dentro de patrones. Es un identificador, como de costumbre, incluso " +"dentro de las expresiones de sujeto ``match``, ``guard`` \\ sy bloques " +"``case``." #: ../Doc/reference/compound_stmts.rst:827 msgid "In simple terms, ``_`` will always succeed." -msgstr "" +msgstr "En términos simples, ``_`` siempre tendrá éxito." #: ../Doc/reference/compound_stmts.rst:832 msgid "Value Patterns" -msgstr "" +msgstr "Patrones de valor" #: ../Doc/reference/compound_stmts.rst:834 msgid "A value pattern represents a named value in Python. Syntax:" -msgstr "" +msgstr "Un patrón de valor representa un valor con nombre en Python. Sintaxis:" #: ../Doc/reference/compound_stmts.rst:842 msgid "" @@ -1126,122 +1160,166 @@ msgid "" "resolution rules `. The pattern succeeds if the value found " "compares equal to the subject value (using the ``==`` equality operator)." msgstr "" +"El nombre con puntos en el patrón se busca usando el estándar Python :ref:" +"`name resolution rules `. El patrón tiene éxito si el valor " +"encontrado se compara con el valor del sujeto (usando el operador de igualdad " +"``==``)." #: ../Doc/reference/compound_stmts.rst:847 msgid "" "In simple terms ``NAME1.NAME2`` will succeed only if `` == NAME1." "NAME2``" msgstr "" +"En términos simples, ``NAME1.NAME2`` solo tendrá éxito si `` == NAME1." +"NAME2``" #: ../Doc/reference/compound_stmts.rst:851 msgid "" "If the same value occurs multiple times in the same match statement, the " "interpreter may cache the first value found and reuse it rather than repeat " -"the same lookup. This cache is strictly tied to a given execution of a " -"given match statement." +"the same lookup. This cache is strictly tied to a given execution of a given " +"match statement." msgstr "" +"Si el mismo valor ocurre varias veces en la misma declaración de coincidencia, " +"el intérprete puede almacenar en caché el primer valor encontrado y " +"reutilizarlo en lugar de repetir la misma búsqueda. Este caché está " +"estrictamente vinculado a una ejecución determinada de una declaración de " +"coincidencia determinada." #: ../Doc/reference/compound_stmts.rst:859 msgid "Group Patterns" -msgstr "" +msgstr "Patrones de grupo" #: ../Doc/reference/compound_stmts.rst:861 msgid "" "A group pattern allows users to add parentheses around patterns to emphasize " "the intended grouping. Otherwise, it has no additional syntax. Syntax:" msgstr "" +"Un patrón de grupo permite a los usuarios agregar paréntesis alrededor de los " +"patrones para enfatizar la agrupación deseada. De lo contrario, no tiene " +"sintaxis adicional. Sintaxis:" #: ../Doc/reference/compound_stmts.rst:868 msgid "In simple terms ``(P)`` has the same effect as ``P``." -msgstr "" +msgstr "En términos simples, ``(P)`` tiene el mismo efecto que ``P``." #: ../Doc/reference/compound_stmts.rst:873 msgid "Sequence Patterns" -msgstr "" +msgstr "Patrones de secuencia" #: ../Doc/reference/compound_stmts.rst:875 msgid "" -"A sequence pattern contains several subpatterns to be matched against " -"sequence elements. The syntax is similar to the unpacking of a list or tuple." +"A sequence pattern contains several subpatterns to be matched against sequence " +"elements. The syntax is similar to the unpacking of a list or tuple." msgstr "" +"Un patrón de secuencia contiene varios subpatrones para hacer coincidir con " +"elementos de secuencia. La sintaxis es similar al desempaquetado de una lista " +"o tupla." #: ../Doc/reference/compound_stmts.rst:886 msgid "" "There is no difference if parentheses or square brackets are used for " "sequence patterns (i.e. ``(...)`` vs ``[...]`` )." msgstr "" +"No hay diferencia si se utilizan paréntesis o corchetes para los patrones de " +"secuencia (es decir, ``(...)`` vs ``[...]``)." #: ../Doc/reference/compound_stmts.rst:890 msgid "" -"A single pattern enclosed in parentheses without a trailing comma (e.g. ``(3 " -"| 4)``) is a :ref:`group pattern `. While a single pattern " +"A single pattern enclosed in parentheses without a trailing comma (e.g. ``(3 | " +"4)``) is a :ref:`group pattern `. While a single pattern " "enclosed in square brackets (e.g. ``[3 | 4]``) is still a sequence pattern." msgstr "" +"Un solo patrón encerrado entre paréntesis sin una coma final (por ejemplo, " +"``(3 | 4)``) es un :ref:`group pattern `. Mientras que un solo " +"patrón encerrado entre corchetes (por ejemplo, ``[3 | 4]``) sigue siendo un " +"patrón de secuencia." #: ../Doc/reference/compound_stmts.rst:895 msgid "" -"At most one star subpattern may be in a sequence pattern. The star " -"subpattern may occur in any position. If no star subpattern is present, the " -"sequence pattern is a fixed-length sequence pattern; otherwise it is a " -"variable-length sequence pattern." +"At most one star subpattern may be in a sequence pattern. The star subpattern " +"may occur in any position. If no star subpattern is present, the sequence " +"pattern is a fixed-length sequence pattern; otherwise it is a variable-length " +"sequence pattern." msgstr "" +"A lo sumo, un subpatrón de estrella puede estar en un patrón de secuencia. El " +"subpatrón de estrella puede ocurrir en cualquier posición. Si no hay ningún " +"subpatrón de estrella, el patrón de secuencia es un patrón de secuencia de " +"longitud fija; de lo contrario, es un patrón de secuencia de longitud variable." #: ../Doc/reference/compound_stmts.rst:900 msgid "" "The following is the logical flow for matching a sequence pattern against a " "subject value:" msgstr "" +"El siguiente es el flujo lógico para hacer coincidir un patrón de secuencia " +"con un valor de sujeto:" #: ../Doc/reference/compound_stmts.rst:903 -msgid "" -"If the subject value is not a sequence [#]_, the sequence pattern fails." +msgid "If the subject value is not a sequence [#]_, the sequence pattern fails." msgstr "" +"Si el valor del sujeto no es una secuencia [#] _, el patrón de secuencia falla." #: ../Doc/reference/compound_stmts.rst:906 msgid "" -"If the subject value is an instance of ``str``, ``bytes`` or ``bytearray`` " -"the sequence pattern fails." +"If the subject value is an instance of ``str``, ``bytes`` or ``bytearray`` the " +"sequence pattern fails." msgstr "" +"Si el valor del sujeto es una instancia de ``str``, ``bytes`` o ``bytearray``, " +"el patrón de secuencia falla." #: ../Doc/reference/compound_stmts.rst:909 msgid "" "The subsequent steps depend on whether the sequence pattern is fixed or " "variable-length." msgstr "" +"Los pasos subsiguientes dependen de si el patrón de secuencia es de longitud " +"fija o variable." #: ../Doc/reference/compound_stmts.rst:912 msgid "If the sequence pattern is fixed-length:" -msgstr "" +msgstr "Si el patrón de secuencia es de longitud fija:" #: ../Doc/reference/compound_stmts.rst:914 msgid "" "If the length of the subject sequence is not equal to the number of " "subpatterns, the sequence pattern fails" msgstr "" +"Si la longitud de la secuencia del sujeto no es igual al número de " +"subpatrones, el patrón de secuencia falla" #: ../Doc/reference/compound_stmts.rst:917 msgid "" "Subpatterns in the sequence pattern are matched to their corresponding items " "in the subject sequence from left to right. Matching stops as soon as a " -"subpattern fails. If all subpatterns succeed in matching their " -"corresponding item, the sequence pattern succeeds." +"subpattern fails. If all subpatterns succeed in matching their corresponding " +"item, the sequence pattern succeeds." msgstr "" +"Los subpatrones del patrón de secuencia se hacen coincidir con sus elementos " +"correspondientes en la secuencia del sujeto de izquierda a derecha. El " +"emparejamiento se detiene tan pronto como falla un subpatrón. Si todos los " +"subpatrones tienen éxito en hacer coincidir su elemento correspondiente, el " +"patrón de secuencia tiene éxito." #: ../Doc/reference/compound_stmts.rst:922 msgid "Otherwise, if the sequence pattern is variable-length:" -msgstr "" +msgstr "De lo contrario, si el patrón de secuencia es de longitud variable:" #: ../Doc/reference/compound_stmts.rst:924 msgid "" "If the length of the subject sequence is less than the number of non-star " "subpatterns, the sequence pattern fails." msgstr "" +"Si la longitud de la secuencia del sujeto es menor que el número de " +"subpatrones sin estrella, el patrón de secuencia falla." #: ../Doc/reference/compound_stmts.rst:927 msgid "" "The leading non-star subpatterns are matched to their corresponding items as " "for fixed-length sequences." msgstr "" +"Los subpatrones principales no en estrella se emparejan con sus elementos " +"correspondientes como para las secuencias de longitud fija." #: ../Doc/reference/compound_stmts.rst:930 msgid "" @@ -1249,80 +1327,107 @@ msgid "" "the remaining subject items, excluding the remaining items corresponding to " "non-star subpatterns following the star subpattern." msgstr "" +"Si el paso anterior tiene éxito, el subpatrón en estrella coincide con una " +"lista formada por los elementos restantes del sujeto, excluyendo los elementos " +"restantes correspondientes a los subpatrones que no son en estrella que siguen " +"el subpatrón en estrella." #: ../Doc/reference/compound_stmts.rst:934 msgid "" "Remaining non-star subpatterns are matched to their corresponding subject " "items, as for a fixed-length sequence." msgstr "" +"Los subpatrones restantes que no son estrellas se emparejan con sus elementos " +"temáticos correspondientes, como para una secuencia de longitud fija." #: ../Doc/reference/compound_stmts.rst:937 msgid "" -"The length of the subject sequence is obtained via :func:`len` (i.e. via " -"the :meth:`__len__` protocol). This length may be cached by the interpreter " -"in a similar manner as :ref:`value patterns `." +"The length of the subject sequence is obtained via :func:`len` (i.e. via the :" +"meth:`__len__` protocol). This length may be cached by the interpreter in a " +"similar manner as :ref:`value patterns `." msgstr "" +"La longitud de la secuencia del sujeto se obtiene a través de :func:`len` (es " +"decir, a través del protocolo :meth:`__len__`). El intérprete puede almacenar " +"en caché esta longitud de manera similar a :ref:`value patterns `." #: ../Doc/reference/compound_stmts.rst:943 msgid "" "In simple terms ``[P1, P2, P3,`` ... ``, P]`` matches only if all the " "following happens:" msgstr "" +"En términos simples, ``[P1, P2, P3,`` ... ``, P]`` solo coincide si ocurre " +"todo lo siguiente:" #: ../Doc/reference/compound_stmts.rst:946 msgid "check ```` is a sequence" -msgstr "" +msgstr "comprobar que ```` es una secuencia" #: ../Doc/reference/compound_stmts.rst:947 msgid "``len(subject) == ``" -msgstr "" +msgstr "``len(subject) == ``" #: ../Doc/reference/compound_stmts.rst:948 msgid "" "``P1`` matches ``[0]`` (note that this match can also bind names)" msgstr "" +"``P1`` coincide con ``[0]`` (tenga en cuenta que esta coincidencia " +"también puede vincular nombres)" #: ../Doc/reference/compound_stmts.rst:949 msgid "" "``P2`` matches ``[1]`` (note that this match can also bind names)" msgstr "" +"``P2`` coincide con ``[1]`` (tenga en cuenta que esta coincidencia " +"también puede vincular nombres)" #: ../Doc/reference/compound_stmts.rst:950 msgid "... and so on for the corresponding pattern/element." -msgstr "" +msgstr "... y así sucesivamente para el patrón/elemento correspondiente." #: ../Doc/reference/compound_stmts.rst:955 msgid "Mapping Patterns" -msgstr "" +msgstr "Patrones de mapeo" #: ../Doc/reference/compound_stmts.rst:957 msgid "" "A mapping pattern contains one or more key-value patterns. The syntax is " "similar to the construction of a dictionary. Syntax:" msgstr "" +"Un patrón de asignación contiene uno o más patrones clave-valor. La sintaxis " +"es similar a la construcción de un diccionario. Sintaxis:" #: ../Doc/reference/compound_stmts.rst:968 msgid "" -"At most one double star pattern may be in a mapping pattern. The double " -"star pattern must be the last subpattern in the mapping pattern." +"At most one double star pattern may be in a mapping pattern. The double star " +"pattern must be the last subpattern in the mapping pattern." msgstr "" +"Como máximo, un patrón de estrella doble puede estar en un patrón de mapeo. El " +"patrón de estrella doble debe ser el último subpatrón del patrón de mapeo." #: ../Doc/reference/compound_stmts.rst:971 msgid "" -"Duplicate keys in mapping patterns are disallowed. Duplicate literal keys " -"will raise a :exc:`SyntaxError`. Two keys that otherwise have the same value " -"will raise a :exc:`ValueError` at runtime." +"Duplicate keys in mapping patterns are disallowed. Duplicate literal keys will " +"raise a :exc:`SyntaxError`. Two keys that otherwise have the same value will " +"raise a :exc:`ValueError` at runtime." msgstr "" +"No se permiten claves duplicadas en patrones de mapeo. Las claves literales " +"duplicadas generarán un :exc:`SyntaxError`. Dos claves que de otro modo " +"tendrían el mismo valor generarán un :exc:`ValueError` en tiempo de ejecución." #: ../Doc/reference/compound_stmts.rst:975 msgid "" "The following is the logical flow for matching a mapping pattern against a " "subject value:" msgstr "" +"El siguiente es el flujo lógico para hacer coincidir un patrón de mapeo con un " +"valor de sujeto:" #: ../Doc/reference/compound_stmts.rst:978 msgid "If the subject value is not a mapping [#]_,the mapping pattern fails." msgstr "" +"Si el valor del sujeto no es una asignación [#]_, el patrón de asignación " +"falla." #: ../Doc/reference/compound_stmts.rst:980 msgid "" @@ -1330,6 +1435,9 @@ msgid "" "and the pattern for each key matches the corresponding item of the subject " "mapping, the mapping pattern succeeds." msgstr "" +"Si cada clave dada en el patrón de mapeo está presente en el mapeo del sujeto, " +"y el patrón para cada clave coincide con el elemento correspondiente del mapeo " +"del sujeto, el patrón de mapeo tiene éxito." #: ../Doc/reference/compound_stmts.rst:984 msgid "" @@ -1337,6 +1445,9 @@ msgid "" "considered invalid. A :exc:`SyntaxError` is raised for duplicate literal " "values; or a :exc:`ValueError` for named keys of the same value." msgstr "" +"Si se detectan claves duplicadas en el patrón de mapeo, el patrón se considera " +"inválido. Se genera un :exc:`SyntaxError` para valores literales duplicados; o " +"un :exc:`ValueError` para claves con nombre del mismo valor." #: ../Doc/reference/compound_stmts.rst:988 msgid "" @@ -1345,67 +1456,84 @@ msgid "" "in the mapping, and not created on-the-fly via :meth:`__missing__` or :meth:" "`__getitem__`." msgstr "" +"Los pares clave-valor se hacen coincidir utilizando la forma de dos argumentos " +"del método ``get()`` del sujeto de mapeo. Los pares clave-valor coincidentes " +"ya deben estar presentes en la asignación y no deben crearse sobre la marcha a " +"través de :meth:`__missing__` o :meth:`__getitem__`." #: ../Doc/reference/compound_stmts.rst:993 msgid "" "In simple terms ``{KEY1: P1, KEY2: P2, ... }`` matches only if all the " "following happens:" msgstr "" +"En términos simples, ``{KEY1: P1, KEY2: P2, ... }`` solo coincide si ocurre " +"todo lo siguiente:" #: ../Doc/reference/compound_stmts.rst:996 msgid "check ```` is a mapping" -msgstr "" +msgstr "comprobar ```` es un mapeo" #: ../Doc/reference/compound_stmts.rst:997 msgid "``KEY1 in ``" -msgstr "" +msgstr "``KEY1 in ``" #: ../Doc/reference/compound_stmts.rst:998 msgid "``P1`` matches ``[KEY1]``" -msgstr "" +msgstr "``P1`` coincide con ``[KEY1]``" #: ../Doc/reference/compound_stmts.rst:999 msgid "... and so on for the corresponding KEY/pattern pair." -msgstr "" +msgstr "... y así sucesivamente para el par correspondiente de KEY / patrón." #: ../Doc/reference/compound_stmts.rst:1005 msgid "Class Patterns" -msgstr "" +msgstr "Patrones de clase" #: ../Doc/reference/compound_stmts.rst:1007 msgid "" "A class pattern represents a class and its positional and keyword arguments " "(if any). Syntax:" msgstr "" +"Un patrón de clase representa una clase y sus argumentos posicionales y de " +"palabras clave (si los hay). Sintaxis:" #: ../Doc/reference/compound_stmts.rst:1018 msgid "The same keyword should not be repeated in class patterns." -msgstr "" +msgstr "La misma palabra clave no debe repetirse en los patrones de clase." #: ../Doc/reference/compound_stmts.rst:1020 msgid "" "The following is the logical flow for matching a class pattern against a " "subject value:" msgstr "" +"El siguiente es el flujo lógico para hacer coincidir un patrón de clase con un " +"valor de materia:" #: ../Doc/reference/compound_stmts.rst:1023 msgid "" "If ``name_or_attr`` is not an instance of the builtin :class:`type` , raise :" "exc:`TypeError`." msgstr "" +"Si ``name_or_attr`` no es una instancia del :class:`type` incorporado, genere :" +"exc:`TypeError`." #: ../Doc/reference/compound_stmts.rst:1026 msgid "" -"If the subject value is not an instance of ``name_or_attr`` (tested via :" -"func:`isinstance`), the class pattern fails." +"If the subject value is not an instance of ``name_or_attr`` (tested via :func:" +"`isinstance`), the class pattern fails." msgstr "" +"Si el valor del sujeto no es una instancia de ``name_or_attr`` (probado a " +"través de :func:`isinstance`), el patrón de clase falla." #: ../Doc/reference/compound_stmts.rst:1029 msgid "" "If no pattern arguments are present, the pattern succeeds. Otherwise, the " -"subsequent steps depend on whether keyword or positional argument patterns " -"are present." +"subsequent steps depend on whether keyword or positional argument patterns are " +"present." msgstr "" +"Si no hay argumentos de patrón, el patrón tiene éxito. De lo contrario, los " +"pasos siguientes dependen de si están presentes patrones de argumentos de " +"posición o de palabras clave." #: ../Doc/reference/compound_stmts.rst:1033 msgid "" @@ -1413,26 +1541,33 @@ msgid "" "subpattern is accepted which will match the entire subject; for these types " "keyword patterns also work as for other types." msgstr "" +"Para varios tipos integrados (especificados a continuación), se acepta un " +"único subpatrón posicional que coincidirá con todo el tema; para estos tipos, " +"los patrones de palabras clave también funcionan como para otros tipos." #: ../Doc/reference/compound_stmts.rst:1037 msgid "" "If only keyword patterns are present, they are processed as follows, one by " "one:" msgstr "" +"Si solo hay patrones de palabras clave, se procesan de la siguiente manera, " +"uno por uno:" #: ../Doc/reference/compound_stmts.rst:1040 msgid "I. The keyword is looked up as an attribute on the subject." -msgstr "" +msgstr "I. La palabra clave se busca como un atributo del tema." #: ../Doc/reference/compound_stmts.rst:1042 msgid "" "If this raises an exception other than :exc:`AttributeError`, the exception " "bubbles up." msgstr "" +"Si esto genera una excepción distinta de :exc:`AttributeError`, la excepción " +"aparece." #: ../Doc/reference/compound_stmts.rst:1045 msgid "If this raises :exc:`AttributeError`, the class pattern has failed." -msgstr "" +msgstr "Si esto genera :exc:`AttributeError`, el patrón de clase ha fallado." #: ../Doc/reference/compound_stmts.rst:1047 msgid "" @@ -1440,151 +1575,175 @@ msgid "" "the subject's attribute value. If this fails, the class pattern fails; if " "this succeeds, the match proceeds to the next keyword." msgstr "" +"De lo contrario, el subpatrón asociado con el patrón de palabra clave se " +"compara con el valor del atributo del sujeto. Si esto falla, el patrón de " +"clase falla; si esto tiene éxito, la coincidencia continúa con la siguiente " +"palabra clave." #: ../Doc/reference/compound_stmts.rst:1052 msgid "II. If all keyword patterns succeed, the class pattern succeeds." msgstr "" +"II. Si todos los patrones de palabras clave tienen éxito, el patrón de clase " +"tiene éxito." #: ../Doc/reference/compound_stmts.rst:1054 msgid "" -"If any positional patterns are present, they are converted to keyword " -"patterns using the :data:`~object.__match_args__` attribute on the class " +"If any positional patterns are present, they are converted to keyword patterns " +"using the :data:`~object.__match_args__` attribute on the class " "``name_or_attr`` before matching:" msgstr "" +"Si hay algún patrón posicional presente, se convierte en patrones de palabras " +"clave utilizando el atributo :data:`~object.__match_args__` en la clase " +"``name_or_attr`` antes de hacer coincidir:" #: ../Doc/reference/compound_stmts.rst:1058 -msgid "" -"I. The equivalent of ``getattr(cls, \"__match_args__\", ())`` is called." -msgstr "" +msgid "I. The equivalent of ``getattr(cls, \"__match_args__\", ())`` is called." +msgstr "I. Se llama el equivalente de ``getattr(cls, \"__match_args__\", ())``." #: ../Doc/reference/compound_stmts.rst:1060 msgid "If this raises an exception, the exception bubbles up." -msgstr "" +msgstr "Si esto genera una excepción, la excepción surge." #: ../Doc/reference/compound_stmts.rst:1062 msgid "" "If the returned value is not a tuple, the conversion fails and :exc:" "`TypeError` is raised." msgstr "" +"Si el valor devuelto no es una tupla, la conversión falla y se genera :exc:" +"`TypeError`." #: ../Doc/reference/compound_stmts.rst:1065 msgid "" "If there are more positional patterns than ``len(cls.__match_args__)``, :exc:" "`TypeError` is raised." msgstr "" +"Si hay más patrones posicionales que ``len(cls.__match_args__)``, se genera :" +"exc:`TypeError`." #: ../Doc/reference/compound_stmts.rst:1068 msgid "" "Otherwise, positional pattern ``i`` is converted to a keyword pattern using " -"``__match_args__[i]`` as the keyword. ``__match_args__[i]`` must be a " -"string; if not :exc:`TypeError` is raised." +"``__match_args__[i]`` as the keyword. ``__match_args__[i]`` must be a string; " +"if not :exc:`TypeError` is raised." msgstr "" +"De lo contrario, el patrón posicional ``i`` se convierte en un patrón de " +"palabra clave utilizando ``__match_args__[i]`` como palabra clave. " +"``__match_args__[i]`` debe ser una cadena; si no, se genera :exc:`TypeError`." #: ../Doc/reference/compound_stmts.rst:1072 msgid "If there are duplicate keywords, :exc:`TypeError` is raised." -msgstr "" +msgstr "Si hay palabras clave duplicadas, se genera :exc:`TypeError`." #: ../Doc/reference/compound_stmts.rst:1074 msgid ":ref:`class-pattern-matching`" -msgstr "" +msgstr ":ref:`class-pattern-matching`" #: ../Doc/reference/compound_stmts.rst:1077 -msgid "" -"II. Once all positional patterns have been converted to keyword patterns," +msgid "II. Once all positional patterns have been converted to keyword patterns," msgstr "" +"II. Una vez que todos los patrones posicionales se hayan convertido en " +"patrones de palabras clave," #: ../Doc/reference/compound_stmts.rst:1077 msgid "the match proceeds as if there were only keyword patterns." -msgstr "" +msgstr "la coincidencia procede como si solo hubiera patrones de palabras clave." #: ../Doc/reference/compound_stmts.rst:1079 msgid "" "For the following built-in types the handling of positional subpatterns is " "different:" msgstr "" +"Para los siguientes tipos integrados, el manejo de subpatrones posicionales es " +"diferente:" #: ../Doc/reference/compound_stmts.rst:1082 msgid ":class:`bool`" -msgstr "" +msgstr ":class:`bool`" #: ../Doc/reference/compound_stmts.rst:1083 msgid ":class:`bytearray`" -msgstr "" +msgstr ":class:`bytearray`" #: ../Doc/reference/compound_stmts.rst:1084 msgid ":class:`bytes`" -msgstr "" +msgstr ":class:`bytes`" #: ../Doc/reference/compound_stmts.rst:1085 msgid ":class:`dict`" -msgstr "" +msgstr ":class:`dict`" #: ../Doc/reference/compound_stmts.rst:1086 msgid ":class:`float`" -msgstr "" +msgstr ":class:`float`" #: ../Doc/reference/compound_stmts.rst:1087 msgid ":class:`frozenset`" -msgstr "" +msgstr ":class:`frozenset`" #: ../Doc/reference/compound_stmts.rst:1088 msgid ":class:`int`" -msgstr "" +msgstr ":class:`int`" #: ../Doc/reference/compound_stmts.rst:1089 #: ../Doc/reference/compound_stmts.rst:1540 msgid ":class:`list`" -msgstr "" +msgstr ":class:`list`" #: ../Doc/reference/compound_stmts.rst:1090 msgid ":class:`set`" -msgstr "" +msgstr ":class:`set`" #: ../Doc/reference/compound_stmts.rst:1091 msgid ":class:`str`" -msgstr "" +msgstr ":class:`str`" #: ../Doc/reference/compound_stmts.rst:1092 #: ../Doc/reference/compound_stmts.rst:1543 msgid ":class:`tuple`" -msgstr "" +msgstr ":class:`tuple`" #: ../Doc/reference/compound_stmts.rst:1094 msgid "" "These classes accept a single positional argument, and the pattern there is " -"matched against the whole object rather than an attribute. For example " -"``int(0|1)`` matches the value ``0``, but not the values ``0.0`` or " -"``False``." +"matched against the whole object rather than an attribute. For example ``int(0|" +"1)`` matches the value ``0``, but not the values ``0.0`` or ``False``." msgstr "" +"Estas clases aceptan un único argumento posicional y el patrón se compara con " +"el objeto completo en lugar de un atributo. Por ejemplo, ``int(0|1)`` coincide " +"con el valor ``0``, pero no con los valores ``0.0`` o ``False``." #: ../Doc/reference/compound_stmts.rst:1098 msgid "" "In simple terms ``CLS(P1, attr=P2)`` matches only if the following happens:" msgstr "" +"En términos simples, ``CLS(P1, attr=P2)`` solo coincide si ocurre lo siguiente:" #: ../Doc/reference/compound_stmts.rst:1100 msgid "``isinstance(, CLS)``" -msgstr "" +msgstr "``isinstance(, CLS)``" #: ../Doc/reference/compound_stmts.rst:1101 msgid "convert ``P1`` to a keyword pattern using ``CLS.__match_args__``" msgstr "" +"convierta ``P1`` en un patrón de palabra clave usando ``CLS.__match_args__``" #: ../Doc/reference/compound_stmts.rst:1103 msgid "For each keyword argument ``attr=P2``:" -msgstr "" +msgstr "Para cada argumento de palabra clave ``attr=P2``:" #: ../Doc/reference/compound_stmts.rst:1103 msgid "``hasattr(, \"attr\")``" -msgstr "" +msgstr "``hasattr(, \"attr\")``" #: ../Doc/reference/compound_stmts.rst:1104 msgid "``P2`` matches ``.attr``" -msgstr "" +msgstr "``P2`` coincide con ``.attr``" #: ../Doc/reference/compound_stmts.rst:1105 msgid "... and so on for the corresponding keyword argument/pattern pair." msgstr "" +"... y así sucesivamente para el par de patrón / argumento de palabra clave " +"correspondiente." #: ../Doc/reference/compound_stmts.rst:1120 msgid "Function definitions" @@ -1592,31 +1751,31 @@ msgstr "Definiciones de funciones" #: ../Doc/reference/compound_stmts.rst:1135 msgid "" -"A function definition defines a user-defined function object (see section :" -"ref:`types`):" +"A function definition defines a user-defined function object (see section :ref:" +"`types`):" msgstr "" -"Una definición de función define una función objeto determinada por el " -"usuario (consulte la sección :ref:`types`):" +"Una definición de función define una función objeto determinada por el usuario " +"(consulte la sección :ref:`types`):" #: ../Doc/reference/compound_stmts.rst:1154 msgid "" "A function definition is an executable statement. Its execution binds the " "function name in the current local namespace to a function object (a wrapper " -"around the executable code for the function). This function object contains " -"a reference to the current global namespace as the global namespace to be " -"used when the function is called." +"around the executable code for the function). This function object contains a " +"reference to the current global namespace as the global namespace to be used " +"when the function is called." msgstr "" -"Una definición de función es una sentencia ejecutable. Su ejecución vincula " -"el nombre de la función en el espacio de nombres local actual a un objeto de " -"función (un contenedor alrededor del código ejecutable para la función). " -"Este objeto de función contiene una referencia al espacio de nombres global " -"actual como el espacio de nombres global que se utilizará cuando se llama a " -"la función." +"Una definición de función es una sentencia ejecutable. Su ejecución vincula el " +"nombre de la función en el espacio de nombres local actual a un objeto de " +"función (un contenedor alrededor del código ejecutable para la función). Este " +"objeto de función contiene una referencia al espacio de nombres global actual " +"como el espacio de nombres global que se utilizará cuando se llama a la " +"función." #: ../Doc/reference/compound_stmts.rst:1160 msgid "" -"The function definition does not execute the function body; this gets " -"executed only when the function is called. [#]_" +"The function definition does not execute the function body; this gets executed " +"only when the function is called. [#]_" msgstr "" "La definición de la función no ejecuta el cuerpo de la función; esto se " "ejecuta solo cuando se llama a la función. [#]_" @@ -1624,20 +1783,20 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:1166 msgid "" "A function definition may be wrapped by one or more :term:`decorator` " -"expressions. Decorator expressions are evaluated when the function is " -"defined, in the scope that contains the function definition. The result " -"must be a callable, which is invoked with the function object as the only " -"argument. The returned value is bound to the function name instead of the " -"function object. Multiple decorators are applied in nested fashion. For " -"example, the following code ::" -msgstr "" -"Una definición de función puede estar envuelta por una o más expresiones :" -"term:`decorator`. Las expresiones de decorador se evalúan cuando se define " -"la función, en el ámbito que contiene la definición de la función. El " -"resultado debe ser invocable, la cual se invoca con el objeto de función " -"como único argumento. El valor retornado está vinculado al nombre de la " -"función en lugar del objeto de la función. Se aplican múltiples decoradores " -"de forma anidada. Por ejemplo, el siguiente código ::" +"expressions. Decorator expressions are evaluated when the function is defined, " +"in the scope that contains the function definition. The result must be a " +"callable, which is invoked with the function object as the only argument. The " +"returned value is bound to the function name instead of the function object. " +"Multiple decorators are applied in nested fashion. For example, the following " +"code ::" +msgstr "" +"Una definición de función puede estar envuelta por una o más expresiones :term:" +"`decorator`. Las expresiones de decorador se evalúan cuando se define la " +"función, en el ámbito que contiene la definición de la función. El resultado " +"debe ser invocable, la cual se invoca con el objeto de función como único " +"argumento. El valor retornado está vinculado al nombre de la función en lugar " +"del objeto de la función. Se aplican múltiples decoradores de forma anidada. " +"Por ejemplo, el siguiente código ::" #: ../Doc/reference/compound_stmts.rst:1177 #: ../Doc/reference/compound_stmts.rst:1354 @@ -1655,8 +1814,7 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:1184 msgid "" "Functions may be decorated with any valid :token:`assignment_expression`. " -"Previously, the grammar was much more restrictive; see :pep:`614` for " -"details." +"Previously, the grammar was much more restrictive; see :pep:`614` for details." msgstr "" "Las funciones se pueden decorar con cualquier token válido :token:" "`assignment_expression`. Anteriormente, la gramática era mucho más " @@ -1668,144 +1826,141 @@ msgid "" "``=`` *expression*, the function is said to have \"default parameter values." "\" For a parameter with a default value, the corresponding :term:`argument` " "may be omitted from a call, in which case the parameter's default value is " -"substituted. If a parameter has a default value, all following parameters " -"up until the \"``*``\" must also have a default value --- this is a " -"syntactic restriction that is not expressed by the grammar." +"substituted. If a parameter has a default value, all following parameters up " +"until the \"``*``\" must also have a default value --- this is a syntactic " +"restriction that is not expressed by the grammar." msgstr "" "Cuando uno o más :term:`parameters ` tienen la forma *parameter* " "``=`` *expression*, se dice que la función tiene \"valores de parámetros " "predeterminados\". Para un parámetro con un valor predeterminado, el " "correspondiente :term:`argument` puede omitirse desde una llamada, en cuyo " -"caso se sustituye el valor predeterminado del parámetro. Si un parámetro " -"tiene un valor predeterminado, todos los parámetros siguientes hasta el " -"\"``*``\" también deben tener un valor predeterminado --- esta es una " -"restricción sintáctica que la gramática no expresa." +"caso se sustituye el valor predeterminado del parámetro. Si un parámetro tiene " +"un valor predeterminado, todos los parámetros siguientes hasta el \"``*``\" " +"también deben tener un valor predeterminado --- esta es una restricción " +"sintáctica que la gramática no expresa." #: ../Doc/reference/compound_stmts.rst:1202 -#, fuzzy -msgid "" -"**Default parameter values are evaluated from left to right when the " -"function definition is executed.** This means that the expression is " -"evaluated once, when the function is defined, and that the same \"pre-" -"computed\" value is used for each call. This is especially important to " -"understand when a default parameter value is a mutable object, such as a " -"list or a dictionary: if the function modifies the object (e.g. by appending " -"an item to a list), the default parameter value is in effect modified. This " -"is generally not what was intended. A way around this is to use ``None`` as " -"the default, and explicitly test for it in the body of the function, e.g.::" +msgid "" +"**Default parameter values are evaluated from left to right when the function " +"definition is executed.** This means that the expression is evaluated once, " +"when the function is defined, and that the same \"pre-computed\" value is used " +"for each call. This is especially important to understand when a default " +"parameter value is a mutable object, such as a list or a dictionary: if the " +"function modifies the object (e.g. by appending an item to a list), the " +"default parameter value is in effect modified. This is generally not what was " +"intended. A way around this is to use ``None`` as the default, and explicitly " +"test for it in the body of the function, e.g.::" msgstr "" "**Los valores de los parámetros predeterminados se evalúan de izquierda a " -"derecha cuando se ejecuta la definición de la función.** Esto significa que " -"la expresión se evalúa una vez, cuando se define la función, y que se " -"utiliza el mismo valor \"precalculado\" para cada llamada . Esto es " -"especialmente importante para entender cuando un parámetro predeterminado es " -"un objeto mutable, como una lista o un diccionario: si la función modifica " -"el objeto (por ejemplo, al agregar un elemento a una lista), el valor " -"predeterminado está en efecto modificado. Esto generalmente no es lo que se " -"pretendía. Una forma de evitar esto es usar ``None`` como valor " -"predeterminado y probarlo explícitamente en el cuerpo de la función, por " -"ejemplo:" +"derecha cuando se ejecuta la definición de la función.** Esto significa que la " +"expresión se evalúa una vez, cuando se define la función, y que se utiliza el " +"mismo valor \"precalculado\" para cada llamada . Esto es especialmente " +"importante para entender cuando un parámetro predeterminado es un objeto " +"mutable, como una lista o un diccionario: si la función modifica el objeto " +"(por ejemplo, al agregar un elemento a una lista), el valor predeterminado " +"está en efecto modificado. Esto generalmente no es lo que se pretendía. Una " +"forma de evitar esto es usar ``None`` como valor predeterminado y probarlo " +"explícitamente en el cuerpo de la función, por ejemplo::" #: ../Doc/reference/compound_stmts.rst:1223 -#, fuzzy -msgid "" -"Function call semantics are described in more detail in section :ref:" -"`calls`. A function call always assigns values to all parameters mentioned " -"in the parameter list, either from positional arguments, from keyword " -"arguments, or from default values. If the form \"``*identifier``\" is " -"present, it is initialized to a tuple receiving any excess positional " -"parameters, defaulting to the empty tuple. If the form \"``**identifier``\" " -"is present, it is initialized to a new ordered mapping receiving any excess " -"keyword arguments, defaulting to a new empty mapping of the same type. " -"Parameters after \"``*``\" or \"``*identifier``\" are keyword-only " -"parameters and may only be passed by keyword arguments. Parameters before " -"\"``/``\" are positional-only parameters and may only be passed by " -"positional arguments." -msgstr "" -"La semántica de llamadas de función se describe con más detalle en la " -"sección :ref:`calls`. Una llamada a la función siempre asigna valores a " -"todos los parámetros mencionados en la lista de parámetros, ya sea desde " -"argumentos de posición, desde argumentos por palabra clave o desde valores " -"predeterminados. Si está presente la forma \"``*identifier``\", se " -"inicializa en una tupla que recibe cualquier parámetro posicional en exceso, " -"por defecto en la tupla vacía. Si el formulario \"``**identifier``\" está " -"presente, se inicializa a una nueva asignación ordenada que recibe cualquier " -"exceso de argumentos por palabra clave, por defecto a una nueva asignación " -"vacía del mismo tipo. Los parámetros después de \"``*``\" o \"``*identifier``" -"\" son parámetros solo por palabra clave y solo pueden pasarse con " -"argumentos de palabras claves usadas." +msgid "" +"Function call semantics are described in more detail in section :ref:`calls`. " +"A function call always assigns values to all parameters mentioned in the " +"parameter list, either from positional arguments, from keyword arguments, or " +"from default values. If the form \"``*identifier``\" is present, it is " +"initialized to a tuple receiving any excess positional parameters, defaulting " +"to the empty tuple. If the form \"``**identifier``\" is present, it is " +"initialized to a new ordered mapping receiving any excess keyword arguments, " +"defaulting to a new empty mapping of the same type. Parameters after \"``*``" +"\" or \"``*identifier``\" are keyword-only parameters and may only be passed " +"by keyword arguments. Parameters before \"``/``\" are positional-only " +"parameters and may only be passed by positional arguments." +msgstr "" +"La semántica de llamadas de función se describe con más detalle en la sección :" +"ref:`calls`. Una llamada a la función siempre asigna valores a todos los " +"parámetros mencionados en la lista de parámetros, ya sea desde argumentos de " +"posición, desde argumentos por palabra clave o desde valores predeterminados. " +"Si está presente la forma \"``*identifier``\", se inicializa en una tupla que " +"recibe cualquier parámetro posicional excedente, por defecto en la tupla " +"vacía. Si el formulario \"``**identifier``\" está presente, se inicializa a " +"una nueva asignación ordenada que recibe cualquier exceso de argumentos por " +"palabra clave, por defecto a una nueva asignación vacía del mismo tipo. Los " +"parámetros después de \"``*``\" o \"``*identifier``\" son parámetros solo por " +"palabra clave y solo pueden pasarse con argumentos de palabras claves usadas." #: ../Doc/reference/compound_stmts.rst:1235 msgid "" "The ``/`` function parameter syntax may be used to indicate positional-only " "parameters. See :pep:`570` for details." msgstr "" +"La sintaxis del parámetro de función ``/`` se puede utilizar para indicar " +"parámetros de posición únicamente. Consulte :pep:`570` para obtener más " +"detalles." #: ../Doc/reference/compound_stmts.rst:1244 msgid "" "Parameters may have an :term:`annotation ` of the form " -"\"``: expression``\" following the parameter name. Any parameter may have " -"an annotation, even those of the form ``*identifier`` or ``**identifier``. " +"\"``: expression``\" following the parameter name. Any parameter may have an " +"annotation, even those of the form ``*identifier`` or ``**identifier``. " "Functions may have \"return\" annotation of the form \"``-> expression``\" " "after the parameter list. These annotations can be any valid Python " "expression. The presence of annotations does not change the semantics of a " -"function. The annotation values are available as values of a dictionary " -"keyed by the parameters' names in the :attr:`__annotations__` attribute of " -"the function object. If the ``annotations`` import from :mod:`__future__` " -"is used, annotations are preserved as strings at runtime which enables " -"postponed evaluation. Otherwise, they are evaluated when the function " -"definition is executed. In this case annotations may be evaluated in a " -"different order than they appear in the source code." +"function. The annotation values are available as values of a dictionary keyed " +"by the parameters' names in the :attr:`__annotations__` attribute of the " +"function object. If the ``annotations`` import from :mod:`__future__` is " +"used, annotations are preserved as strings at runtime which enables postponed " +"evaluation. Otherwise, they are evaluated when the function definition is " +"executed. In this case annotations may be evaluated in a different order than " +"they appear in the source code." msgstr "" "Los parámetros pueden tener :term:`annotation ` de la " "forma \"``: expression``\" que sigue al nombre del parámetro. Cualquier " -"parámetro puede tener una anotación, incluso las de la forma ``*identifier`` " -"o ``** identifier``. Las funciones pueden tener una anotación \"return\" de " -"la forma \"``-> expression``\" después de la lista de parámetros. Estas " +"parámetro puede tener una anotación, incluso las de la forma ``*identifier`` o " +"``** identifier``. Las funciones pueden tener una anotación \"return\" de la " +"forma \"``-> expression``\" después de la lista de parámetros. Estas " "anotaciones pueden ser cualquier expresión válida de Python. La presencia de " "anotaciones no cambia la semántica de una función. Los valores de anotación " "están disponibles como valores de un diccionario con los nombres de los " -"parámetros en el atributo :attr:`__annotations__` del objeto de la función. " -"Si se usa ``annotations`` importada desde :mod:`__future__`, las anotaciones " -"se conservan como cadenas de caracteres en tiempo de ejecución que permiten " -"la evaluación pospuesta. De lo contrario, se evalúan cuando se ejecuta la " -"definición de la función. En este caso, las anotaciones pueden evaluarse en " -"un orden diferente al que aparecen en el código fuente." +"parámetros en el atributo :attr:`__annotations__` del objeto de la función. Si " +"se usa ``annotations`` importada desde :mod:`__future__`, las anotaciones se " +"conservan como cadenas de caracteres en tiempo de ejecución que permiten la " +"evaluación pospuesta. De lo contrario, se evalúan cuando se ejecuta la " +"definición de la función. En este caso, las anotaciones pueden evaluarse en un " +"orden diferente al que aparecen en el código fuente." #: ../Doc/reference/compound_stmts.rst:1259 msgid "" "It is also possible to create anonymous functions (functions not bound to a " "name), for immediate use in expressions. This uses lambda expressions, " -"described in section :ref:`lambda`. Note that the lambda expression is " -"merely a shorthand for a simplified function definition; a function defined " -"in a \":keyword:`def`\" statement can be passed around or assigned to " -"another name just like a function defined by a lambda expression. The \":" -"keyword:`!def`\" form is actually more powerful since it allows the " -"execution of multiple statements and annotations." +"described in section :ref:`lambda`. Note that the lambda expression is merely " +"a shorthand for a simplified function definition; a function defined in a \":" +"keyword:`def`\" statement can be passed around or assigned to another name " +"just like a function defined by a lambda expression. The \":keyword:`!def`\" " +"form is actually more powerful since it allows the execution of multiple " +"statements and annotations." msgstr "" "También es posible crear funciones anónimas (funciones no vinculadas a un " "nombre), para uso inmediato en expresiones. Utiliza expresiones lambda, " -"descritas en la sección :ref:`lambda`. Tenga en cuenta que la expresión " -"lambda es simplemente una abreviatura para una definición de función " -"simplificada; una función definida en una sentencia \":keyword:`def`\" puede " -"pasarse o asignarse a otro nombre al igual que una función definida por una " -"expresión lambda. La forma \":keyword:`!def`\" es en realidad más poderosa " -"ya que permite la ejecución de múltiples sentencias y anotaciones." +"descritas en la sección :ref:`lambda`. Tenga en cuenta que la expresión lambda " +"es simplemente una abreviatura para una definición de función simplificada; " +"una función definida en una sentencia \":keyword:`def`\" puede pasarse o " +"asignarse a otro nombre al igual que una función definida por una expresión " +"lambda. La forma \":keyword:`!def`\" es en realidad más poderosa ya que " +"permite la ejecución de múltiples sentencias y anotaciones." #: ../Doc/reference/compound_stmts.rst:1267 msgid "" "**Programmer's note:** Functions are first-class objects. A \"``def``\" " -"statement executed inside a function definition defines a local function " -"that can be returned or passed around. Free variables used in the nested " -"function can access the local variables of the function containing the def. " -"See section :ref:`naming` for details." +"statement executed inside a function definition defines a local function that " +"can be returned or passed around. Free variables used in the nested function " +"can access the local variables of the function containing the def. See " +"section :ref:`naming` for details." msgstr "" "**Nota del programador:** Las funciones son objetos de la primera-clase. Una " -"sentencia \"``def``\" ejecutada dentro de una definición de función define " -"una función local que se puede retornar o pasar. Las variables libres " -"utilizadas en la función anidada pueden acceder a las variables locales de " -"la función que contiene el def. Vea la sección :ref:`naming` para más " -"detalles." +"sentencia \"``def``\" ejecutada dentro de una definición de función define una " +"función local que se puede retornar o pasar. Las variables libres utilizadas " +"en la función anidada pueden acceder a las variables locales de la función que " +"contiene el def. Vea la sección :ref:`naming` para más detalles." #: ../Doc/reference/compound_stmts.rst:1276 msgid ":pep:`3107` - Function Annotations" @@ -1842,8 +1997,8 @@ msgstr ":pep:`563` - Evaluación pospuesta de anotaciones" #: ../Doc/reference/compound_stmts.rst:1286 msgid "" -"Support for forward references within annotations by preserving annotations " -"in a string form at runtime instead of eager evaluation." +"Support for forward references within annotations by preserving annotations in " +"a string form at runtime instead of eager evaluation." msgstr "" "Admite referencias directas dentro de las anotaciones conservando las " "anotaciones en forma de cadena de caracteres en tiempo de ejecución en lugar " @@ -1861,17 +2016,17 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:1315 msgid "" "A class definition is an executable statement. The inheritance list usually " -"gives a list of base classes (see :ref:`metaclasses` for more advanced " -"uses), so each item in the list should evaluate to a class object which " -"allows subclassing. Classes without an inheritance list inherit, by " -"default, from the base class :class:`object`; hence, ::" +"gives a list of base classes (see :ref:`metaclasses` for more advanced uses), " +"so each item in the list should evaluate to a class object which allows " +"subclassing. Classes without an inheritance list inherit, by default, from " +"the base class :class:`object`; hence, ::" msgstr "" "Una definición de clase es una sentencia ejecutable. La lista de herencia " -"generalmente proporciona una lista de clases base (consulte :ref:" -"`metaclasses` para usos más avanzados), por lo que cada elemento de la lista " -"debe evaluar a un objeto de clase que permita la subclasificación. Las " -"clases sin una lista de herencia heredan, por defecto, de la clase base :" -"class:`object`; por lo tanto, ::" +"generalmente proporciona una lista de clases base (consulte :ref:`metaclasses` " +"para usos más avanzados), por lo que cada elemento de la lista debe evaluar a " +"un objeto de clase que permita la subclasificación. Las clases sin una lista " +"de herencia heredan, por defecto, de la clase base :class:`object`; por lo " +"tanto, ::" #: ../Doc/reference/compound_stmts.rst:1324 msgid "is equivalent to ::" @@ -1882,8 +2037,8 @@ msgid "" "The class's suite is then executed in a new execution frame (see :ref:" "`naming`), using a newly created local namespace and the original global " "namespace. (Usually, the suite contains mostly function definitions.) When " -"the class's suite finishes execution, its execution frame is discarded but " -"its local namespace is saved. [#]_ A class object is then created using the " +"the class's suite finishes execution, its execution frame is discarded but its " +"local namespace is saved. [#]_ A class object is then created using the " "inheritance list for the base classes and the saved local namespace for the " "attribute dictionary. The class name is bound to this class object in the " "original local namespace." @@ -1891,24 +2046,24 @@ msgstr "" "La suite de la clase se ejecuta en un nuevo marco de ejecución (ver :ref:" "`naming`), usando un espacio de nombres local recién creado y el espacio de " "nombres global original. (Por lo general, el bloque contiene principalmente " -"definiciones de funciones). Cuando la suite de la clase finaliza la " -"ejecución, su marco de ejecución se descarta pero se guarda su espacio de " -"nombres local. [#]_ Luego se crea un objeto de clase utilizando la lista de " -"herencia para las clases base y el espacio de nombres local guardado para el " -"diccionario de atributos. El nombre de la clase está vinculado a este objeto " -"de clase en el espacio de nombres local original." +"definiciones de funciones). Cuando la suite de la clase finaliza la ejecución, " +"su marco de ejecución se descarta pero se guarda su espacio de nombres local. " +"[#]_ Luego se crea un objeto de clase utilizando la lista de herencia para las " +"clases base y el espacio de nombres local guardado para el diccionario de " +"atributos. El nombre de la clase está vinculado a este objeto de clase en el " +"espacio de nombres local original." #: ../Doc/reference/compound_stmts.rst:1338 msgid "" "The order in which attributes are defined in the class body is preserved in " -"the new class's ``__dict__``. Note that this is reliable only right after " -"the class is created and only for classes that were defined using the " -"definition syntax." +"the new class's ``__dict__``. Note that this is reliable only right after the " +"class is created and only for classes that were defined using the definition " +"syntax." msgstr "" -"El orden en que se definen los atributos en el cuerpo de la clase se " -"conserva en el ``__dict__`` de la nueva clase. Tenga en cuenta que esto es " -"confiable solo justo después de crear la clase y solo para las clases que se " -"definieron utilizando la sintaxis de definición." +"El orden en que se definen los atributos en el cuerpo de la clase se conserva " +"en el ``__dict__`` de la nueva clase. Tenga en cuenta que esto es confiable " +"solo justo después de crear la clase y solo para las clases que se definieron " +"utilizando la sintaxis de definición." #: ../Doc/reference/compound_stmts.rst:1343 msgid "" @@ -1929,15 +2084,14 @@ msgid "" "The evaluation rules for the decorator expressions are the same as for " "function decorators. The result is then bound to the class name." msgstr "" -"Las reglas de evaluación para las expresiones de decorador son las mismas " -"que para los decoradores de funciones. El resultado se vincula al nombre de " -"la clase." +"Las reglas de evaluación para las expresiones de decorador son las mismas que " +"para los decoradores de funciones. El resultado se vincula al nombre de la " +"clase." #: ../Doc/reference/compound_stmts.rst:1362 msgid "" "Classes may be decorated with any valid :token:`assignment_expression`. " -"Previously, the grammar was much more restrictive; see :pep:`614` for " -"details." +"Previously, the grammar was much more restrictive; see :pep:`614` for details." msgstr "" "Las clases se pueden decorar con cualquier token válido :token:" "`assignment_expression`. Anteriormente, la gramática era mucho más " @@ -1946,23 +2100,22 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:1367 msgid "" "**Programmer's note:** Variables defined in the class definition are class " -"attributes; they are shared by instances. Instance attributes can be set in " -"a method with ``self.name = value``. Both class and instance attributes are " +"attributes; they are shared by instances. Instance attributes can be set in a " +"method with ``self.name = value``. Both class and instance attributes are " "accessible through the notation \"``self.name``\", and an instance attribute " "hides a class attribute with the same name when accessed in this way. Class " -"attributes can be used as defaults for instance attributes, but using " -"mutable values there can lead to unexpected results. :ref:`Descriptors " -"` can be used to create instance variables with different " -"implementation details." +"attributes can be used as defaults for instance attributes, but using mutable " +"values there can lead to unexpected results. :ref:`Descriptors ` " +"can be used to create instance variables with different implementation details." msgstr "" "** Nota del programador: ** Las variables definidas en la definición de la " -"clase son atributos de clase; son compartidos por instancias. Los atributos " -"de instancia se pueden establecer en un método con ``self.name = value``. Se " +"clase son atributos de clase; son compartidos por instancias. Los atributos de " +"instancia se pueden establecer en un método con ``self.name = value``. Se " "puede acceder a los atributos de clase e instancia a través de la notación " -"\"``self.name``\", y un atributo de instancia oculta un atributo de clase " -"con el mismo nombre cuando se accede de esta manera. Los atributos de clase " -"se pueden usar como valores predeterminados para los atributos de instancia, " -"pero el uso de valores mutables puede generar resultados inesperados. :ref:" +"\"``self.name``\", y un atributo de instancia oculta un atributo de clase con " +"el mismo nombre cuando se accede de esta manera. Los atributos de clase se " +"pueden usar como valores predeterminados para los atributos de instancia, pero " +"el uso de valores mutables puede generar resultados inesperados. :ref:" "`Descriptors ` se puede usar para crear variables de instancia " "con diferentes detalles de implementación." @@ -1975,8 +2128,8 @@ msgid "" "The proposal that changed the declaration of metaclasses to the current " "syntax, and the semantics for how classes with metaclasses are constructed." msgstr "" -"La propuesta que cambió la declaración de metaclases a la sintaxis actual y " -"la semántica de cómo se construyen las clases con metaclases." +"La propuesta que cambió la declaración de metaclases a la sintaxis actual y la " +"semántica de cómo se construyen las clases con metaclases." #: ../Doc/reference/compound_stmts.rst:1385 msgid ":pep:`3129` - Class Decorators" @@ -1984,8 +2137,8 @@ msgstr ":pep:`3129` - Decoradores de clase" #: ../Doc/reference/compound_stmts.rst:1385 msgid "" -"The proposal that added class decorators. Function and method decorators " -"were introduced in :pep:`318`." +"The proposal that added class decorators. Function and method decorators were " +"introduced in :pep:`318`." msgstr "" "La propuesta que agregó decoradores de clase. Los decoradores de funciones y " "métodos se introdujeron en :pep:`318`." @@ -2002,22 +2155,25 @@ msgstr "Definición de la función corrutina" msgid "" "Execution of Python coroutines can be suspended and resumed at many points " "(see :term:`coroutine`). :keyword:`await` expressions, :keyword:`async for` " -"and :keyword:`async with` can only be used in the body of a coroutine " -"function." +"and :keyword:`async with` can only be used in the body of a coroutine function." msgstr "" +"La ejecución de corrutinas de Python se puede suspender y reanudar en muchos " +"puntos (consulte :term:`coroutine`). Las expresiones :keyword:`await`, :" +"keyword:`async for` y :keyword:`async with` solo se pueden utilizar en el " +"cuerpo de una función de corrutina." #: ../Doc/reference/compound_stmts.rst:1414 msgid "" "Functions defined with ``async def`` syntax are always coroutine functions, " "even if they do not contain ``await`` or ``async`` keywords." msgstr "" -"Las funciones definidas con la sintaxis ``async def`` siempre son funciones " -"de corrutina, incluso si no contienen palabras claves ``await`` o ``async``." +"Las funciones definidas con la sintaxis ``async def`` siempre son funciones de " +"corrutina, incluso si no contienen palabras claves ``await`` o ``async``." #: ../Doc/reference/compound_stmts.rst:1417 msgid "" -"It is a :exc:`SyntaxError` to use a ``yield from`` expression inside the " -"body of a coroutine function." +"It is a :exc:`SyntaxError` to use a ``yield from`` expression inside the body " +"of a coroutine function." msgstr "" "Es un error del tipo :exc:`SyntaxError` usar una expresión ``yield from`` " "dentro del cuerpo de una función de corrutina." @@ -2028,9 +2184,11 @@ msgstr "Un ejemplo de una función corrutina::" #: ../Doc/reference/compound_stmts.rst:1426 msgid "" -"``await`` and ``async`` are now keywords; previously they were only treated " -"as such inside the body of a coroutine function." +"``await`` and ``async`` are now keywords; previously they were only treated as " +"such inside the body of a coroutine function." msgstr "" +"``await`` y ``async`` ahora son palabras clave; anteriormente solo se los " +"trataba como tales dentro del cuerpo de una función de rutina." #: ../Doc/reference/compound_stmts.rst:1434 msgid "The :keyword:`!async for` statement" @@ -2039,8 +2197,8 @@ msgstr "La sentencia :keyword:`!async for`" #: ../Doc/reference/compound_stmts.rst:1439 msgid "" "An :term:`asynchronous iterable` provides an ``__aiter__`` method that " -"directly returns an :term:`asynchronous iterator`, which can call " -"asynchronous code in its ``__anext__`` method." +"directly returns an :term:`asynchronous iterator`, which can call asynchronous " +"code in its ``__anext__`` method." msgstr "" "Un :term:`asynchronous iterable` proporciona un método ``__aiter__`` que " "retorna directamente un :term:`asynchronous iterator`, que puede llamar a " @@ -2064,11 +2222,11 @@ msgstr "Ver también :meth:`__aiter__` y :meth:`__anext__` para más detalles." #: ../Doc/reference/compound_stmts.rst:1471 msgid "" -"It is a :exc:`SyntaxError` to use an ``async for`` statement outside the " -"body of a coroutine function." +"It is a :exc:`SyntaxError` to use an ``async for`` statement outside the body " +"of a coroutine function." msgstr "" -"Es un error del tipo :exc:`SyntaxError` usar una sentencia ``async for`` " -"fuera del cuerpo de una función de corrutina." +"Es un error del tipo :exc:`SyntaxError` usar una sentencia ``async for`` fuera " +"del cuerpo de una función de corrutina." #: ../Doc/reference/compound_stmts.rst:1479 msgid "The :keyword:`!async with` statement" @@ -2088,8 +2246,8 @@ msgstr "Ver también :meth:`__aenter__` y :meth:`__aexit__` para más detalles." #: ../Doc/reference/compound_stmts.rst:1513 msgid "" -"It is a :exc:`SyntaxError` to use an ``async with`` statement outside the " -"body of a coroutine function." +"It is a :exc:`SyntaxError` to use an ``async with`` statement outside the body " +"of a coroutine function." msgstr "" "Es un error del tipo :exc:`SyntaxError` usar una sentencia ``async with`` " "fuera del cuerpo de una función de corrutina." @@ -2112,86 +2270,98 @@ msgstr "Notas al pie" #: ../Doc/reference/compound_stmts.rst:1525 msgid "" -"The exception is propagated to the invocation stack unless there is a :" -"keyword:`finally` clause which happens to raise another exception. That new " -"exception causes the old one to be lost." +"The exception is propagated to the invocation stack unless there is a :keyword:" +"`finally` clause which happens to raise another exception. That new exception " +"causes the old one to be lost." msgstr "" -"La excepción se propaga a la pila de invocación a menos que haya una " -"cláusula :keyword:`finally` que provoque otra excepción. Esa nueva excepción " -"hace que se pierda la anterior." +"La excepción se propaga a la pila de invocación a menos que haya una cláusula :" +"keyword:`finally` que provoque otra excepción. Esa nueva excepción hace que se " +"pierda la anterior." #: ../Doc/reference/compound_stmts.rst:1529 msgid "In pattern matching, a sequence is defined as one of the following:" msgstr "" +"En la coincidencia de patrones, una secuencia se define como una de las " +"siguientes:" #: ../Doc/reference/compound_stmts.rst:1531 msgid "a class that inherits from :class:`collections.abc.Sequence`" -msgstr "" +msgstr "una clase que hereda de :class:`collections.abc.Sequence`" #: ../Doc/reference/compound_stmts.rst:1532 msgid "" "a Python class that has been registered as :class:`collections.abc.Sequence`" msgstr "" +"una clase de Python que se ha registrado como :class:`collections.abc.Sequence`" #: ../Doc/reference/compound_stmts.rst:1533 msgid "" "a builtin class that has its (CPython) :data:`Py_TPFLAGS_SEQUENCE` bit set" msgstr "" +"una clase incorporada que tiene su conjunto de bits (CPython) :data:" +"`Py_TPFLAGS_SEQUENCE`" #: ../Doc/reference/compound_stmts.rst:1534 #: ../Doc/reference/compound_stmts.rst:1553 msgid "a class that inherits from any of the above" -msgstr "" +msgstr "una clase que hereda de cualquiera de los anteriores" #: ../Doc/reference/compound_stmts.rst:1536 msgid "The following standard library classes are sequences:" -msgstr "" +msgstr "Las siguientes clases de biblioteca estándar son secuencias:" #: ../Doc/reference/compound_stmts.rst:1538 msgid ":class:`array.array`" -msgstr "" +msgstr ":class:`array.array`" #: ../Doc/reference/compound_stmts.rst:1539 msgid ":class:`collections.deque`" -msgstr "" +msgstr ":class:`collections.deque`" #: ../Doc/reference/compound_stmts.rst:1541 msgid ":class:`memoryview`" -msgstr "" +msgstr ":class:`memoryview`" #: ../Doc/reference/compound_stmts.rst:1542 msgid ":class:`range`" -msgstr "" +msgstr ":class:`range`" #: ../Doc/reference/compound_stmts.rst:1545 msgid "" "Subject values of type ``str``, ``bytes``, and ``bytearray`` do not match " "sequence patterns." msgstr "" +"Los valores de sujeto de tipo ``str``, ``bytes`` y ``bytearray`` no coinciden " +"con los patrones de secuencia." #: ../Doc/reference/compound_stmts.rst:1548 msgid "In pattern matching, a mapping is defined as one of the following:" msgstr "" +"En la coincidencia de patrones, un mapeo se define como uno de los siguientes:" #: ../Doc/reference/compound_stmts.rst:1550 msgid "a class that inherits from :class:`collections.abc.Mapping`" -msgstr "" +msgstr "una clase que hereda de :class:`collections.abc.Mapping`" #: ../Doc/reference/compound_stmts.rst:1551 msgid "" "a Python class that has been registered as :class:`collections.abc.Mapping`" msgstr "" +"una clase de Python que se ha registrado como :class:`collections.abc.Mapping`" #: ../Doc/reference/compound_stmts.rst:1552 -msgid "" -"a builtin class that has its (CPython) :data:`Py_TPFLAGS_MAPPING` bit set" +msgid "a builtin class that has its (CPython) :data:`Py_TPFLAGS_MAPPING` bit set" msgstr "" +"una clase incorporada que tiene su conjunto de bits (CPython) :data:" +"`Py_TPFLAGS_MAPPING`" #: ../Doc/reference/compound_stmts.rst:1555 msgid "" -"The standard library classes :class:`dict` and :class:`types." -"MappingProxyType` are mappings." +"The standard library classes :class:`dict` and :class:`types.MappingProxyType` " +"are mappings." msgstr "" +"Las clases de biblioteca estándar :class:`dict` y :class:`types." +"MappingProxyType` son asignaciones." #: ../Doc/reference/compound_stmts.rst:1558 msgid "" @@ -2200,8 +2370,8 @@ msgid "" "function's :term:`docstring`." msgstr "" "Una cadena de caracteres literal que aparece como la primera sentencia en el " -"cuerpo de la función se transforma en el atributo ``__doc__`` de la función " -"y, por lo tanto, en funciones :term:`docstring`." +"cuerpo de la función se transforma en el atributo ``__doc__`` de la función y, " +"por lo tanto, en funciones :term:`docstring`." #: ../Doc/reference/compound_stmts.rst:1562 msgid "" @@ -2214,15 +2384,15 @@ msgstr "" "``__doc__`` y, por lo tanto, de la clase :term:`docstring`." #~ msgid "" -#~ "Execution of Python coroutines can be suspended and resumed at many " -#~ "points (see :term:`coroutine`). Inside the body of a coroutine function, " +#~ "Execution of Python coroutines can be suspended and resumed at many points " +#~ "(see :term:`coroutine`). Inside the body of a coroutine function, " #~ "``await`` and ``async`` identifiers become reserved keywords; :keyword:" #~ "`await` expressions, :keyword:`async for` and :keyword:`async with` can " #~ "only be used in coroutine function bodies." #~ msgstr "" -#~ "La ejecución de las corrutinas de Python puede suspenderse y reanudarse " -#~ "en muchos puntos (ver :term:`coroutine`). Dentro del cuerpo de una " -#~ "función de corrutina, los identificadores ``await`` y ``async`` se " -#~ "convierten en palabras claves reservadas; las expresiones :keyword:" -#~ "`await`, :keyword:`async for` y :keyword:`async with` solo se puede usar " -#~ "en los cuerpos de funciones de corrutina." +#~ "La ejecución de las corrutinas de Python puede suspenderse y reanudarse en " +#~ "muchos puntos (ver :term:`coroutine`). Dentro del cuerpo de una función de " +#~ "corrutina, los identificadores ``await`` y ``async`` se convierten en " +#~ "palabras claves reservadas; las expresiones :keyword:`await`, :keyword:" +#~ "`async for` y :keyword:`async with` solo se puede usar en los cuerpos de " +#~ "funciones de corrutina." From 77a26196140e2f09ff457f7ba1743238bab5d4b6 Mon Sep 17 00:00:00 2001 From: "Carlos A. Crespo" Date: Thu, 6 Jan 2022 10:14:39 -0300 Subject: [PATCH 6/8] powrap --- reference/compound_stmts.po | 1339 ++++++++++++++++++----------------- 1 file changed, 693 insertions(+), 646 deletions(-) diff --git a/reference/compound_stmts.po b/reference/compound_stmts.po index d2231b707d..68a60a2961 100644 --- a/reference/compound_stmts.po +++ b/reference/compound_stmts.po @@ -34,8 +34,8 @@ msgid "" "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 " +"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." @@ -44,53 +44,54 @@ 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." +"`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 " +"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::" +"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::" +"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: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::" +"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::" +"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:45 msgid "Summarizing:" @@ -99,25 +100,25 @@ 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 " +"``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)." +"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." +"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" @@ -129,18 +130,19 @@ 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." +"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." +"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" @@ -158,25 +160,25 @@ msgstr "" 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." +"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." +"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." +"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." +"`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" @@ -193,90 +195,90 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:160 msgid "" -"The expression list is evaluated once; it should yield an iterable object. An " -"iterator is created for the result of the ``expression_list``. The suite is " -"then executed once for each item provided by the iterator, in the order " +"The expression list is evaluated once; it should yield an iterable object. " +"An iterator is created for the result of the ``expression_list``. The suite " +"is then executed once for each item provided by the iterator, in the order " "returned by the iterator. Each item in turn is assigned to the target list " -"using the standard rules for assignments (see :ref:`assignment`), and then the " -"suite is executed. When the items are exhausted (which is immediately when " -"the sequence is empty or an iterator raises a :exc:`StopIteration` exception), " -"the suite in the :keyword:`!else` clause, if present, is executed, and the " -"loop terminates." +"using the standard rules for assignments (see :ref:`assignment`), and then " +"the suite is executed. When the items are exhausted (which is immediately " +"when the sequence is empty or an iterator raises a :exc:`StopIteration` " +"exception), the suite in the :keyword:`!else` clause, if present, is " +"executed, and the loop terminates." msgstr "" "La lista de expresiones se evalúa una vez; debería producir un objeto " -"iterable. Se crea un iterador para el resultado de la ``expression_list``. La " -"suite se ejecuta una vez para cada elemento proporcionado por el iterador, en " -"el orden retornado por el iterador. Cada elemento a su vez se asigna a la " -"lista utilizando las reglas estándar para las asignaciones (ver :ref:" -"`assignment`), y luego se ejecuta la suite. Cuando los elementos están " +"iterable. Se crea un iterador para el resultado de la ``expression_list``. " +"La suite se ejecuta una vez para cada elemento proporcionado por el " +"iterador, en el orden retornado por el iterador. Cada elemento a su vez se " +"asigna a la lista utilizando las reglas estándar para las asignaciones (ver :" +"ref:`assignment`), y luego se ejecuta la suite. Cuando los elementos están " "agotados (que es inmediatamente cuando la secuencia está vacía o un iterador " -"genera una excepción del tipo :exc:`StopIteration`), la suite en la cláusula :" -"keyword:`!else`, si está presente, se ejecuta y el bucle termina." +"genera una excepción del tipo :exc:`StopIteration`), la suite en la " +"cláusula :keyword:`!else`, si está presente, se ejecuta y el bucle 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." +"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." +"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::" +"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``::" +"sobrescribe todas las asignaciones anteriores a esas variables, incluidas " +"las realizadas en la suite del bucle ``for``::" #: ../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 function :func:`range` returns an iterator of integers " -"suitable to emulate the effect of Pascal's ``for i := a to b do``; e.g., " -"``list(range(3))`` returns the list ``[0, 1, 2]``." +"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 function :func:`range` returns an iterator of " +"integers suitable to emulate the effect of Pascal's ``for i := a to b do``; " +"e.g., ``list(range(3))`` returns the list ``[0, 1, 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: la " -"función incorporada :func:`range` retorna un iterador de enteros adecuado para " -"emular el efecto de Pascal ``for i := a to b do``; por ejemplo, " +"función incorporada :func:`range` retorna un iterador de enteros adecuado " +"para emular el efecto de Pascal ``for i := a to b do``; por ejemplo, " "``list(range(3))`` retorna la lista ``[0, 1, 2]``." #: ../Doc/reference/compound_stmts.rst:205 msgid "" -"There is a subtlety when the sequence is being modified by the loop (this can " -"only occur for mutable sequences, e.g. lists). An internal counter is used to " -"keep track of which item is used next, and this is incremented on each " -"iteration. When this counter has reached the length of the sequence the loop " -"terminates. This means that if the suite deletes the current (or a previous) " -"item from the sequence, the next item will be skipped (since it gets the index " -"of the current item which has already been treated). Likewise, if the suite " -"inserts an item in the sequence before the current item, the current item will " -"be treated again the next time through the loop. This can lead to nasty bugs " -"that can be avoided by making a temporary copy using a slice of the whole " -"sequence, e.g., ::" -msgstr "" -"Hay una sutileza cuando la secuencia está siendo modificada por el bucle (esto " -"solo puede ocurrir para secuencias mutables, por ejemplo, listas). Se utiliza " -"un contador interno para realizar un seguimiento de qué elemento se usa a " -"continuación, y esto se incrementa en cada iteración. Cuando este contador ha " -"alcanzado la longitud de la secuencia, el bucle termina. Esto significa que si " -"la suite elimina el elemento actual (o anterior) de la secuencia, se omitirá " -"el siguiente elemento (ya que obtiene el índice del elemento actual que ya ha " -"sido tratado). Del mismo modo, si la suite inserta un elemento en la secuencia " -"anterior al elemento actual, el elemento actual será tratado nuevamente la " -"próxima vez a través del bucle. Esto puede conducir a errores graves que se " -"pueden evitar haciendo una copia temporal usando una porción de la secuencia " -"completa, por ejemplo, ::" +"There is a subtlety when the sequence is being modified by the loop (this " +"can only occur for mutable sequences, e.g. lists). An internal counter is " +"used to keep track of which item is used next, and this is incremented on " +"each iteration. When this counter has reached the length of the sequence " +"the loop terminates. This means that if the suite deletes the current (or a " +"previous) item from the sequence, the next item will be skipped (since it " +"gets the index of the current item which has already been treated). " +"Likewise, if the suite inserts an item in the sequence before the current " +"item, the current item will be treated again the next time through the loop. " +"This can lead to nasty bugs that can be avoided by making a temporary copy " +"using a slice of the whole sequence, e.g., ::" +msgstr "" +"Hay una sutileza cuando la secuencia está siendo modificada por el bucle " +"(esto solo puede ocurrir para secuencias mutables, por ejemplo, listas). Se " +"utiliza un contador interno para realizar un seguimiento de qué elemento se " +"usa a continuación, y esto se incrementa en cada iteración. Cuando este " +"contador ha alcanzado la longitud de la secuencia, el bucle termina. Esto " +"significa que si la suite elimina el elemento actual (o anterior) de la " +"secuencia, se omitirá el siguiente elemento (ya que obtiene el índice del " +"elemento actual que ya ha sido tratado). Del mismo modo, si la suite inserta " +"un elemento en la secuencia anterior al elemento actual, el elemento actual " +"será tratado nuevamente la próxima vez a través del bucle. Esto puede " +"conducir a errores graves que se pueden evitar haciendo una copia temporal " +"usando una porción de la secuencia completa, por ejemplo, ::" #: ../Doc/reference/compound_stmts.rst:226 msgid "The :keyword:`!try` statement" @@ -284,43 +286,45 @@ msgstr "La sentencia :keyword:`!try`" #: ../Doc/reference/compound_stmts.rst:236 msgid "" -"The :keyword:`try` statement specifies exception handlers and/or cleanup code " -"for a group of statements:" +"The :keyword:`try` statement specifies exception handlers and/or cleanup " +"code for a group of statements:" msgstr "" -"La sentencia :keyword:`try` es especifica para gestionar excepciones o código " -"de limpieza para un grupo de sentencias:" +"La sentencia :keyword:`try` es especifica para gestionar excepciones o " +"código de limpieza para un grupo de sentencias:" #: ../Doc/reference/compound_stmts.rst:249 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 except clauses in " -"turn until one is found that matches the exception. An expression-less except " -"clause, if present, must be last; it matches any exception. For an except " -"clause with an expression, that expression is evaluated, and the clause " -"matches the exception if the resulting object is \"compatible\" with the " -"exception. An object is compatible with an exception if it is the class or a " -"base class of the exception object, or a tuple containing an item that is the " -"class or a base class of the exception object." +"executed. When an exception occurs in the :keyword:`!try` suite, a search " +"for an exception handler is started. This search inspects the except " +"clauses in turn until one is found that matches the exception. An " +"expression-less except clause, if present, must be last; it matches any " +"exception. For an except clause with an expression, that expression is " +"evaluated, and the clause matches the exception if the resulting object is " +"\"compatible\" with the exception. An object is compatible with an " +"exception if it is the class or a base class of the exception object, or a " +"tuple containing an item that is the class or a base class of the exception " +"object." msgstr "" "Las cláusulas :keyword:`except` especifican uno o más manejadores de " "excepciones. Cuando no ocurre ninguna excepción en la palabra clave :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 manejador " -"de excepciones. Esta búsqueda inspecciona las cláusulas except a su vez hasta " -"encontrar una que coincida con la excepción. Una cláusula except sin " -"expresión, si está presente, debe ser la última; coincide con cualquier " -"excepción. Para una cláusula except con una expresión, esa expresión se evalúa " -"y la cláusula coincide con la excepción si el objeto resultante es \"compatible" -"\" con la excepción. Un objeto es compatible con una excepción si es la clase " -"o una clase base del objeto de excepción, o una tupla que contiene un elemento " -"que es la clase o una clase base del objeto de excepción." +"excepción en la suite :keyword:`!try`, se inicia una búsqueda de un " +"manejador de excepciones. Esta búsqueda inspecciona las cláusulas except a " +"su vez hasta encontrar una que coincida con la excepción. Una cláusula " +"except sin expresión, si está presente, debe ser la última; coincide con " +"cualquier excepción. Para una cláusula except con una expresión, esa " +"expresión se evalúa y la cláusula coincide con la excepción si el objeto " +"resultante es \"compatible\" con la excepción. Un objeto es compatible con " +"una excepción si es la clase o una clase base del objeto de excepción, o una " +"tupla que contiene un elemento que es la clase o una clase base del objeto " +"de excepción." #: ../Doc/reference/compound_stmts.rst:261 msgid "" -"If no except clause matches the exception, the search for an exception handler " -"continues in the surrounding code and on the invocation stack. [#]_" +"If no 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 ``except`` coincide con la excepción, la búsqueda de un " "gestor de excepciones continúa en el código circundante y en la pila de " @@ -328,16 +332,17 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:264 msgid "" -"If the evaluation of an expression in the header of an 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)." +"If the evaluation of an expression in the header of an 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 ``except`` " -"genera una excepción, la búsqueda original de un gestor se cancela y se inicia " -"la 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` provocó la " -"excepción)." +"Si la evaluación de una expresión en el encabezado de una cláusula " +"``except`` genera una excepción, la búsqueda original de un gestor se " +"cancela y se inicia la 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` provocó la excepción)." #: ../Doc/reference/compound_stmts.rst:271 msgid "" @@ -346,27 +351,27 @@ msgid "" "present, and the except clause's suite is executed. All except clauses must " "have an executable block. When the end of this block is reached, execution " "continues normally after the entire try statement. (This means that if two " -"nested handlers exist for the same exception, and the exception occurs in the " -"try clause of the inner handler, the outer handler will not handle the " +"nested handlers exist for the same exception, and the exception occurs in " +"the try clause of the inner handler, the outer handler will not handle the " "exception.)" msgstr "" "Cuando se encuentra una cláusula ``except`` coincidente, la excepción se " "asigna al destino especificado después de la palabra clave :keyword:`!as` en " -"esa cláusula ``except``, si está presente, y se ejecuta la suite de cláusulas " -"``except``. Todas las cláusulas ``except`` deben tener un bloque ejecutable. " -"Cuando se alcanza el final de este bloque, la ejecución continúa normalmente " -"después de toda la sentencia try. (Esto significa que si existen dos gestores " -"de errores anidados para la misma excepción, y la excepción ocurre en la " -"cláusula ``try`` del gestor interno, el gestor externo no gestionará la " -"excepción)." +"esa cláusula ``except``, si está presente, y se ejecuta la suite de " +"cláusulas ``except``. Todas las cláusulas ``except`` deben tener un bloque " +"ejecutable. Cuando se alcanza el final de este bloque, la ejecución continúa " +"normalmente después de toda la sentencia try. (Esto significa que si existen " +"dos gestores de errores anidados para la misma excepción, y la excepción " +"ocurre en la cláusula ``try`` del gestor interno, el gestor externo no " +"gestionará la excepción)." #: ../Doc/reference/compound_stmts.rst:279 msgid "" -"When an exception has been assigned using ``as target``, it is cleared at the " -"end of the except clause. This is as if ::" +"When an exception has been assigned using ``as target``, it is cleared at " +"the end of the except clause. This is as if ::" msgstr "" -"Cuando se ha asignado una excepción usando ``as target``, se borra al final de " -"la cláusula ``except``. Esto es como si ::" +"Cuando se ha asignado una excepción usando ``as target``, se borra al final " +"de la cláusula ``except``. Esto es como si ::" #: ../Doc/reference/compound_stmts.rst:285 msgid "was translated to ::" @@ -375,10 +380,10 @@ msgstr "fue traducido a ::" #: ../Doc/reference/compound_stmts.rst:293 msgid "" "This means the exception must be assigned to a different name to be able to " -"refer to it after the 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." +"refer to it after the 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 referirse a ella después de la cláusula ``except``. Las excepciones se " @@ -389,29 +394,29 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:302 msgid "" "Before an except clause's suite is executed, details about the exception are " -"stored in the :mod:`sys` module and can be accessed via :func:`sys.exc_info`. :" -"func:`sys.exc_info` returns a 3-tuple consisting of the exception class, the " -"exception instance and a traceback object (see section :ref:`types`) " -"identifying the point in the program where the exception occurred. The " -"details about the exception accessed via :func:`sys.exc_info` are restored to " -"their previous values when leaving an exception handler::" +"stored in the :mod:`sys` module and can be accessed via :func:`sys." +"exc_info`. :func:`sys.exc_info` returns a 3-tuple consisting of the " +"exception class, the exception instance and a traceback object (see section :" +"ref:`types`) identifying the point in the program where the exception " +"occurred. The details about the exception accessed via :func:`sys.exc_info` " +"are restored to their previous values when leaving an exception handler::" msgstr "" "Antes de que se ejecute un conjunto de cláusulas ``except``, los detalles " "sobre la excepción se almacenan en el módulo :mod:`sys` y se puede acceder a " "través de :func:`sys.exc_info`. :func:`sys.exc_info` retorna 3 tuplas que " "consisten en la clase de excepción, la instancia de excepción y un objeto de " "rastreo (ver sección :ref:`types`) que identifica el punto en el programa " -"donde ocurrió la excepción. Lo valores :func:`sys.exc_info` se restauran a sus " -"valores anteriores (antes de la llamada) al regresar de una función que manejó " -"una excepción::" +"donde ocurrió la excepción. Lo valores :func:`sys.exc_info` se restauran a " +"sus valores anteriores (antes de la llamada) al regresar de una función que " +"manejó una excepción::" #: ../Doc/reference/compound_stmts.rst:334 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." +"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ó " @@ -422,45 +427,46 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:342 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 está presente :keyword:`finally`, esto especifica un gestor de 'limpieza'. " -"La cláusula :keyword:`try` se ejecuta, incluidas las cláusulas :keyword:" -"`except` y :keyword:`!else`. Si se produce 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::" +"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 está presente :keyword:`finally`, esto especifica un gestor de " +"'limpieza'. La cláusula :keyword:`try` se ejecuta, incluidas las cláusulas :" +"keyword:`except` y :keyword:`!else`. Si se produce 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:361 msgid "" -"The exception information is not available to the program during execution of " -"the :keyword:`finally` clause." +"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:369 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.'" +"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 la suite :keyword:`try` de un :keyword:`!try`...\\ la sentencia :" -"keyword:`!finally`, la cláusula :keyword:`finally` también se ejecuta 'al " -"salir'." +"Cuando se ejecuta una sentencia :keyword:`return`, :keyword:`break` o :" +"keyword:`continue` en la suite :keyword:`try` de un :keyword:`!try`...\\ la " +"sentencia :keyword:`!finally`, la cláusula :keyword:`finally` también se " +"ejecuta 'al salir'." #: ../Doc/reference/compound_stmts.rst:373 msgid "" @@ -470,9 +476,9 @@ msgid "" "always be the last one executed::" msgstr "" "El valor de retorno de una función está determinado por la última sentencia :" -"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 ejecutada::" +"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 ejecutada::" #: ../Doc/reference/compound_stmts.rst:387 msgid "" @@ -480,9 +486,10 @@ msgid "" "`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 generar excepciones se puede encontrar en la sección :ref:`raise`." +"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 generar excepciones se puede encontrar en la sección :" +"ref:`raise`." #: ../Doc/reference/compound_stmts.rst:391 msgid "" @@ -503,19 +510,19 @@ msgid "" "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." +"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:419 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:" +"La ejecución de la sentencia :keyword:`with` con un \"item\" se realiza de " +"la siguiente manera:" #: ../Doc/reference/compound_stmts.rst:421 msgid "" @@ -528,7 +535,8 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:424 msgid "The context manager's :meth:`__enter__` is loaded for later use." msgstr "" -"El administrador de contexto :meth:`__enter__` se carga para su uso posterior." +"El administrador de contexto :meth:`__enter__` se carga para su uso " +"posterior." #: ../Doc/reference/compound_stmts.rst:426 msgid "The context manager's :meth:`__exit__` is loaded for later use." @@ -549,17 +557,17 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:435 msgid "" -"The :keyword:`with` statement guarantees that if the :meth:`__enter__` method " -"returns without an error, then :meth:`__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 6 " -"below." +"The :keyword:`with` statement guarantees that if the :meth:`__enter__` " +"method returns without an error, then :meth:`__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 6 below." msgstr "" "La sentencia :keyword:`with` garantiza que si el método :meth:`__enter__` " "regresa sin error, entonces siempre se llamará a :meth:`__exit__`. Por lo " -"tanto, si se produce un error durante la asignación a la lista de destino, se " -"tratará de la misma manera que si se produciría un error dentro de la suite. " -"Vea el paso 6 a continuación." +"tanto, si se produce un error durante la asignación a la lista de destino, " +"se tratará de la misma manera que si se produciría un error dentro de la " +"suite. Vea el paso 6 a continuación." #: ../Doc/reference/compound_stmts.rst:441 msgid "The suite is executed." @@ -573,16 +581,16 @@ msgid "" "supplied." msgstr "" "Se invoca el método del administrador de contexto :meth:`__exit__`. Si una " -"excepción causó la salida de la suite, su tipo, valor y rastreo se pasan como " -"argumentos a :meth:`__exit__`. De lo contrario, se proporcionan tres " +"excepción causó la salida de la suite, su tipo, valor y rastreo se pasan " +"como argumentos a :meth:`__exit__`. De lo contrario, se proporcionan tres " "argumentos :const:`None`." #: ../Doc/reference/compound_stmts.rst:448 msgid "" "If the suite was exited due to an exception, and the return value from the :" "meth:`__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." +"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:`__exit__` fue falso, la excepción se vuelve a plantear. Si el " @@ -621,8 +629,8 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:493 msgid "" -"You can also write multi-item context managers in multiple lines if the items " -"are surrounded by parentheses. For example::" +"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::" @@ -636,8 +644,8 @@ 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." +"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:511 msgid ":pep:`343` - The \"with\" statement" @@ -648,8 +656,8 @@ 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`." +"La especificación, antecedentes y ejemplos de la sentencia de Python :" +"keyword:`with`." #: ../Doc/reference/compound_stmts.rst:517 msgid "The :keyword:`!match` statement" @@ -657,11 +665,13 @@ msgstr "La sentencia :keyword:`!match`" #: ../Doc/reference/compound_stmts.rst:530 msgid "The match statement is used for pattern matching. Syntax:" -msgstr "La declaración match es usada para coincidencia de patrones. Sintaxis:" +msgstr "" +"La declaración match es usada para coincidencia de patrones. Sintaxis:" #: ../Doc/reference/compound_stmts.rst:539 msgid "" -"This section uses single quotes to denote :ref:`soft keywords `." +"This section uses single quotes to denote :ref:`soft keywords `." msgstr "" "Esta sección utiliza comillas simples para denotar las :ref:`palabras clave " "suaves `." @@ -674,9 +684,10 @@ msgid "" "value (following ``match``). The pattern (which may contain subpatterns) is " "matched against the subject value. The outcomes are:" msgstr "" -"La coincidencia de patrones toma un patrón como entrada (delante de ``case``) " -"y un valor de búsqueda (delante de ``match``). El patrón (que puede contener " -"subpatrones) es comparado con el valor de búsqueda. Los resultados son:" +"La coincidencia de patrones toma un patrón como entrada (delante de " +"``case``) y un valor de búsqueda (delante de ``match``). El patrón (que " +"puede contener subpatrones) es comparado con el valor de búsqueda. Los " +"resultados son:" #: ../Doc/reference/compound_stmts.rst:546 msgid "A match success or failure (also termed a pattern success or failure)." @@ -686,8 +697,8 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:548 msgid "" -"Possible binding of matched values to a name. The prerequisites for this are " -"further discussed below." +"Possible binding of matched values to a name. The prerequisites for this " +"are further discussed below." msgstr "" "Una posible vinculación de los valores coincidentes con un nombre. Los " "requisitos previos para esto se discuten abajo." @@ -696,8 +707,8 @@ msgstr "" msgid "" "The ``match`` and ``case`` keywords are :ref:`soft keywords `." msgstr "" -"Las palabras clave ``match`` y ``case`` son :ref:`palabras clave suaves `." +"Las palabras clave ``match`` y ``case`` son :ref:`palabras clave suaves " +"`." #: ../Doc/reference/compound_stmts.rst:555 #: ../Doc/reference/compound_stmts.rst:1109 @@ -716,7 +727,8 @@ msgstr "Resumen" #: ../Doc/reference/compound_stmts.rst:562 msgid "Here's an overview of the logical flow of a match statement:" msgstr "" -"A continuación, un resumen del flujo lógico de una declaración de coincidencia:" +"A continuación, un resumen del flujo lógico de una declaración de " +"coincidencia:" #: ../Doc/reference/compound_stmts.rst:565 msgid "" @@ -730,41 +742,42 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:569 msgid "" -"Each pattern in a ``case_block`` is attempted to match with the subject value. " -"The specific rules for success or failure are described below. The match " -"attempt can also bind some or all of the standalone names within the pattern. " -"The precise pattern binding rules vary per pattern type and are specified " -"below. **Name bindings made during a successful pattern match outlive the " -"executed block and can be used after the match statement**." +"Each pattern in a ``case_block`` is attempted to match with the subject " +"value. The specific rules for success or failure are described below. The " +"match attempt can also bind some or all of the standalone names within the " +"pattern. The precise pattern binding rules vary per pattern type and are " +"specified below. **Name bindings made during a successful pattern match " +"outlive the executed block and can be used after the match statement**." msgstr "" -"Se intenta coincidir cada patrón en un ``case_block`` con el valor sujeto. Las " -"reglas específicas para el éxito o el fracaso se describen abajo. El intento " -"de coincidencia también puede enlazar algunos o todos los nombres " +"Se intenta coincidir cada patrón en un ``case_block`` con el valor sujeto. " +"Las reglas específicas para el éxito o el fracaso se describen abajo. El " +"intento de coincidencia también puede enlazar algunos o todos los nombres " "independientes dentro del patrón. Las reglas precisas de enlace de patrones " -"varían según el tipo de patrón y se especifican a continuación. **Los enlaces " -"de nombre realizados durante una coincidencia de patrones exitosa sobreviven " -"al bloque ejecutado y se pueden usar después de la declaración de " +"varían según el tipo de patrón y se especifican a continuación. **Los " +"enlaces de nombre realizados durante una coincidencia de patrones exitosa " +"sobreviven al bloque ejecutado y se pueden usar después de la declaración de " "coincidencia**." #: ../Doc/reference/compound_stmts.rst:578 msgid "" "During failed pattern matches, some subpatterns may succeed. Do not rely on " -"bindings being made for a failed match. Conversely, do not rely on variables " -"remaining unchanged after a failed match. The exact behavior is dependent on " -"implementation and may vary. This is an intentional decision made to allow " -"different implementations to add optimizations." +"bindings being made for a failed match. Conversely, do not rely on " +"variables remaining unchanged after a failed match. The exact behavior is " +"dependent on implementation and may vary. This is an intentional decision " +"made to allow different implementations to add optimizations." msgstr "" "Durante las coincidencias de patrones fallidas, algunos subpatrones pueden " "tener éxito. No confíe en que los enlaces se realicen para una coincidencia " "fallida. Por el contrario, no confíe en que las variables permanezcan sin " -"cambios después de una coincidencia fallida. El comportamiento exacto depende " -"de la implementación y puede variar. Esta es una decisión intencional para " -"permitir que diferentes implementaciones añadan optimizaciones." +"cambios después de una coincidencia fallida. El comportamiento exacto " +"depende de la implementación y puede variar. Esta es una decisión " +"intencional para permitir que diferentes implementaciones añadan " +"optimizaciones." #: ../Doc/reference/compound_stmts.rst:585 msgid "" -"If the pattern succeeds, the corresponding guard (if present) is evaluated. In " -"this case all name bindings are guaranteed to have happened." +"If the pattern succeeds, the corresponding guard (if present) is evaluated. " +"In this case all name bindings are guaranteed to have happened." msgstr "" "Si el patrón es exitoso, se evalúa la protección correspondiente (si está " "presente). En este caso se garantiza que todos los enlaces de nombres han " @@ -775,8 +788,8 @@ msgid "" "If the guard evaluates as true or is missing, the ``block`` inside " "``case_block`` is executed." msgstr "" -"Si la protección se evalúa como verdadera o no existe, se ejecuta el ``block`` " -"dentro de ``case_block``." +"Si la protección se evalúa como verdadera o no existe, se ejecuta el " +"``block`` dentro de ``case_block``." #: ../Doc/reference/compound_stmts.rst:591 msgid "Otherwise, the next ``case_block`` is attempted as described above." @@ -791,13 +804,14 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:597 msgid "" -"Users should generally never rely on a pattern being evaluated. Depending on " -"implementation, the interpreter may cache values or use other optimizations " -"which skip repeated evaluations." +"Users should generally never rely on a pattern being evaluated. Depending " +"on implementation, the interpreter may cache values or use other " +"optimizations which skip repeated evaluations." msgstr "" "Por lo general, los usuarios no deben confiar en que se evalúe un patrón. " "Dependiendo de la implementación, el intérprete puede almacenar en caché los " -"valores o utilizar otras optimizaciones que omitan las evaluaciones repetidas." +"valores o utilizar otras optimizaciones que omitan las evaluaciones " +"repetidas." #: ../Doc/reference/compound_stmts.rst:601 msgid "A sample match statement::" @@ -821,18 +835,20 @@ msgid "" "``case`` block to execute. It takes the form: :keyword:`if` followed by an " "expression." msgstr "" -"Una ``guard`` (que es parte del ``case``) debe ser exitosa para que el código " -"dentro de ``case`` sea ejecutado. Toma la forma: :keyword:`if` seguida de una " -"expresión." +"Una ``guard`` (que es parte del ``case``) debe ser exitosa para que el " +"código dentro de ``case`` sea ejecutado. Toma la forma: :keyword:`if` " +"seguida de una expresión." #: ../Doc/reference/compound_stmts.rst:632 msgid "The logical flow of a ``case`` block with a ``guard`` follows:" -msgstr "El flujo lógico de un bloque ``case`` con una ``guard`` es el siguiente:" +msgstr "" +"El flujo lógico de un bloque ``case`` con una ``guard`` es el siguiente:" #: ../Doc/reference/compound_stmts.rst:634 msgid "" "Check that the pattern in the ``case`` block succeeded. If the pattern " -"failed, the ``guard`` is not evaluated and the next ``case`` block is checked." +"failed, the ``guard`` is not evaluated and the next ``case`` block is " +"checked." msgstr "" "Se comprueba que el patrón del bloque ``case`` fue exitoso. Si el patrón " "falló, el ``guard`` no se evalúa y se comprueba el siguiente bloque ``case``." @@ -842,22 +858,24 @@ msgid "If the pattern succeeded, evaluate the ``guard``." msgstr "Si el patrón tuvo éxito, se evalúa el ``guard``." #: ../Doc/reference/compound_stmts.rst:640 -msgid "If the ``guard`` condition evaluates as true, the case block is selected." +msgid "" +"If the ``guard`` condition evaluates as true, the case block is selected." msgstr "" "Si la condición del ``guard`` es verdadera, se selecciona el bloque de ese " "caso." #: ../Doc/reference/compound_stmts.rst:643 msgid "" -"If the ``guard`` condition evaluates as false, the case block is not selected." +"If the ``guard`` condition evaluates as false, the case block is not " +"selected." msgstr "" "Si la condición del ``guard`` es falsa, el bloque de ese caso no es " "seleccionado." #: ../Doc/reference/compound_stmts.rst:646 msgid "" -"If the ``guard`` raises an exception during evaluation, the exception bubbles " -"up." +"If the ``guard`` raises an exception during evaluation, the exception " +"bubbles up." msgstr "" "Si el ``guard`` genera una excepción durante la evaluación, se levanta la " "excepción." @@ -865,14 +883,14 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:649 msgid "" "Guards are allowed to have side effects as they are expressions. Guard " -"evaluation must proceed from the first to the last case block, one at a time, " -"skipping case blocks whose pattern(s) don't all succeed. (I.e., guard " -"evaluation must happen in order.) Guard evaluation must stop once a case block " -"is selected." +"evaluation must proceed from the first to the last case block, one at a " +"time, skipping case blocks whose pattern(s) don't all succeed. (I.e., guard " +"evaluation must happen in order.) Guard evaluation must stop once a case " +"block is selected." msgstr "" "Se permite que las protecciones tengan efectos secundarios, ya que son " -"expresiones. La evaluación de la protección debe ir desde el primer al último " -"bloque de casos, uno a la vez, saltando los bloques de casos cuyo(s) " +"expresiones. La evaluación de la protección debe ir desde el primer al " +"último bloque de casos, uno a la vez, saltando los bloques de casos cuyo(s) " "patrón(es) no tenga(n) éxito. (Es decir, la evaluación de las protecciones " "debe realizarse en orden.) La evaluación de las protecciones debe detenerse " "una vez que se selecciona un bloque de casos." @@ -897,10 +915,10 @@ msgid "" "syntax alone that it will always succeed. Only the following patterns are " "irrefutable:" msgstr "" -"Un bloque de casos se considera irrefutable si no tiene protección y su patrón " -"es irrefutable. Un patrón se considera irrefutable si podemos demostrar, sólo " -"por su sintaxis, que siempre tendrá éxito. Sólo los siguientes patrones son " -"irrefutables:" +"Un bloque de casos se considera irrefutable si no tiene protección y su " +"patrón es irrefutable. Un patrón se considera irrefutable si podemos " +"demostrar, sólo por su sintaxis, que siempre tendrá éxito. Sólo los " +"siguientes patrones son irrefutables:" #: ../Doc/reference/compound_stmts.rst:671 msgid ":ref:`as-patterns` whose left-hand side is irrefutable" @@ -928,7 +946,8 @@ msgstr "Patrones" #: ../Doc/reference/compound_stmts.rst:690 msgid "This section uses grammar notations beyond standard EBNF:" -msgstr "Esta sección utiliza notaciones gramaticales más allá del estándar EBNF:" +msgstr "" +"Esta sección utiliza notaciones gramaticales más allá del estándar EBNF:" #: ../Doc/reference/compound_stmts.rst:692 msgid "the notation ``SEP.RULE+`` is shorthand for ``RULE (SEP RULE)*``" @@ -946,18 +965,19 @@ msgstr "La sintaxis de nivel superior para ``patrones`` es:" #: ../Doc/reference/compound_stmts.rst:711 msgid "" -"The descriptions below will include a description \"in simple terms\" of what " -"a pattern does for illustration purposes (credits to Raymond Hettinger for a " -"document that inspired most of the descriptions). Note that these descriptions " -"are purely for illustration purposes and **may not** reflect the underlying " -"implementation. Furthermore, they do not cover all valid forms." +"The descriptions below will include a description \"in simple terms\" of " +"what a pattern does for illustration purposes (credits to Raymond Hettinger " +"for a document that inspired most of the descriptions). Note that these " +"descriptions are purely for illustration purposes and **may not** reflect " +"the underlying implementation. Furthermore, they do not cover all valid " +"forms." msgstr "" "Las descripciones a continuación incluirán una descripción \"en términos " -"simples\" de lo que hace un patrón con fines ilustrativos (créditos a Raymond " -"Hettinger por un documento que inspiró la mayoría de las descripciones). Tenga " -"en cuenta que estas descripciones tienen únicamente fines ilustrativos y que " -"**may not** refleja la implementación subyacente. Además, no cubren todos los " -"formularios válidos." +"simples\" de lo que hace un patrón con fines ilustrativos (créditos a " +"Raymond Hettinger por un documento que inspiró la mayoría de las " +"descripciones). Tenga en cuenta que estas descripciones tienen únicamente " +"fines ilustrativos y que **may not** refleja la implementación subyacente. " +"Además, no cubren todos los formularios válidos." #: ../Doc/reference/compound_stmts.rst:721 msgid "OR Patterns" @@ -983,13 +1003,13 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:732 msgid "" "An OR pattern matches each of its subpatterns in turn to the subject value, " -"until one succeeds. The OR pattern is then considered successful. Otherwise, " -"if none of the subpatterns succeed, the OR pattern fails." +"until one succeeds. The OR pattern is then considered successful. " +"Otherwise, if none of the subpatterns succeed, the OR pattern fails." msgstr "" -"Un patrón OR hace coincidir cada uno de sus subpatrones a su vez con el valor " -"del sujeto, hasta que uno tiene éxito. Entonces, el patrón OR se considera " -"exitoso. De lo contrario, si ninguno de los subpatrones tiene éxito, el patrón " -"OR falla." +"Un patrón OR hace coincidir cada uno de sus subpatrones a su vez con el " +"valor del sujeto, hasta que uno tiene éxito. Entonces, el patrón OR se " +"considera exitoso. De lo contrario, si ninguno de los subpatrones tiene " +"éxito, el patrón OR falla." #: ../Doc/reference/compound_stmts.rst:736 msgid "" @@ -998,8 +1018,8 @@ msgid "" "otherwise." msgstr "" "En términos simples, ``P1 | P2 | ...`` intentará igualar ``P1``, si falla, " -"intentará igualar ``P2``, teniendo éxito inmediatamente si alguno tiene éxito, " -"fallando en caso contrario." +"intentará igualar ``P2``, teniendo éxito inmediatamente si alguno tiene " +"éxito, fallando en caso contrario." #: ../Doc/reference/compound_stmts.rst:742 msgid "AS Patterns" @@ -1046,23 +1066,24 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:776 msgid "" "The rule ``strings`` and the token ``NUMBER`` are defined in the :doc:" -"`standard Python grammar <./grammar>`. Triple-quoted strings are supported. " -"Raw strings and byte strings are supported. :ref:`f-strings` are not " -"supported." +"`standard Python grammar <./grammar>`. Triple-quoted strings are " +"supported. Raw strings and byte strings are supported. :ref:`f-strings` " +"are not supported." msgstr "" -"La regla ``strings`` y el token ``NUMBER`` se definen en :doc:`standard Python " -"grammar <./grammar>`. Se admiten cadenas entre comillas triples. Se admiten " -"cadenas sin formato y cadenas de bytes. :ref:`f-strings` no es compatible." +"La regla ``strings`` y el token ``NUMBER`` se definen en :doc:`standard " +"Python grammar <./grammar>`. Se admiten cadenas entre comillas triples. Se " +"admiten cadenas sin formato y cadenas de bytes. :ref:`f-strings` no es " +"compatible." #: ../Doc/reference/compound_stmts.rst:781 msgid "" "The forms ``signed_number '+' NUMBER`` and ``signed_number '-' NUMBER`` are " -"for expressing :ref:`complex numbers `; they require a real number " -"on the left and an imaginary number on the right. E.g. ``3 + 4j``." +"for expressing :ref:`complex numbers `; they require a real " +"number on the left and an imaginary number on the right. E.g. ``3 + 4j``." msgstr "" "Los formularios ``signed_number '+' NUMBER`` y ``signed_number '-' NUMBER`` " -"son para expresar :ref:`complex numbers `; requieren un número real " -"a la izquierda y un número imaginario a la derecha. P.ej. ``3 + 4j``." +"son para expresar :ref:`complex numbers `; requieren un número " +"real a la izquierda y un número imaginario a la derecha. P.ej. ``3 + 4j``." #: ../Doc/reference/compound_stmts.rst:785 msgid "" @@ -1080,7 +1101,8 @@ msgstr "Capturar patrones" #: ../Doc/reference/compound_stmts.rst:793 msgid "A capture pattern binds the subject value to a name. Syntax:" -msgstr "Un patrón de captura vincula el valor del sujeto a un nombre. Sintaxis:" +msgstr "" +"Un patrón de captura vincula el valor del sujeto a un nombre. Sintaxis:" #: ../Doc/reference/compound_stmts.rst:799 msgid "" @@ -1092,11 +1114,12 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:802 msgid "" -"In a given pattern, a given name can only be bound once. E.g. ``case x, x: ..." -"`` is invalid while ``case [x] | x: ...`` is allowed." +"In a given pattern, a given name can only be bound once. E.g. ``case x, " +"x: ...`` is invalid while ``case [x] | x: ...`` is allowed." msgstr "" -"En un patrón dado, un nombre dado solo se puede vincular una vez. P.ej. ``case " -"x, x: ...`` no es válido mientras ``case [x] | x: ...`` está permitido." +"En un patrón dado, un nombre dado solo se puede vincular una vez. P.ej. " +"``case x, x: ...`` no es válido mientras ``case [x] | x: ...`` está " +"permitido." #: ../Doc/reference/compound_stmts.rst:805 msgid "" @@ -1106,10 +1129,10 @@ msgid "" "there's an applicable :keyword:`global` or :keyword:`nonlocal` statement." msgstr "" "Los patrones de captura siempre tienen éxito. El enlace sigue las reglas de " -"alcance establecidas por el operador de expresión de asignación en :pep:`572`; " -"el nombre se convierte en una variable local en el alcance de la función " -"contenedora más cercana, a menos que haya una declaración :keyword:`global` o :" -"keyword:`nonlocal` aplicable." +"alcance establecidas por el operador de expresión de asignación en :pep:" +"`572`; el nombre se convierte en una variable local en el alcance de la " +"función contenedora más cercana, a menos que haya una declaración :keyword:" +"`global` o :keyword:`nonlocal` aplicable." #: ../Doc/reference/compound_stmts.rst:810 msgid "" @@ -1134,13 +1157,13 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:823 msgid "" "``_`` is a :ref:`soft keyword ` within any pattern, but only " -"within patterns. It is an identifier, as usual, even within ``match`` subject " -"expressions, ``guard``\\ s, and ``case`` blocks." +"within patterns. It is an identifier, as usual, even within ``match`` " +"subject expressions, ``guard``\\ s, and ``case`` blocks." msgstr "" "``_`` es un :ref:`soft keyword ` dentro de cualquier patrón, " -"pero solo dentro de patrones. Es un identificador, como de costumbre, incluso " -"dentro de las expresiones de sujeto ``match``, ``guard`` \\ sy bloques " -"``case``." +"pero solo dentro de patrones. Es un identificador, como de costumbre, " +"incluso dentro de las expresiones de sujeto ``match``, ``guard`` \\ sy " +"bloques ``case``." #: ../Doc/reference/compound_stmts.rst:827 msgid "In simple terms, ``_`` will always succeed." @@ -1162,29 +1185,29 @@ msgid "" msgstr "" "El nombre con puntos en el patrón se busca usando el estándar Python :ref:" "`name resolution rules `. El patrón tiene éxito si el valor " -"encontrado se compara con el valor del sujeto (usando el operador de igualdad " -"``==``)." +"encontrado se compara con el valor del sujeto (usando el operador de " +"igualdad ``==``)." #: ../Doc/reference/compound_stmts.rst:847 msgid "" "In simple terms ``NAME1.NAME2`` will succeed only if `` == NAME1." "NAME2``" msgstr "" -"En términos simples, ``NAME1.NAME2`` solo tendrá éxito si `` == NAME1." -"NAME2``" +"En términos simples, ``NAME1.NAME2`` solo tendrá éxito si `` == " +"NAME1.NAME2``" #: ../Doc/reference/compound_stmts.rst:851 msgid "" "If the same value occurs multiple times in the same match statement, the " "interpreter may cache the first value found and reuse it rather than repeat " -"the same lookup. This cache is strictly tied to a given execution of a given " -"match statement." +"the same lookup. This cache is strictly tied to a given execution of a " +"given match statement." msgstr "" -"Si el mismo valor ocurre varias veces en la misma declaración de coincidencia, " -"el intérprete puede almacenar en caché el primer valor encontrado y " -"reutilizarlo en lugar de repetir la misma búsqueda. Este caché está " -"estrictamente vinculado a una ejecución determinada de una declaración de " -"coincidencia determinada." +"Si el mismo valor ocurre varias veces en la misma declaración de " +"coincidencia, el intérprete puede almacenar en caché el primer valor " +"encontrado y reutilizarlo en lugar de repetir la misma búsqueda. Este caché " +"está estrictamente vinculado a una ejecución determinada de una declaración " +"de coincidencia determinada." #: ../Doc/reference/compound_stmts.rst:859 msgid "Group Patterns" @@ -1195,8 +1218,8 @@ msgid "" "A group pattern allows users to add parentheses around patterns to emphasize " "the intended grouping. Otherwise, it has no additional syntax. Syntax:" msgstr "" -"Un patrón de grupo permite a los usuarios agregar paréntesis alrededor de los " -"patrones para enfatizar la agrupación deseada. De lo contrario, no tiene " +"Un patrón de grupo permite a los usuarios agregar paréntesis alrededor de " +"los patrones para enfatizar la agrupación deseada. De lo contrario, no tiene " "sintaxis adicional. Sintaxis:" #: ../Doc/reference/compound_stmts.rst:868 @@ -1209,12 +1232,12 @@ msgstr "Patrones de secuencia" #: ../Doc/reference/compound_stmts.rst:875 msgid "" -"A sequence pattern contains several subpatterns to be matched against sequence " -"elements. The syntax is similar to the unpacking of a list or tuple." +"A sequence pattern contains several subpatterns to be matched against " +"sequence elements. The syntax is similar to the unpacking of a list or tuple." msgstr "" "Un patrón de secuencia contiene varios subpatrones para hacer coincidir con " -"elementos de secuencia. La sintaxis es similar al desempaquetado de una lista " -"o tupla." +"elementos de secuencia. La sintaxis es similar al desempaquetado de una " +"lista o tupla." #: ../Doc/reference/compound_stmts.rst:886 msgid "" @@ -1226,26 +1249,27 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:890 msgid "" -"A single pattern enclosed in parentheses without a trailing comma (e.g. ``(3 | " -"4)``) is a :ref:`group pattern `. While a single pattern " +"A single pattern enclosed in parentheses without a trailing comma (e.g. ``(3 " +"| 4)``) is a :ref:`group pattern `. While a single pattern " "enclosed in square brackets (e.g. ``[3 | 4]``) is still a sequence pattern." msgstr "" "Un solo patrón encerrado entre paréntesis sin una coma final (por ejemplo, " -"``(3 | 4)``) es un :ref:`group pattern `. Mientras que un solo " -"patrón encerrado entre corchetes (por ejemplo, ``[3 | 4]``) sigue siendo un " -"patrón de secuencia." +"``(3 | 4)``) es un :ref:`group pattern `. Mientras que un " +"solo patrón encerrado entre corchetes (por ejemplo, ``[3 | 4]``) sigue " +"siendo un patrón de secuencia." #: ../Doc/reference/compound_stmts.rst:895 msgid "" -"At most one star subpattern may be in a sequence pattern. The star subpattern " -"may occur in any position. If no star subpattern is present, the sequence " -"pattern is a fixed-length sequence pattern; otherwise it is a variable-length " -"sequence pattern." +"At most one star subpattern may be in a sequence pattern. The star " +"subpattern may occur in any position. If no star subpattern is present, the " +"sequence pattern is a fixed-length sequence pattern; otherwise it is a " +"variable-length sequence pattern." msgstr "" -"A lo sumo, un subpatrón de estrella puede estar en un patrón de secuencia. El " -"subpatrón de estrella puede ocurrir en cualquier posición. Si no hay ningún " -"subpatrón de estrella, el patrón de secuencia es un patrón de secuencia de " -"longitud fija; de lo contrario, es un patrón de secuencia de longitud variable." +"A lo sumo, un subpatrón de estrella puede estar en un patrón de secuencia. " +"El subpatrón de estrella puede ocurrir en cualquier posición. Si no hay " +"ningún subpatrón de estrella, el patrón de secuencia es un patrón de " +"secuencia de longitud fija; de lo contrario, es un patrón de secuencia de " +"longitud variable." #: ../Doc/reference/compound_stmts.rst:900 msgid "" @@ -1256,17 +1280,19 @@ msgstr "" "con un valor de sujeto:" #: ../Doc/reference/compound_stmts.rst:903 -msgid "If the subject value is not a sequence [#]_, the sequence pattern fails." +msgid "" +"If the subject value is not a sequence [#]_, the sequence pattern fails." msgstr "" -"Si el valor del sujeto no es una secuencia [#] _, el patrón de secuencia falla." +"Si el valor del sujeto no es una secuencia [#] _, el patrón de secuencia " +"falla." #: ../Doc/reference/compound_stmts.rst:906 msgid "" -"If the subject value is an instance of ``str``, ``bytes`` or ``bytearray`` the " -"sequence pattern fails." +"If the subject value is an instance of ``str``, ``bytes`` or ``bytearray`` " +"the sequence pattern fails." msgstr "" -"Si el valor del sujeto es una instancia de ``str``, ``bytes`` o ``bytearray``, " -"el patrón de secuencia falla." +"Si el valor del sujeto es una instancia de ``str``, ``bytes`` o " +"``bytearray``, el patrón de secuencia falla." #: ../Doc/reference/compound_stmts.rst:909 msgid "" @@ -1292,8 +1318,8 @@ msgstr "" msgid "" "Subpatterns in the sequence pattern are matched to their corresponding items " "in the subject sequence from left to right. Matching stops as soon as a " -"subpattern fails. If all subpatterns succeed in matching their corresponding " -"item, the sequence pattern succeeds." +"subpattern fails. If all subpatterns succeed in matching their " +"corresponding item, the sequence pattern succeeds." msgstr "" "Los subpatrones del patrón de secuencia se hacen coincidir con sus elementos " "correspondientes en la secuencia del sujeto de izquierda a derecha. El " @@ -1328,36 +1354,37 @@ msgid "" "non-star subpatterns following the star subpattern." msgstr "" "Si el paso anterior tiene éxito, el subpatrón en estrella coincide con una " -"lista formada por los elementos restantes del sujeto, excluyendo los elementos " -"restantes correspondientes a los subpatrones que no son en estrella que siguen " -"el subpatrón en estrella." +"lista formada por los elementos restantes del sujeto, excluyendo los " +"elementos restantes correspondientes a los subpatrones que no son en " +"estrella que siguen el subpatrón en estrella." #: ../Doc/reference/compound_stmts.rst:934 msgid "" "Remaining non-star subpatterns are matched to their corresponding subject " "items, as for a fixed-length sequence." msgstr "" -"Los subpatrones restantes que no son estrellas se emparejan con sus elementos " -"temáticos correspondientes, como para una secuencia de longitud fija." +"Los subpatrones restantes que no son estrellas se emparejan con sus " +"elementos temáticos correspondientes, como para una secuencia de longitud " +"fija." #: ../Doc/reference/compound_stmts.rst:937 msgid "" -"The length of the subject sequence is obtained via :func:`len` (i.e. via the :" -"meth:`__len__` protocol). This length may be cached by the interpreter in a " -"similar manner as :ref:`value patterns `." +"The length of the subject sequence is obtained via :func:`len` (i.e. via " +"the :meth:`__len__` protocol). This length may be cached by the interpreter " +"in a similar manner as :ref:`value patterns `." msgstr "" -"La longitud de la secuencia del sujeto se obtiene a través de :func:`len` (es " -"decir, a través del protocolo :meth:`__len__`). El intérprete puede almacenar " -"en caché esta longitud de manera similar a :ref:`value patterns `." +"La longitud de la secuencia del sujeto se obtiene a través de :func:`len` " +"(es decir, a través del protocolo :meth:`__len__`). El intérprete puede " +"almacenar en caché esta longitud de manera similar a :ref:`value patterns " +"`." #: ../Doc/reference/compound_stmts.rst:943 msgid "" "In simple terms ``[P1, P2, P3,`` ... ``, P]`` matches only if all the " "following happens:" msgstr "" -"En términos simples, ``[P1, P2, P3,`` ... ``, P]`` solo coincide si ocurre " -"todo lo siguiente:" +"En términos simples, ``[P1, P2, P3,`` ... ``, P]`` solo coincide si " +"ocurre todo lo siguiente:" #: ../Doc/reference/compound_stmts.rst:946 msgid "check ```` is a sequence" @@ -1399,29 +1426,30 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:968 msgid "" -"At most one double star pattern may be in a mapping pattern. The double star " -"pattern must be the last subpattern in the mapping pattern." +"At most one double star pattern may be in a mapping pattern. The double " +"star pattern must be the last subpattern in the mapping pattern." msgstr "" -"Como máximo, un patrón de estrella doble puede estar en un patrón de mapeo. El " -"patrón de estrella doble debe ser el último subpatrón del patrón de mapeo." +"Como máximo, un patrón de estrella doble puede estar en un patrón de mapeo. " +"El patrón de estrella doble debe ser el último subpatrón del patrón de mapeo." #: ../Doc/reference/compound_stmts.rst:971 msgid "" -"Duplicate keys in mapping patterns are disallowed. Duplicate literal keys will " -"raise a :exc:`SyntaxError`. Two keys that otherwise have the same value will " -"raise a :exc:`ValueError` at runtime." +"Duplicate keys in mapping patterns are disallowed. Duplicate literal keys " +"will raise a :exc:`SyntaxError`. Two keys that otherwise have the same value " +"will raise a :exc:`ValueError` at runtime." msgstr "" "No se permiten claves duplicadas en patrones de mapeo. Las claves literales " "duplicadas generarán un :exc:`SyntaxError`. Dos claves que de otro modo " -"tendrían el mismo valor generarán un :exc:`ValueError` en tiempo de ejecución." +"tendrían el mismo valor generarán un :exc:`ValueError` en tiempo de " +"ejecución." #: ../Doc/reference/compound_stmts.rst:975 msgid "" "The following is the logical flow for matching a mapping pattern against a " "subject value:" msgstr "" -"El siguiente es el flujo lógico para hacer coincidir un patrón de mapeo con un " -"valor de sujeto:" +"El siguiente es el flujo lógico para hacer coincidir un patrón de mapeo con " +"un valor de sujeto:" #: ../Doc/reference/compound_stmts.rst:978 msgid "If the subject value is not a mapping [#]_,the mapping pattern fails." @@ -1435,9 +1463,9 @@ msgid "" "and the pattern for each key matches the corresponding item of the subject " "mapping, the mapping pattern succeeds." msgstr "" -"Si cada clave dada en el patrón de mapeo está presente en el mapeo del sujeto, " -"y el patrón para cada clave coincide con el elemento correspondiente del mapeo " -"del sujeto, el patrón de mapeo tiene éxito." +"Si cada clave dada en el patrón de mapeo está presente en el mapeo del " +"sujeto, y el patrón para cada clave coincide con el elemento correspondiente " +"del mapeo del sujeto, el patrón de mapeo tiene éxito." #: ../Doc/reference/compound_stmts.rst:984 msgid "" @@ -1445,9 +1473,9 @@ msgid "" "considered invalid. A :exc:`SyntaxError` is raised for duplicate literal " "values; or a :exc:`ValueError` for named keys of the same value." msgstr "" -"Si se detectan claves duplicadas en el patrón de mapeo, el patrón se considera " -"inválido. Se genera un :exc:`SyntaxError` para valores literales duplicados; o " -"un :exc:`ValueError` para claves con nombre del mismo valor." +"Si se detectan claves duplicadas en el patrón de mapeo, el patrón se " +"considera inválido. Se genera un :exc:`SyntaxError` para valores literales " +"duplicados; o un :exc:`ValueError` para claves con nombre del mismo valor." #: ../Doc/reference/compound_stmts.rst:988 msgid "" @@ -1456,10 +1484,10 @@ msgid "" "in the mapping, and not created on-the-fly via :meth:`__missing__` or :meth:" "`__getitem__`." msgstr "" -"Los pares clave-valor se hacen coincidir utilizando la forma de dos argumentos " -"del método ``get()`` del sujeto de mapeo. Los pares clave-valor coincidentes " -"ya deben estar presentes en la asignación y no deben crearse sobre la marcha a " -"través de :meth:`__missing__` o :meth:`__getitem__`." +"Los pares clave-valor se hacen coincidir utilizando la forma de dos " +"argumentos del método ``get()`` del sujeto de mapeo. Los pares clave-valor " +"coincidentes ya deben estar presentes en la asignación y no deben crearse " +"sobre la marcha a través de :meth:`__missing__` o :meth:`__getitem__`." #: ../Doc/reference/compound_stmts.rst:993 msgid "" @@ -1506,21 +1534,21 @@ msgid "" "The following is the logical flow for matching a class pattern against a " "subject value:" msgstr "" -"El siguiente es el flujo lógico para hacer coincidir un patrón de clase con un " -"valor de materia:" +"El siguiente es el flujo lógico para hacer coincidir un patrón de clase con " +"un valor de materia:" #: ../Doc/reference/compound_stmts.rst:1023 msgid "" "If ``name_or_attr`` is not an instance of the builtin :class:`type` , raise :" "exc:`TypeError`." msgstr "" -"Si ``name_or_attr`` no es una instancia del :class:`type` incorporado, genere :" -"exc:`TypeError`." +"Si ``name_or_attr`` no es una instancia del :class:`type` incorporado, " +"genere :exc:`TypeError`." #: ../Doc/reference/compound_stmts.rst:1026 msgid "" -"If the subject value is not an instance of ``name_or_attr`` (tested via :func:" -"`isinstance`), the class pattern fails." +"If the subject value is not an instance of ``name_or_attr`` (tested via :" +"func:`isinstance`), the class pattern fails." msgstr "" "Si el valor del sujeto no es una instancia de ``name_or_attr`` (probado a " "través de :func:`isinstance`), el patrón de clase falla." @@ -1528,8 +1556,8 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:1029 msgid "" "If no pattern arguments are present, the pattern succeeds. Otherwise, the " -"subsequent steps depend on whether keyword or positional argument patterns are " -"present." +"subsequent steps depend on whether keyword or positional argument patterns " +"are present." msgstr "" "Si no hay argumentos de patrón, el patrón tiene éxito. De lo contrario, los " "pasos siguientes dependen de si están presentes patrones de argumentos de " @@ -1542,8 +1570,9 @@ msgid "" "keyword patterns also work as for other types." msgstr "" "Para varios tipos integrados (especificados a continuación), se acepta un " -"único subpatrón posicional que coincidirá con todo el tema; para estos tipos, " -"los patrones de palabras clave también funcionan como para otros tipos." +"único subpatrón posicional que coincidirá con todo el tema; para estos " +"tipos, los patrones de palabras clave también funcionan como para otros " +"tipos." #: ../Doc/reference/compound_stmts.rst:1037 msgid "" @@ -1588,17 +1617,19 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:1054 msgid "" -"If any positional patterns are present, they are converted to keyword patterns " -"using the :data:`~object.__match_args__` attribute on the class " +"If any positional patterns are present, they are converted to keyword " +"patterns using the :data:`~object.__match_args__` attribute on the class " "``name_or_attr`` before matching:" msgstr "" -"Si hay algún patrón posicional presente, se convierte en patrones de palabras " -"clave utilizando el atributo :data:`~object.__match_args__` en la clase " -"``name_or_attr`` antes de hacer coincidir:" +"Si hay algún patrón posicional presente, se convierte en patrones de " +"palabras clave utilizando el atributo :data:`~object.__match_args__` en la " +"clase ``name_or_attr`` antes de hacer coincidir:" #: ../Doc/reference/compound_stmts.rst:1058 -msgid "I. The equivalent of ``getattr(cls, \"__match_args__\", ())`` is called." -msgstr "I. Se llama el equivalente de ``getattr(cls, \"__match_args__\", ())``." +msgid "" +"I. The equivalent of ``getattr(cls, \"__match_args__\", ())`` is called." +msgstr "" +"I. Se llama el equivalente de ``getattr(cls, \"__match_args__\", ())``." #: ../Doc/reference/compound_stmts.rst:1060 msgid "If this raises an exception, the exception bubbles up." @@ -1623,8 +1654,8 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:1068 msgid "" "Otherwise, positional pattern ``i`` is converted to a keyword pattern using " -"``__match_args__[i]`` as the keyword. ``__match_args__[i]`` must be a string; " -"if not :exc:`TypeError` is raised." +"``__match_args__[i]`` as the keyword. ``__match_args__[i]`` must be a " +"string; if not :exc:`TypeError` is raised." msgstr "" "De lo contrario, el patrón posicional ``i`` se convierte en un patrón de " "palabra clave utilizando ``__match_args__[i]`` como palabra clave. " @@ -1639,22 +1670,24 @@ msgid ":ref:`class-pattern-matching`" msgstr ":ref:`class-pattern-matching`" #: ../Doc/reference/compound_stmts.rst:1077 -msgid "II. Once all positional patterns have been converted to keyword patterns," +msgid "" +"II. Once all positional patterns have been converted to keyword patterns," msgstr "" "II. Una vez que todos los patrones posicionales se hayan convertido en " "patrones de palabras clave," #: ../Doc/reference/compound_stmts.rst:1077 msgid "the match proceeds as if there were only keyword patterns." -msgstr "la coincidencia procede como si solo hubiera patrones de palabras clave." +msgstr "" +"la coincidencia procede como si solo hubiera patrones de palabras clave." #: ../Doc/reference/compound_stmts.rst:1079 msgid "" "For the following built-in types the handling of positional subpatterns is " "different:" msgstr "" -"Para los siguientes tipos integrados, el manejo de subpatrones posicionales es " -"diferente:" +"Para los siguientes tipos integrados, el manejo de subpatrones posicionales " +"es diferente:" #: ../Doc/reference/compound_stmts.rst:1082 msgid ":class:`bool`" @@ -1705,18 +1738,20 @@ msgstr ":class:`tuple`" #: ../Doc/reference/compound_stmts.rst:1094 msgid "" "These classes accept a single positional argument, and the pattern there is " -"matched against the whole object rather than an attribute. For example ``int(0|" -"1)`` matches the value ``0``, but not the values ``0.0`` or ``False``." +"matched against the whole object rather than an attribute. For example " +"``int(0|1)`` matches the value ``0``, but not the values ``0.0`` or " +"``False``." msgstr "" -"Estas clases aceptan un único argumento posicional y el patrón se compara con " -"el objeto completo en lugar de un atributo. Por ejemplo, ``int(0|1)`` coincide " -"con el valor ``0``, pero no con los valores ``0.0`` o ``False``." +"Estas clases aceptan un único argumento posicional y el patrón se compara " +"con el objeto completo en lugar de un atributo. Por ejemplo, ``int(0|1)`` " +"coincide con el valor ``0``, pero no con los valores ``0.0`` o ``False``." #: ../Doc/reference/compound_stmts.rst:1098 msgid "" "In simple terms ``CLS(P1, attr=P2)`` matches only if the following happens:" msgstr "" -"En términos simples, ``CLS(P1, attr=P2)`` solo coincide si ocurre lo siguiente:" +"En términos simples, ``CLS(P1, attr=P2)`` solo coincide si ocurre lo " +"siguiente:" #: ../Doc/reference/compound_stmts.rst:1100 msgid "``isinstance(, CLS)``" @@ -1751,31 +1786,31 @@ msgstr "Definiciones de funciones" #: ../Doc/reference/compound_stmts.rst:1135 msgid "" -"A function definition defines a user-defined function object (see section :ref:" -"`types`):" +"A function definition defines a user-defined function object (see section :" +"ref:`types`):" msgstr "" -"Una definición de función define una función objeto determinada por el usuario " -"(consulte la sección :ref:`types`):" +"Una definición de función define una función objeto determinada por el " +"usuario (consulte la sección :ref:`types`):" #: ../Doc/reference/compound_stmts.rst:1154 msgid "" "A function definition is an executable statement. Its execution binds the " "function name in the current local namespace to a function object (a wrapper " -"around the executable code for the function). This function object contains a " -"reference to the current global namespace as the global namespace to be used " -"when the function is called." +"around the executable code for the function). This function object contains " +"a reference to the current global namespace as the global namespace to be " +"used when the function is called." msgstr "" -"Una definición de función es una sentencia ejecutable. Su ejecución vincula el " -"nombre de la función en el espacio de nombres local actual a un objeto de " -"función (un contenedor alrededor del código ejecutable para la función). Este " -"objeto de función contiene una referencia al espacio de nombres global actual " -"como el espacio de nombres global que se utilizará cuando se llama a la " -"función." +"Una definición de función es una sentencia ejecutable. Su ejecución vincula " +"el nombre de la función en el espacio de nombres local actual a un objeto de " +"función (un contenedor alrededor del código ejecutable para la función). " +"Este objeto de función contiene una referencia al espacio de nombres global " +"actual como el espacio de nombres global que se utilizará cuando se llama a " +"la función." #: ../Doc/reference/compound_stmts.rst:1160 msgid "" -"The function definition does not execute the function body; this gets executed " -"only when the function is called. [#]_" +"The function definition does not execute the function body; this gets " +"executed only when the function is called. [#]_" msgstr "" "La definición de la función no ejecuta el cuerpo de la función; esto se " "ejecuta solo cuando se llama a la función. [#]_" @@ -1783,20 +1818,20 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:1166 msgid "" "A function definition may be wrapped by one or more :term:`decorator` " -"expressions. Decorator expressions are evaluated when the function is defined, " -"in the scope that contains the function definition. The result must be a " -"callable, which is invoked with the function object as the only argument. The " -"returned value is bound to the function name instead of the function object. " -"Multiple decorators are applied in nested fashion. For example, the following " -"code ::" -msgstr "" -"Una definición de función puede estar envuelta por una o más expresiones :term:" -"`decorator`. Las expresiones de decorador se evalúan cuando se define la " -"función, en el ámbito que contiene la definición de la función. El resultado " -"debe ser invocable, la cual se invoca con el objeto de función como único " -"argumento. El valor retornado está vinculado al nombre de la función en lugar " -"del objeto de la función. Se aplican múltiples decoradores de forma anidada. " -"Por ejemplo, el siguiente código ::" +"expressions. Decorator expressions are evaluated when the function is " +"defined, in the scope that contains the function definition. The result " +"must be a callable, which is invoked with the function object as the only " +"argument. The returned value is bound to the function name instead of the " +"function object. Multiple decorators are applied in nested fashion. For " +"example, the following code ::" +msgstr "" +"Una definición de función puede estar envuelta por una o más expresiones :" +"term:`decorator`. Las expresiones de decorador se evalúan cuando se define " +"la función, en el ámbito que contiene la definición de la función. El " +"resultado debe ser invocable, la cual se invoca con el objeto de función " +"como único argumento. El valor retornado está vinculado al nombre de la " +"función en lugar del objeto de la función. Se aplican múltiples decoradores " +"de forma anidada. Por ejemplo, el siguiente código ::" #: ../Doc/reference/compound_stmts.rst:1177 #: ../Doc/reference/compound_stmts.rst:1354 @@ -1814,7 +1849,8 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:1184 msgid "" "Functions may be decorated with any valid :token:`assignment_expression`. " -"Previously, the grammar was much more restrictive; see :pep:`614` for details." +"Previously, the grammar was much more restrictive; see :pep:`614` for " +"details." msgstr "" "Las funciones se pueden decorar con cualquier token válido :token:" "`assignment_expression`. Anteriormente, la gramática era mucho más " @@ -1826,67 +1862,70 @@ msgid "" "``=`` *expression*, the function is said to have \"default parameter values." "\" For a parameter with a default value, the corresponding :term:`argument` " "may be omitted from a call, in which case the parameter's default value is " -"substituted. If a parameter has a default value, all following parameters up " -"until the \"``*``\" must also have a default value --- this is a syntactic " -"restriction that is not expressed by the grammar." +"substituted. If a parameter has a default value, all following parameters " +"up until the \"``*``\" must also have a default value --- this is a " +"syntactic restriction that is not expressed by the grammar." msgstr "" "Cuando uno o más :term:`parameters ` tienen la forma *parameter* " "``=`` *expression*, se dice que la función tiene \"valores de parámetros " "predeterminados\". Para un parámetro con un valor predeterminado, el " "correspondiente :term:`argument` puede omitirse desde una llamada, en cuyo " -"caso se sustituye el valor predeterminado del parámetro. Si un parámetro tiene " -"un valor predeterminado, todos los parámetros siguientes hasta el \"``*``\" " -"también deben tener un valor predeterminado --- esta es una restricción " -"sintáctica que la gramática no expresa." +"caso se sustituye el valor predeterminado del parámetro. Si un parámetro " +"tiene un valor predeterminado, todos los parámetros siguientes hasta el " +"\"``*``\" también deben tener un valor predeterminado --- esta es una " +"restricción sintáctica que la gramática no expresa." #: ../Doc/reference/compound_stmts.rst:1202 msgid "" -"**Default parameter values are evaluated from left to right when the function " -"definition is executed.** This means that the expression is evaluated once, " -"when the function is defined, and that the same \"pre-computed\" value is used " -"for each call. This is especially important to understand when a default " -"parameter value is a mutable object, such as a list or a dictionary: if the " -"function modifies the object (e.g. by appending an item to a list), the " -"default parameter value is in effect modified. This is generally not what was " -"intended. A way around this is to use ``None`` as the default, and explicitly " -"test for it in the body of the function, e.g.::" +"**Default parameter values are evaluated from left to right when the " +"function definition is executed.** This means that the expression is " +"evaluated once, when the function is defined, and that the same \"pre-" +"computed\" value is used for each call. This is especially important to " +"understand when a default parameter value is a mutable object, such as a " +"list or a dictionary: if the function modifies the object (e.g. by appending " +"an item to a list), the default parameter value is in effect modified. This " +"is generally not what was intended. A way around this is to use ``None`` as " +"the default, and explicitly test for it in the body of the function, e.g.::" msgstr "" "**Los valores de los parámetros predeterminados se evalúan de izquierda a " -"derecha cuando se ejecuta la definición de la función.** Esto significa que la " -"expresión se evalúa una vez, cuando se define la función, y que se utiliza el " -"mismo valor \"precalculado\" para cada llamada . Esto es especialmente " -"importante para entender cuando un parámetro predeterminado es un objeto " -"mutable, como una lista o un diccionario: si la función modifica el objeto " -"(por ejemplo, al agregar un elemento a una lista), el valor predeterminado " -"está en efecto modificado. Esto generalmente no es lo que se pretendía. Una " -"forma de evitar esto es usar ``None`` como valor predeterminado y probarlo " -"explícitamente en el cuerpo de la función, por ejemplo::" +"derecha cuando se ejecuta la definición de la función.** Esto significa que " +"la expresión se evalúa una vez, cuando se define la función, y que se " +"utiliza el mismo valor \"precalculado\" para cada llamada . Esto es " +"especialmente importante para entender cuando un parámetro predeterminado es " +"un objeto mutable, como una lista o un diccionario: si la función modifica " +"el objeto (por ejemplo, al agregar un elemento a una lista), el valor " +"predeterminado está en efecto modificado. Esto generalmente no es lo que se " +"pretendía. Una forma de evitar esto es usar ``None`` como valor " +"predeterminado y probarlo explícitamente en el cuerpo de la función, por " +"ejemplo::" #: ../Doc/reference/compound_stmts.rst:1223 msgid "" -"Function call semantics are described in more detail in section :ref:`calls`. " -"A function call always assigns values to all parameters mentioned in the " -"parameter list, either from positional arguments, from keyword arguments, or " -"from default values. If the form \"``*identifier``\" is present, it is " -"initialized to a tuple receiving any excess positional parameters, defaulting " -"to the empty tuple. If the form \"``**identifier``\" is present, it is " -"initialized to a new ordered mapping receiving any excess keyword arguments, " -"defaulting to a new empty mapping of the same type. Parameters after \"``*``" -"\" or \"``*identifier``\" are keyword-only parameters and may only be passed " -"by keyword arguments. Parameters before \"``/``\" are positional-only " -"parameters and may only be passed by positional arguments." -msgstr "" -"La semántica de llamadas de función se describe con más detalle en la sección :" -"ref:`calls`. Una llamada a la función siempre asigna valores a todos los " -"parámetros mencionados en la lista de parámetros, ya sea desde argumentos de " -"posición, desde argumentos por palabra clave o desde valores predeterminados. " -"Si está presente la forma \"``*identifier``\", se inicializa en una tupla que " -"recibe cualquier parámetro posicional excedente, por defecto en la tupla " -"vacía. Si el formulario \"``**identifier``\" está presente, se inicializa a " -"una nueva asignación ordenada que recibe cualquier exceso de argumentos por " -"palabra clave, por defecto a una nueva asignación vacía del mismo tipo. Los " -"parámetros después de \"``*``\" o \"``*identifier``\" son parámetros solo por " -"palabra clave y solo pueden pasarse con argumentos de palabras claves usadas." +"Function call semantics are described in more detail in section :ref:" +"`calls`. A function call always assigns values to all parameters mentioned " +"in the parameter list, either from positional arguments, from keyword " +"arguments, or from default values. If the form \"``*identifier``\" is " +"present, it is initialized to a tuple receiving any excess positional " +"parameters, defaulting to the empty tuple. If the form \"``**identifier``\" " +"is present, it is initialized to a new ordered mapping receiving any excess " +"keyword arguments, defaulting to a new empty mapping of the same type. " +"Parameters after \"``*``\" or \"``*identifier``\" are keyword-only " +"parameters and may only be passed by keyword arguments. Parameters before " +"\"``/``\" are positional-only parameters and may only be passed by " +"positional arguments." +msgstr "" +"La semántica de llamadas de función se describe con más detalle en la " +"sección :ref:`calls`. Una llamada a la función siempre asigna valores a " +"todos los parámetros mencionados en la lista de parámetros, ya sea desde " +"argumentos de posición, desde argumentos por palabra clave o desde valores " +"predeterminados. Si está presente la forma \"``*identifier``\", se " +"inicializa en una tupla que recibe cualquier parámetro posicional excedente, " +"por defecto en la tupla vacía. Si el formulario \"``**identifier``\" está " +"presente, se inicializa a una nueva asignación ordenada que recibe cualquier " +"exceso de argumentos por palabra clave, por defecto a una nueva asignación " +"vacía del mismo tipo. Los parámetros después de \"``*``\" o \"``*identifier``" +"\" son parámetros solo por palabra clave y solo pueden pasarse con " +"argumentos de palabras claves usadas." #: ../Doc/reference/compound_stmts.rst:1235 msgid "" @@ -1900,67 +1939,68 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:1244 msgid "" "Parameters may have an :term:`annotation ` of the form " -"\"``: expression``\" following the parameter name. Any parameter may have an " -"annotation, even those of the form ``*identifier`` or ``**identifier``. " +"\"``: expression``\" following the parameter name. Any parameter may have " +"an annotation, even those of the form ``*identifier`` or ``**identifier``. " "Functions may have \"return\" annotation of the form \"``-> expression``\" " "after the parameter list. These annotations can be any valid Python " "expression. The presence of annotations does not change the semantics of a " -"function. The annotation values are available as values of a dictionary keyed " -"by the parameters' names in the :attr:`__annotations__` attribute of the " -"function object. If the ``annotations`` import from :mod:`__future__` is " -"used, annotations are preserved as strings at runtime which enables postponed " -"evaluation. Otherwise, they are evaluated when the function definition is " -"executed. In this case annotations may be evaluated in a different order than " -"they appear in the source code." +"function. The annotation values are available as values of a dictionary " +"keyed by the parameters' names in the :attr:`__annotations__` attribute of " +"the function object. If the ``annotations`` import from :mod:`__future__` " +"is used, annotations are preserved as strings at runtime which enables " +"postponed evaluation. Otherwise, they are evaluated when the function " +"definition is executed. In this case annotations may be evaluated in a " +"different order than they appear in the source code." msgstr "" "Los parámetros pueden tener :term:`annotation ` de la " "forma \"``: expression``\" que sigue al nombre del parámetro. Cualquier " -"parámetro puede tener una anotación, incluso las de la forma ``*identifier`` o " -"``** identifier``. Las funciones pueden tener una anotación \"return\" de la " -"forma \"``-> expression``\" después de la lista de parámetros. Estas " +"parámetro puede tener una anotación, incluso las de la forma ``*identifier`` " +"o ``** identifier``. Las funciones pueden tener una anotación \"return\" de " +"la forma \"``-> expression``\" después de la lista de parámetros. Estas " "anotaciones pueden ser cualquier expresión válida de Python. La presencia de " "anotaciones no cambia la semántica de una función. Los valores de anotación " "están disponibles como valores de un diccionario con los nombres de los " -"parámetros en el atributo :attr:`__annotations__` del objeto de la función. Si " -"se usa ``annotations`` importada desde :mod:`__future__`, las anotaciones se " -"conservan como cadenas de caracteres en tiempo de ejecución que permiten la " -"evaluación pospuesta. De lo contrario, se evalúan cuando se ejecuta la " -"definición de la función. En este caso, las anotaciones pueden evaluarse en un " -"orden diferente al que aparecen en el código fuente." +"parámetros en el atributo :attr:`__annotations__` del objeto de la función. " +"Si se usa ``annotations`` importada desde :mod:`__future__`, las anotaciones " +"se conservan como cadenas de caracteres en tiempo de ejecución que permiten " +"la evaluación pospuesta. De lo contrario, se evalúan cuando se ejecuta la " +"definición de la función. En este caso, las anotaciones pueden evaluarse en " +"un orden diferente al que aparecen en el código fuente." #: ../Doc/reference/compound_stmts.rst:1259 msgid "" "It is also possible to create anonymous functions (functions not bound to a " "name), for immediate use in expressions. This uses lambda expressions, " -"described in section :ref:`lambda`. Note that the lambda expression is merely " -"a shorthand for a simplified function definition; a function defined in a \":" -"keyword:`def`\" statement can be passed around or assigned to another name " -"just like a function defined by a lambda expression. The \":keyword:`!def`\" " -"form is actually more powerful since it allows the execution of multiple " -"statements and annotations." +"described in section :ref:`lambda`. Note that the lambda expression is " +"merely a shorthand for a simplified function definition; a function defined " +"in a \":keyword:`def`\" statement can be passed around or assigned to " +"another name just like a function defined by a lambda expression. The \":" +"keyword:`!def`\" form is actually more powerful since it allows the " +"execution of multiple statements and annotations." msgstr "" "También es posible crear funciones anónimas (funciones no vinculadas a un " "nombre), para uso inmediato en expresiones. Utiliza expresiones lambda, " -"descritas en la sección :ref:`lambda`. Tenga en cuenta que la expresión lambda " -"es simplemente una abreviatura para una definición de función simplificada; " -"una función definida en una sentencia \":keyword:`def`\" puede pasarse o " -"asignarse a otro nombre al igual que una función definida por una expresión " -"lambda. La forma \":keyword:`!def`\" es en realidad más poderosa ya que " -"permite la ejecución de múltiples sentencias y anotaciones." +"descritas en la sección :ref:`lambda`. Tenga en cuenta que la expresión " +"lambda es simplemente una abreviatura para una definición de función " +"simplificada; una función definida en una sentencia \":keyword:`def`\" puede " +"pasarse o asignarse a otro nombre al igual que una función definida por una " +"expresión lambda. La forma \":keyword:`!def`\" es en realidad más poderosa " +"ya que permite la ejecución de múltiples sentencias y anotaciones." #: ../Doc/reference/compound_stmts.rst:1267 msgid "" "**Programmer's note:** Functions are first-class objects. A \"``def``\" " -"statement executed inside a function definition defines a local function that " -"can be returned or passed around. Free variables used in the nested function " -"can access the local variables of the function containing the def. See " -"section :ref:`naming` for details." +"statement executed inside a function definition defines a local function " +"that can be returned or passed around. Free variables used in the nested " +"function can access the local variables of the function containing the def. " +"See section :ref:`naming` for details." msgstr "" "**Nota del programador:** Las funciones son objetos de la primera-clase. Una " -"sentencia \"``def``\" ejecutada dentro de una definición de función define una " -"función local que se puede retornar o pasar. Las variables libres utilizadas " -"en la función anidada pueden acceder a las variables locales de la función que " -"contiene el def. Vea la sección :ref:`naming` para más detalles." +"sentencia \"``def``\" ejecutada dentro de una definición de función define " +"una función local que se puede retornar o pasar. Las variables libres " +"utilizadas en la función anidada pueden acceder a las variables locales de " +"la función que contiene el def. Vea la sección :ref:`naming` para más " +"detalles." #: ../Doc/reference/compound_stmts.rst:1276 msgid ":pep:`3107` - Function Annotations" @@ -1997,8 +2037,8 @@ msgstr ":pep:`563` - Evaluación pospuesta de anotaciones" #: ../Doc/reference/compound_stmts.rst:1286 msgid "" -"Support for forward references within annotations by preserving annotations in " -"a string form at runtime instead of eager evaluation." +"Support for forward references within annotations by preserving annotations " +"in a string form at runtime instead of eager evaluation." msgstr "" "Admite referencias directas dentro de las anotaciones conservando las " "anotaciones en forma de cadena de caracteres en tiempo de ejecución en lugar " @@ -2016,17 +2056,17 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:1315 msgid "" "A class definition is an executable statement. The inheritance list usually " -"gives a list of base classes (see :ref:`metaclasses` for more advanced uses), " -"so each item in the list should evaluate to a class object which allows " -"subclassing. Classes without an inheritance list inherit, by default, from " -"the base class :class:`object`; hence, ::" +"gives a list of base classes (see :ref:`metaclasses` for more advanced " +"uses), so each item in the list should evaluate to a class object which " +"allows subclassing. Classes without an inheritance list inherit, by " +"default, from the base class :class:`object`; hence, ::" msgstr "" "Una definición de clase es una sentencia ejecutable. La lista de herencia " -"generalmente proporciona una lista de clases base (consulte :ref:`metaclasses` " -"para usos más avanzados), por lo que cada elemento de la lista debe evaluar a " -"un objeto de clase que permita la subclasificación. Las clases sin una lista " -"de herencia heredan, por defecto, de la clase base :class:`object`; por lo " -"tanto, ::" +"generalmente proporciona una lista de clases base (consulte :ref:" +"`metaclasses` para usos más avanzados), por lo que cada elemento de la lista " +"debe evaluar a un objeto de clase que permita la subclasificación. Las " +"clases sin una lista de herencia heredan, por defecto, de la clase base :" +"class:`object`; por lo tanto, ::" #: ../Doc/reference/compound_stmts.rst:1324 msgid "is equivalent to ::" @@ -2037,8 +2077,8 @@ msgid "" "The class's suite is then executed in a new execution frame (see :ref:" "`naming`), using a newly created local namespace and the original global " "namespace. (Usually, the suite contains mostly function definitions.) When " -"the class's suite finishes execution, its execution frame is discarded but its " -"local namespace is saved. [#]_ A class object is then created using the " +"the class's suite finishes execution, its execution frame is discarded but " +"its local namespace is saved. [#]_ A class object is then created using the " "inheritance list for the base classes and the saved local namespace for the " "attribute dictionary. The class name is bound to this class object in the " "original local namespace." @@ -2046,24 +2086,24 @@ msgstr "" "La suite de la clase se ejecuta en un nuevo marco de ejecución (ver :ref:" "`naming`), usando un espacio de nombres local recién creado y el espacio de " "nombres global original. (Por lo general, el bloque contiene principalmente " -"definiciones de funciones). Cuando la suite de la clase finaliza la ejecución, " -"su marco de ejecución se descarta pero se guarda su espacio de nombres local. " -"[#]_ Luego se crea un objeto de clase utilizando la lista de herencia para las " -"clases base y el espacio de nombres local guardado para el diccionario de " -"atributos. El nombre de la clase está vinculado a este objeto de clase en el " -"espacio de nombres local original." +"definiciones de funciones). Cuando la suite de la clase finaliza la " +"ejecución, su marco de ejecución se descarta pero se guarda su espacio de " +"nombres local. [#]_ Luego se crea un objeto de clase utilizando la lista de " +"herencia para las clases base y el espacio de nombres local guardado para el " +"diccionario de atributos. El nombre de la clase está vinculado a este objeto " +"de clase en el espacio de nombres local original." #: ../Doc/reference/compound_stmts.rst:1338 msgid "" "The order in which attributes are defined in the class body is preserved in " -"the new class's ``__dict__``. Note that this is reliable only right after the " -"class is created and only for classes that were defined using the definition " -"syntax." +"the new class's ``__dict__``. Note that this is reliable only right after " +"the class is created and only for classes that were defined using the " +"definition syntax." msgstr "" -"El orden en que se definen los atributos en el cuerpo de la clase se conserva " -"en el ``__dict__`` de la nueva clase. Tenga en cuenta que esto es confiable " -"solo justo después de crear la clase y solo para las clases que se definieron " -"utilizando la sintaxis de definición." +"El orden en que se definen los atributos en el cuerpo de la clase se " +"conserva en el ``__dict__`` de la nueva clase. Tenga en cuenta que esto es " +"confiable solo justo después de crear la clase y solo para las clases que se " +"definieron utilizando la sintaxis de definición." #: ../Doc/reference/compound_stmts.rst:1343 msgid "" @@ -2084,14 +2124,15 @@ msgid "" "The evaluation rules for the decorator expressions are the same as for " "function decorators. The result is then bound to the class name." msgstr "" -"Las reglas de evaluación para las expresiones de decorador son las mismas que " -"para los decoradores de funciones. El resultado se vincula al nombre de la " -"clase." +"Las reglas de evaluación para las expresiones de decorador son las mismas " +"que para los decoradores de funciones. El resultado se vincula al nombre de " +"la clase." #: ../Doc/reference/compound_stmts.rst:1362 msgid "" "Classes may be decorated with any valid :token:`assignment_expression`. " -"Previously, the grammar was much more restrictive; see :pep:`614` for details." +"Previously, the grammar was much more restrictive; see :pep:`614` for " +"details." msgstr "" "Las clases se pueden decorar con cualquier token válido :token:" "`assignment_expression`. Anteriormente, la gramática era mucho más " @@ -2100,22 +2141,23 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:1367 msgid "" "**Programmer's note:** Variables defined in the class definition are class " -"attributes; they are shared by instances. Instance attributes can be set in a " -"method with ``self.name = value``. Both class and instance attributes are " +"attributes; they are shared by instances. Instance attributes can be set in " +"a method with ``self.name = value``. Both class and instance attributes are " "accessible through the notation \"``self.name``\", and an instance attribute " "hides a class attribute with the same name when accessed in this way. Class " -"attributes can be used as defaults for instance attributes, but using mutable " -"values there can lead to unexpected results. :ref:`Descriptors ` " -"can be used to create instance variables with different implementation details." +"attributes can be used as defaults for instance attributes, but using " +"mutable values there can lead to unexpected results. :ref:`Descriptors " +"` can be used to create instance variables with different " +"implementation details." msgstr "" "** Nota del programador: ** Las variables definidas en la definición de la " -"clase son atributos de clase; son compartidos por instancias. Los atributos de " -"instancia se pueden establecer en un método con ``self.name = value``. Se " +"clase son atributos de clase; son compartidos por instancias. Los atributos " +"de instancia se pueden establecer en un método con ``self.name = value``. Se " "puede acceder a los atributos de clase e instancia a través de la notación " -"\"``self.name``\", y un atributo de instancia oculta un atributo de clase con " -"el mismo nombre cuando se accede de esta manera. Los atributos de clase se " -"pueden usar como valores predeterminados para los atributos de instancia, pero " -"el uso de valores mutables puede generar resultados inesperados. :ref:" +"\"``self.name``\", y un atributo de instancia oculta un atributo de clase " +"con el mismo nombre cuando se accede de esta manera. Los atributos de clase " +"se pueden usar como valores predeterminados para los atributos de instancia, " +"pero el uso de valores mutables puede generar resultados inesperados. :ref:" "`Descriptors ` se puede usar para crear variables de instancia " "con diferentes detalles de implementación." @@ -2128,8 +2170,8 @@ msgid "" "The proposal that changed the declaration of metaclasses to the current " "syntax, and the semantics for how classes with metaclasses are constructed." msgstr "" -"La propuesta que cambió la declaración de metaclases a la sintaxis actual y la " -"semántica de cómo se construyen las clases con metaclases." +"La propuesta que cambió la declaración de metaclases a la sintaxis actual y " +"la semántica de cómo se construyen las clases con metaclases." #: ../Doc/reference/compound_stmts.rst:1385 msgid ":pep:`3129` - Class Decorators" @@ -2137,8 +2179,8 @@ msgstr ":pep:`3129` - Decoradores de clase" #: ../Doc/reference/compound_stmts.rst:1385 msgid "" -"The proposal that added class decorators. Function and method decorators were " -"introduced in :pep:`318`." +"The proposal that added class decorators. Function and method decorators " +"were introduced in :pep:`318`." msgstr "" "La propuesta que agregó decoradores de clase. Los decoradores de funciones y " "métodos se introdujeron en :pep:`318`." @@ -2155,7 +2197,8 @@ msgstr "Definición de la función corrutina" msgid "" "Execution of Python coroutines can be suspended and resumed at many points " "(see :term:`coroutine`). :keyword:`await` expressions, :keyword:`async for` " -"and :keyword:`async with` can only be used in the body of a coroutine function." +"and :keyword:`async with` can only be used in the body of a coroutine " +"function." msgstr "" "La ejecución de corrutinas de Python se puede suspender y reanudar en muchos " "puntos (consulte :term:`coroutine`). Las expresiones :keyword:`await`, :" @@ -2167,13 +2210,13 @@ msgid "" "Functions defined with ``async def`` syntax are always coroutine functions, " "even if they do not contain ``await`` or ``async`` keywords." msgstr "" -"Las funciones definidas con la sintaxis ``async def`` siempre son funciones de " -"corrutina, incluso si no contienen palabras claves ``await`` o ``async``." +"Las funciones definidas con la sintaxis ``async def`` siempre son funciones " +"de corrutina, incluso si no contienen palabras claves ``await`` o ``async``." #: ../Doc/reference/compound_stmts.rst:1417 msgid "" -"It is a :exc:`SyntaxError` to use a ``yield from`` expression inside the body " -"of a coroutine function." +"It is a :exc:`SyntaxError` to use a ``yield from`` expression inside the " +"body of a coroutine function." msgstr "" "Es un error del tipo :exc:`SyntaxError` usar una expresión ``yield from`` " "dentro del cuerpo de una función de corrutina." @@ -2184,8 +2227,8 @@ msgstr "Un ejemplo de una función corrutina::" #: ../Doc/reference/compound_stmts.rst:1426 msgid "" -"``await`` and ``async`` are now keywords; previously they were only treated as " -"such inside the body of a coroutine function." +"``await`` and ``async`` are now keywords; previously they were only treated " +"as such inside the body of a coroutine function." msgstr "" "``await`` y ``async`` ahora son palabras clave; anteriormente solo se los " "trataba como tales dentro del cuerpo de una función de rutina." @@ -2197,8 +2240,8 @@ msgstr "La sentencia :keyword:`!async for`" #: ../Doc/reference/compound_stmts.rst:1439 msgid "" "An :term:`asynchronous iterable` provides an ``__aiter__`` method that " -"directly returns an :term:`asynchronous iterator`, which can call asynchronous " -"code in its ``__anext__`` method." +"directly returns an :term:`asynchronous iterator`, which can call " +"asynchronous code in its ``__anext__`` method." msgstr "" "Un :term:`asynchronous iterable` proporciona un método ``__aiter__`` que " "retorna directamente un :term:`asynchronous iterator`, que puede llamar a " @@ -2222,11 +2265,11 @@ msgstr "Ver también :meth:`__aiter__` y :meth:`__anext__` para más detalles." #: ../Doc/reference/compound_stmts.rst:1471 msgid "" -"It is a :exc:`SyntaxError` to use an ``async for`` statement outside the body " -"of a coroutine function." +"It is a :exc:`SyntaxError` to use an ``async for`` statement outside the " +"body of a coroutine function." msgstr "" -"Es un error del tipo :exc:`SyntaxError` usar una sentencia ``async for`` fuera " -"del cuerpo de una función de corrutina." +"Es un error del tipo :exc:`SyntaxError` usar una sentencia ``async for`` " +"fuera del cuerpo de una función de corrutina." #: ../Doc/reference/compound_stmts.rst:1479 msgid "The :keyword:`!async with` statement" @@ -2246,8 +2289,8 @@ msgstr "Ver también :meth:`__aenter__` y :meth:`__aexit__` para más detalles." #: ../Doc/reference/compound_stmts.rst:1513 msgid "" -"It is a :exc:`SyntaxError` to use an ``async with`` statement outside the body " -"of a coroutine function." +"It is a :exc:`SyntaxError` to use an ``async with`` statement outside the " +"body of a coroutine function." msgstr "" "Es un error del tipo :exc:`SyntaxError` usar una sentencia ``async with`` " "fuera del cuerpo de una función de corrutina." @@ -2270,13 +2313,13 @@ msgstr "Notas al pie" #: ../Doc/reference/compound_stmts.rst:1525 msgid "" -"The exception is propagated to the invocation stack unless there is a :keyword:" -"`finally` clause which happens to raise another exception. That new exception " -"causes the old one to be lost." +"The exception is propagated to the invocation stack unless there is a :" +"keyword:`finally` clause which happens to raise another exception. That new " +"exception causes the old one to be lost." msgstr "" -"La excepción se propaga a la pila de invocación a menos que haya una cláusula :" -"keyword:`finally` que provoque otra excepción. Esa nueva excepción hace que se " -"pierda la anterior." +"La excepción se propaga a la pila de invocación a menos que haya una " +"cláusula :keyword:`finally` que provoque otra excepción. Esa nueva excepción " +"hace que se pierda la anterior." #: ../Doc/reference/compound_stmts.rst:1529 msgid "In pattern matching, a sequence is defined as one of the following:" @@ -2292,7 +2335,8 @@ msgstr "una clase que hereda de :class:`collections.abc.Sequence`" msgid "" "a Python class that has been registered as :class:`collections.abc.Sequence`" msgstr "" -"una clase de Python que se ha registrado como :class:`collections.abc.Sequence`" +"una clase de Python que se ha registrado como :class:`collections.abc." +"Sequence`" #: ../Doc/reference/compound_stmts.rst:1533 msgid "" @@ -2331,13 +2375,14 @@ msgid "" "Subject values of type ``str``, ``bytes``, and ``bytearray`` do not match " "sequence patterns." msgstr "" -"Los valores de sujeto de tipo ``str``, ``bytes`` y ``bytearray`` no coinciden " -"con los patrones de secuencia." +"Los valores de sujeto de tipo ``str``, ``bytes`` y ``bytearray`` no " +"coinciden con los patrones de secuencia." #: ../Doc/reference/compound_stmts.rst:1548 msgid "In pattern matching, a mapping is defined as one of the following:" msgstr "" -"En la coincidencia de patrones, un mapeo se define como uno de los siguientes:" +"En la coincidencia de patrones, un mapeo se define como uno de los " +"siguientes:" #: ../Doc/reference/compound_stmts.rst:1550 msgid "a class that inherits from :class:`collections.abc.Mapping`" @@ -2347,18 +2392,20 @@ msgstr "una clase que hereda de :class:`collections.abc.Mapping`" msgid "" "a Python class that has been registered as :class:`collections.abc.Mapping`" msgstr "" -"una clase de Python que se ha registrado como :class:`collections.abc.Mapping`" +"una clase de Python que se ha registrado como :class:`collections.abc." +"Mapping`" #: ../Doc/reference/compound_stmts.rst:1552 -msgid "a builtin class that has its (CPython) :data:`Py_TPFLAGS_MAPPING` bit set" +msgid "" +"a builtin class that has its (CPython) :data:`Py_TPFLAGS_MAPPING` bit set" msgstr "" "una clase incorporada que tiene su conjunto de bits (CPython) :data:" "`Py_TPFLAGS_MAPPING`" #: ../Doc/reference/compound_stmts.rst:1555 msgid "" -"The standard library classes :class:`dict` and :class:`types.MappingProxyType` " -"are mappings." +"The standard library classes :class:`dict` and :class:`types." +"MappingProxyType` are mappings." msgstr "" "Las clases de biblioteca estándar :class:`dict` y :class:`types." "MappingProxyType` son asignaciones." @@ -2370,8 +2417,8 @@ msgid "" "function's :term:`docstring`." msgstr "" "Una cadena de caracteres literal que aparece como la primera sentencia en el " -"cuerpo de la función se transforma en el atributo ``__doc__`` de la función y, " -"por lo tanto, en funciones :term:`docstring`." +"cuerpo de la función se transforma en el atributo ``__doc__`` de la función " +"y, por lo tanto, en funciones :term:`docstring`." #: ../Doc/reference/compound_stmts.rst:1562 msgid "" @@ -2384,15 +2431,15 @@ msgstr "" "``__doc__`` y, por lo tanto, de la clase :term:`docstring`." #~ msgid "" -#~ "Execution of Python coroutines can be suspended and resumed at many points " -#~ "(see :term:`coroutine`). Inside the body of a coroutine function, " +#~ "Execution of Python coroutines can be suspended and resumed at many " +#~ "points (see :term:`coroutine`). Inside the body of a coroutine function, " #~ "``await`` and ``async`` identifiers become reserved keywords; :keyword:" #~ "`await` expressions, :keyword:`async for` and :keyword:`async with` can " #~ "only be used in coroutine function bodies." #~ msgstr "" -#~ "La ejecución de las corrutinas de Python puede suspenderse y reanudarse en " -#~ "muchos puntos (ver :term:`coroutine`). Dentro del cuerpo de una función de " -#~ "corrutina, los identificadores ``await`` y ``async`` se convierten en " -#~ "palabras claves reservadas; las expresiones :keyword:`await`, :keyword:" -#~ "`async for` y :keyword:`async with` solo se puede usar en los cuerpos de " -#~ "funciones de corrutina." +#~ "La ejecución de las corrutinas de Python puede suspenderse y reanudarse " +#~ "en muchos puntos (ver :term:`coroutine`). Dentro del cuerpo de una " +#~ "función de corrutina, los identificadores ``await`` y ``async`` se " +#~ "convierten en palabras claves reservadas; las expresiones :keyword:" +#~ "`await`, :keyword:`async for` y :keyword:`async with` solo se puede usar " +#~ "en los cuerpos de funciones de corrutina." From b0e259a786043ffcb8e62acd548922cea8e30a62 Mon Sep 17 00:00:00 2001 From: "Carlos A. Crespo" Date: Thu, 6 Jan 2022 10:25:39 -0300 Subject: [PATCH 7/8] fix build --- reference/compound_stmts.po | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/reference/compound_stmts.po b/reference/compound_stmts.po index 68a60a2961..5306d41aa7 100644 --- a/reference/compound_stmts.po +++ b/reference/compound_stmts.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2021-10-16 21:42+0200\n" -"PO-Revision-Date: 2022-01-06 10:10-0300\n" +"PO-Revision-Date: 2022-01-06 10:25-0300\n" "Last-Translator: Carlos A. Crespo \n" "Language-Team: python-doc-es\n" "Language: es_AR\n" @@ -1110,7 +1110,7 @@ msgid "" "expresses). It is instead treated as a :token:`wildcard_pattern`." msgstr "" "Un solo guión bajo ``_`` no es un patrón de captura (esto es lo que expresa " -"``!'_'``). En cambio, se trata como un: token: `wildcard_pattern`." +"``!'_'``). En cambio, se trata como un :token:`wildcard_pattern`." #: ../Doc/reference/compound_stmts.rst:802 msgid "" @@ -1283,7 +1283,7 @@ msgstr "" msgid "" "If the subject value is not a sequence [#]_, the sequence pattern fails." msgstr "" -"Si el valor del sujeto no es una secuencia [#] _, el patrón de secuencia " +"Si el valor del sujeto no es una secuencia [#]_, el patrón de secuencia " "falla." #: ../Doc/reference/compound_stmts.rst:906 From f22077a2f4b1ff4f20ce7af6180f7a4b359d91d0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cristi=C3=A1n=20Maureira-Fredes?= Date: Sun, 9 Jan 2022 14:44:51 +0100 Subject: [PATCH 8/8] Apply suggestions from code review --- reference/compound_stmts.po | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/reference/compound_stmts.po b/reference/compound_stmts.po index 5306d41aa7..df77e89567 100644 --- a/reference/compound_stmts.po +++ b/reference/compound_stmts.po @@ -1023,7 +1023,7 @@ msgstr "" #: ../Doc/reference/compound_stmts.rst:742 msgid "AS Patterns" -msgstr "Como patrones" +msgstr "patrones AS" #: ../Doc/reference/compound_stmts.rst:744 msgid "" @@ -1640,7 +1640,7 @@ msgid "" "If the returned value is not a tuple, the conversion fails and :exc:" "`TypeError` is raised." msgstr "" -"Si el valor devuelto no es una tupla, la conversión falla y se genera :exc:" +"Si el valor retornado no es una tupla, la conversión falla y se genera :exc:" "`TypeError`." #: ../Doc/reference/compound_stmts.rst:1065