From a6ca60afa1c96a49fce2732ff8029e83546d695f Mon Sep 17 00:00:00 2001
From: Marco Richetta <marcorichetta@gmail.com>
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 <cmaureirafredes@gmail.com>\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 <soft-"
 "keywords>`."
 msgstr ""
+"Esta sección utiliza comillas simples para denotar las :ref:`palabras clave "
+"<soft-keywords>` 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 <soft-keywords>`."
 msgstr ""
+"Las palabras clave ``match`` y ``case`` son :ref:`palabras clave <soft-"
+"keywords>` 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 <typesseq-tuple>`."
 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 <typesseq-tuple>`."
 
 #: ../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 <marco.richetta@fluxit.com.ar>
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 <cmaureirafredes@gmail.com>\n"
+"PO-Revision-Date: 2021-12-20 22:05-0300\n"
+"Last-Translator: Marco Richetta <marcorichetta@gmail.com>\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 <marcorichetta@gmail.com>
Date: Mon, 3 Jan 2022 22:11:51 -0300
Subject: [PATCH 3/8] Apply suggestions from code review

Co-authored-by: Carlos A. Crespo <lvccrespo@gmail.com>
---
 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 "
-"<soft-keywords>` suaves."
+"suaves <soft-keywords>`."
 
 # Se utilizó valor de búsqueda para traducir *subject value* basándose en la traducción francesa *champ de recherche*.
 #: ../Doc/reference/compound_stmts.rst:542
@@ -706,8 +706,8 @@ msgstr ""
 msgid ""
 "The ``match`` and ``case`` keywords are :ref:`soft keywords <soft-keywords>`."
 msgstr ""
-"Las palabras clave ``match`` y ``case`` son :ref:`palabras clave <soft-"
-"keywords>` suaves."
+"Las palabras clave ``match`` y ``case`` son :ref:`palabras clave suaves <soft-"
+"keywords>`."
 
 #: ../Doc/reference/compound_stmts.rst:555
 #: ../Doc/reference/compound_stmts.rst:1109

From d4ee943e1c249174f9574f1a872d94e5d1b835df Mon Sep 17 00:00:00 2001
From: Marco Richetta <marco.richetta@fluxit.com.ar>
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 <soft-keywords>`."
 msgstr ""
-"Las palabras clave ``match`` y ``case`` son :ref:`palabras clave suaves <soft-"
-"keywords>`."
+"Las palabras clave ``match`` y ``case`` son :ref:`palabras clave suaves "
+"<soft-keywords>`."
 
 #: ../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" <lvccrespo@gmail.com>
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 <marcorichetta@gmail.com>\n"
-"Language: es_AR\n"
+"PO-Revision-Date: 2022-01-06 10:10-0300\n"
+"Last-Translator: Carlos A. Crespo <lvccrespo@gmail.com>\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 <soft-"
-"keywords>`."
+"This section uses single quotes to denote :ref:`soft keywords <soft-keywords>`."
 msgstr ""
 "Esta sección utiliza comillas simples para denotar las :ref:`palabras clave "
 "suaves <soft-keywords>`."
 
-# Se utilizó valor de búsqueda para traducir *subject value* basándose en la traducción francesa *champ de recherche*.
+# 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 <soft-keywords>`."
 msgstr ""
-"Las palabras clave ``match`` y ``case`` son :ref:`palabras clave suaves "
-"<soft-keywords>`."
+"Las palabras clave ``match`` y ``case`` son :ref:`palabras clave suaves <soft-"
+"keywords>`."
 
 #: ../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 <irrefutable_case>`, and "
 "each subpattern must bind the same set of names to avoid ambiguity."
 msgstr ""
+"Solo el subpatrón final puede ser :ref:`irrefutable <irrefutable_case>`, 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 = <subject>``."
 msgstr ""
+"En términos simples, ``P as NAME`` coincidirá con ``P`` y, en caso de éxito, "
+"establecerá ``NAME = <subject>``."
 
 #: ../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 <literals>` in Python.  "
 "Syntax:"
 msgstr ""
+"Un patrón literal corresponde a la mayoría de :ref:`literals <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 <imaginary>`; they require a real "
-"number on the left and an imaginary number on the right. E.g. ``3 + 4j``."
+"for expressing :ref:`complex numbers <imaginary>`; 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 <imaginary>`; 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 ``<subject> == "
+"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 = "
 "<subject>``."
 msgstr ""
+"En términos simples, ``NAME`` siempre tendrá éxito y establecerá ``NAME = "
+"<subject>``."
 
 #: ../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 <soft-keywords>` 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 <soft-keywords>` 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 <resolve_names>`.  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 <resolve_names>`. 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 ``<subject> == NAME1."
 "NAME2``"
 msgstr ""
+"En términos simples, ``NAME1.NAME2`` solo tendrá éxito si ``<subject> == 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 <group-patterns>`. While a single pattern "
+"A single pattern enclosed in parentheses without a trailing comma (e.g. ``(3 | "
+"4)``) is a :ref:`group pattern <group-patterns>`. 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 <group-patterns>`. 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 <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 <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 <value-"
+"patterns>`."
 
 #: ../Doc/reference/compound_stmts.rst:943
 msgid ""
 "In simple terms ``[P1, P2, P3,`` ... ``, P<N>]`` matches only if all the "
 "following happens:"
 msgstr ""
+"En términos simples, ``[P1, P2, P3,`` ... ``, P<N>]`` solo coincide si ocurre "
+"todo lo siguiente:"
 
 #: ../Doc/reference/compound_stmts.rst:946
 msgid "check ``<subject>`` is a sequence"
-msgstr ""
+msgstr "comprobar que ``<subject>`` es una secuencia"
 
 #: ../Doc/reference/compound_stmts.rst:947
 msgid "``len(subject) == <N>``"
-msgstr ""
+msgstr "``len(subject) == <N>``"
 
 #: ../Doc/reference/compound_stmts.rst:948
 msgid ""
 "``P1`` matches ``<subject>[0]`` (note that this match can also bind names)"
 msgstr ""
+"``P1`` coincide con ``<subject>[0]`` (tenga en cuenta que esta coincidencia "
+"también puede vincular nombres)"
 
 #: ../Doc/reference/compound_stmts.rst:949
 msgid ""
 "``P2`` matches ``<subject>[1]`` (note that this match can also bind names)"
 msgstr ""
+"``P2`` coincide con ``<subject>[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 ``<subject>`` is a mapping"
-msgstr ""
+msgstr "comprobar ``<subject>`` es un mapeo"
 
 #: ../Doc/reference/compound_stmts.rst:997
 msgid "``KEY1 in <subject>``"
-msgstr ""
+msgstr "``KEY1 in <subject>``"
 
 #: ../Doc/reference/compound_stmts.rst:998
 msgid "``P1`` matches ``<subject>[KEY1]``"
-msgstr ""
+msgstr "``P1`` coincide con ``<subject>[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(<subject>, CLS)``"
-msgstr ""
+msgstr "``isinstance(<subject>, 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(<subject>, \"attr\")``"
-msgstr ""
+msgstr "``hasattr(<subject>, \"attr\")``"
 
 #: ../Doc/reference/compound_stmts.rst:1104
 msgid "``P2`` matches ``<subject>.attr``"
-msgstr ""
+msgstr "``P2`` coincide con ``<subject>.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 <parameter>` 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 <function 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 <function 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 "
-"<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 <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 <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" <lvccrespo@gmail.com>
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 <soft-keywords>`."
+"This section uses single quotes to denote :ref:`soft keywords <soft-"
+"keywords>`."
 msgstr ""
 "Esta sección utiliza comillas simples para denotar las :ref:`palabras clave "
 "suaves <soft-keywords>`."
@@ -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 <soft-keywords>`."
 msgstr ""
-"Las palabras clave ``match`` y ``case`` son :ref:`palabras clave suaves <soft-"
-"keywords>`."
+"Las palabras clave ``match`` y ``case`` son :ref:`palabras clave suaves "
+"<soft-keywords>`."
 
 #: ../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 <imaginary>`; they require a real number "
-"on the left and an imaginary number on the right. E.g. ``3 + 4j``."
+"for expressing :ref:`complex numbers <imaginary>`; 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 <imaginary>`; 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 <imaginary>`; 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 <soft-keywords>` 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 <soft-keywords>` 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 <resolve_names>`. 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 ``<subject> == NAME1."
 "NAME2``"
 msgstr ""
-"En términos simples, ``NAME1.NAME2`` solo tendrá éxito si ``<subject> == NAME1."
-"NAME2``"
+"En términos simples, ``NAME1.NAME2`` solo tendrá éxito si ``<subject> == "
+"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 <group-patterns>`. While a single pattern "
+"A single pattern enclosed in parentheses without a trailing comma (e.g. ``(3 "
+"| 4)``) is a :ref:`group pattern <group-patterns>`. 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 <group-patterns>`. 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 <group-patterns>`. 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 <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 <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 <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 "
+"<value-patterns>`."
 
 #: ../Doc/reference/compound_stmts.rst:943
 msgid ""
 "In simple terms ``[P1, P2, P3,`` ... ``, P<N>]`` matches only if all the "
 "following happens:"
 msgstr ""
-"En términos simples, ``[P1, P2, P3,`` ... ``, P<N>]`` solo coincide si ocurre "
-"todo lo siguiente:"
+"En términos simples, ``[P1, P2, P3,`` ... ``, P<N>]`` solo coincide si "
+"ocurre todo lo siguiente:"
 
 #: ../Doc/reference/compound_stmts.rst:946
 msgid "check ``<subject>`` 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(<subject>, 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 <parameter>` 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 <function 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 <function 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 <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 "
+"<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 <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" <lvccrespo@gmail.com>
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 <lvccrespo@gmail.com>\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?=
 <cmaureir@users.noreply.github.com>
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

<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>
<html xmlns='http://www.w3.org/1999/xhtml'>
<head>
<title>pFad - Phonifier reborn</title>
<meta http-equiv='Content-Type' content='text/html; charset=utf-8' />
</head>
<body>
<h1>Pfad - The Proxy pFad of &#169; 2024 Garber Painting. All rights reserved.</h1>


<!-- Disclaimer -->
<p>Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.</p>
<br>
<p>Alternative Proxies:</p><p><a href="http://rainy.clevelandohioweatherforecast.com/php-proxy/index.php?q=https://patch-diff.githubusercontent.com/raw/python/python-docs-es/pull/1646.patch" target="_blank">Alternative Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/index.php?u=https://patch-diff.githubusercontent.com/raw/python/python-docs-es/pull/1646.patch" target="_blank">pFad Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/v3index.php?u=https://patch-diff.githubusercontent.com/raw/python/python-docs-es/pull/1646.patch" target="_blank">pFad v3 Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/v4index.php?u=https://patch-diff.githubusercontent.com/raw/python/python-docs-es/pull/1646.patch" target="_blank">pFad v4 Proxy</a></p></body>
</html>