diff --git a/TRANSLATORS b/TRANSLATORS
index 462f568522..7574589853 100644
--- a/TRANSLATORS
+++ b/TRANSLATORS
@@ -86,6 +86,7 @@ Fabrizio Damicelli (@fabridamicelli)
 Facundo Batista (@facundobatista)
 Federico Jurío (@FedericoJurio)
 Federico Zuccolo (@fzuccolo)
+Felipe Arce Aqueveque (@pipe1os)
 Fnar
 Fonso
 Francisco Ecatl Melo Valle
diff --git a/dictionaries/tutorial_classes.txt b/dictionaries/tutorial_classes.txt
index cc2c1108df..3776aaac5b 100644
--- a/dictionaries/tutorial_classes.txt
+++ b/dictionaries/tutorial_classes.txt
@@ -6,3 +6,4 @@ Observá
 llamás
 necesitás
 sorpresivo
+linealiza
\ No newline at end of file
diff --git a/tutorial/classes.po b/tutorial/classes.po
index 5b1eed3c3c..153b4f82e4 100644
--- a/tutorial/classes.po
+++ b/tutorial/classes.po
@@ -13,12 +13,12 @@ msgstr ""
 "POT-Creation-Date: 2026-02-26 18:44-0300\n"
 "PO-Revision-Date: 2023-10-16 19:31-0300\n"
 "Last-Translator: Carlos A. Crespo <lvccrespo@gmail.com>\n"
-"Language: es\n"
 "Language-Team: python-doc-es\n"
-"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"Language: es\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
 "Generated-By: Babel 2.18.0\n"
 
 #: ../Doc/tutorial/classes.rst:5
@@ -228,9 +228,9 @@ msgid ""
 "module is created when the module definition is read in; normally, module "
 "namespaces also last until the interpreter quits.  The statements executed "
 "by the top-level invocation of the interpreter, either read from a script "
-"file or interactively, are considered part of a module called :mod:"
-"`__main__`, so they have their own global namespace.  (The built-in names "
-"actually also live in a module; this is called :mod:`builtins`.)"
+"file or interactively, are considered part of a module "
+"called :mod:`__main__`, so they have their own global namespace.  (The built-"
+"in names actually also live in a module; this is called :mod:`builtins`.)"
 msgstr ""
 "Los espacios de nombres se crean en diferentes momentos y con diferentes "
 "tiempos de vida.  El espacio de nombres que contiene los nombres incluidos "
@@ -309,20 +309,20 @@ msgstr ""
 msgid ""
 "If a name is declared global, then all references and assignments go "
 "directly to the next-to-last scope containing the module's global names.  To "
-"rebind variables found outside of the innermost scope, the :keyword:"
-"`nonlocal` statement can be used; if not declared nonlocal, those variables "
-"are read-only (an attempt to write to such a variable will simply create a "
-"*new* local variable in the innermost scope, leaving the identically named "
-"outer variable unchanged)."
+"rebind variables found outside of the innermost scope, "
+"the :keyword:`nonlocal` statement can be used; if not declared nonlocal, "
+"those variables are read-only (an attempt to write to such a variable will "
+"simply create a *new* local variable in the innermost scope, leaving the "
+"identically named outer variable unchanged)."
 msgstr ""
 "Si un nombre se declara global, entonces todas las referencias y "
 "asignaciones se realizan directamente en el ámbito penúltimo que contiene "
 "los nombres globales del módulo. Para volver a enlazar variables encontradas "
-"fuera del ámbito más interno, se puede utilizar la declaración :keyword:"
-"`nonlocal`; si no se declara nonlocal, esas variables serán de sólo lectura "
-"(un intento de escribir en una variable de este tipo simplemente creará una "
-"*nueva* variable local en el ámbito más interno, dejando sin cambios la "
-"variable con el mismo nombre en el ámbito externo)."
+"fuera del ámbito más interno, se puede utilizar la "
+"declaración :keyword:`nonlocal`; si no se declara nonlocal, esas variables "
+"serán de sólo lectura (un intento de escribir en una variable de este tipo "
+"simplemente creará una *nueva* variable local en el ámbito más interno, "
+"dejando sin cambios la variable con el mismo nombre en el ámbito externo)."
 
 #: ../Doc/tutorial/classes.rst:133
 msgid ""
@@ -357,31 +357,31 @@ msgstr ""
 
 #: ../Doc/tutorial/classes.rst:146
 msgid ""
-"A special quirk of Python is that -- if no :keyword:`global` or :keyword:"
-"`nonlocal` statement is in effect -- assignments to names always go into the "
-"innermost scope. Assignments do not copy data --- they just bind names to "
-"objects.  The same is true for deletions: the statement ``del x`` removes "
-"the binding of ``x`` from the namespace referenced by the local scope.  In "
-"fact, all operations that introduce new names use the local scope: in "
-"particular, :keyword:`import` statements and function definitions bind the "
-"module or function name in the local scope."
-msgstr ""
-"Una peculiaridad especial de Python es que, si no hay una declaración :"
-"keyword:`global` o :keyword:`nonlocal` en efecto, las asignaciones a nombres "
-"siempre van al ámbito interno.  Las asignaciones no copian datos, solamente "
-"asocian nombres a objetos.  Lo mismo cuando se borra: la declaración ``del "
-"x`` quita la asociación de ``x`` del espacio de nombres referenciado por el "
-"ámbito local.  De hecho, todas las operaciones que introducen nuevos nombres "
-"usan el ámbito local: en particular, las instrucciones :keyword:`import` y "
-"las definiciones de funciones asocian el módulo o nombre de la función al "
-"espacio de nombres en el ámbito local."
+"A special quirk of Python is that -- if no :keyword:`global` "
+"or :keyword:`nonlocal` statement is in effect -- assignments to names always "
+"go into the innermost scope. Assignments do not copy data --- they just bind "
+"names to objects.  The same is true for deletions: the statement ``del x`` "
+"removes the binding of ``x`` from the namespace referenced by the local "
+"scope.  In fact, all operations that introduce new names use the local "
+"scope: in particular, :keyword:`import` statements and function definitions "
+"bind the module or function name in the local scope."
+msgstr ""
+"Una peculiaridad especial de Python es que, si no hay una "
+"declaración :keyword:`global` o :keyword:`nonlocal` en efecto, las "
+"asignaciones a nombres siempre van al ámbito interno.  Las asignaciones no "
+"copian datos, solamente asocian nombres a objetos.  Lo mismo cuando se "
+"borra: la declaración ``del x`` quita la asociación de ``x`` del espacio de "
+"nombres referenciado por el ámbito local.  De hecho, todas las operaciones "
+"que introducen nuevos nombres usan el ámbito local: en particular, las "
+"instrucciones :keyword:`import` y las definiciones de funciones asocian el "
+"módulo o nombre de la función al espacio de nombres en el ámbito local."
 
 #: ../Doc/tutorial/classes.rst:154
 msgid ""
 "The :keyword:`global` statement can be used to indicate that particular "
-"variables live in the global scope and should be rebound there; the :keyword:"
-"`nonlocal` statement indicates that particular variables live in an "
-"enclosing scope and should be rebound there."
+"variables live in the global scope and should be rebound there; "
+"the :keyword:`nonlocal` statement indicates that particular variables live "
+"in an enclosing scope and should be rebound there."
 msgstr ""
 "La declaración :keyword:`global` puede usarse para indicar que ciertas "
 "variables viven en el ámbito global y deberían reasignarse allí; la "
@@ -399,8 +399,8 @@ msgid ""
 "variable binding::"
 msgstr ""
 "Este es un ejemplo que muestra como hacer referencia a distintos ámbitos y "
-"espacios de nombres, y cómo las declaraciones :keyword:`global` y :keyword:"
-"`nonlocal` afectan la asignación de variables::"
+"espacios de nombres, y cómo las declaraciones :keyword:`global` "
+"y :keyword:`nonlocal` afectan la asignación de variables::"
 
 #: ../Doc/tutorial/classes.rst:168
 msgid ""
@@ -427,6 +427,28 @@ msgid ""
 "scope_test()\n"
 "print(\"In global scope:\", spam)"
 msgstr ""
+"def scope_test():\n"
+"    def do_local():\n"
+"        spam = \"local spam\"\n"
+"\n"
+"    def do_nonlocal():\n"
+"        nonlocal spam\n"
+"        spam = \"nonlocal spam\"\n"
+"\n"
+"    def do_global():\n"
+"        global spam\n"
+"        spam = \"global spam\"\n"
+"\n"
+"    spam = \"test spam\"\n"
+"    do_local()\n"
+"    print(\"After local assignment:\", spam)\n"
+"    do_nonlocal()\n"
+"    print(\"After nonlocal assignment:\", spam)\n"
+"    do_global()\n"
+"    print(\"After global assignment:\", spam)\n"
+"\n"
+"scope_test()\n"
+"print(\"In global scope:\", spam)"
 
 #: ../Doc/tutorial/classes.rst:191
 msgid "The output of the example code is:"
@@ -439,6 +461,10 @@ msgid ""
 "After global assignment: nonlocal spam\n"
 "In global scope: global spam"
 msgstr ""
+"After local assignment: test spam\n"
+"After nonlocal assignment: nonlocal spam\n"
+"After global assignment: nonlocal spam\n"
+"In global scope: global spam"
 
 #: ../Doc/tutorial/classes.rst:200
 msgid ""
@@ -449,13 +475,13 @@ msgid ""
 msgstr ""
 "Notá como la asignación *local* (que es el comportamiento normal) no cambió "
 "la vinculación de *spam* de *scope_test*.  La asignación :keyword:`nonlocal` "
-"cambió la vinculación de *spam* de *scope_test*, y la asignación :keyword:"
-"`global` cambió la vinculación a nivel de módulo."
+"cambió la vinculación de *spam* de *scope_test*, y la "
+"asignación :keyword:`global` cambió la vinculación a nivel de módulo."
 
 #: ../Doc/tutorial/classes.rst:205
 msgid ""
-"You can also see that there was no previous binding for *spam* before the :"
-"keyword:`global` assignment."
+"You can also see that there was no previous binding for *spam* before "
+"the :keyword:`global` assignment."
 msgstr ""
 "También podés ver que no había vinculación para *spam* antes de la "
 "asignación :keyword:`global`."
@@ -489,6 +515,12 @@ msgid ""
 "    .\n"
 "    <statement-N>"
 msgstr ""
+"class ClassName:\n"
+"    <statement-1>\n"
+"    .\n"
+"    .\n"
+"    .\n"
+"    <statement-N>"
 
 #: ../Doc/tutorial/classes.rst:232
 msgid ""
@@ -583,9 +615,14 @@ msgid ""
 "    def f(self):\n"
 "        return 'hello world'"
 msgstr ""
+"class MyClass:\n"
+"    \"\"\"A simple example class\"\"\"\n"
+"    i = 12345\n"
+"\n"
+"    def f(self):\n"
+"        return 'hello world'"
 
 #: ../Doc/tutorial/classes.rst:276
-#, fuzzy
 msgid ""
 "then ``MyClass.i`` and ``MyClass.f`` are valid attribute references, "
 "returning an integer and a function object, respectively. Class attributes "
@@ -595,10 +632,10 @@ msgid ""
 msgstr ""
 "entonces ``MyClass.i`` y ``MyClass.f`` son referencias de atributos válidas, "
 "que retornan un entero y un objeto función respectivamente. Los atributos de "
-"clase también pueden ser asignados, o sea que podés cambiar el valor de "
-"``MyClass.i`` mediante asignación. :attr:`!__doc__` también es un atributo "
-"válido, que retorna la documentación asociada a la clase: ``\"A simple "
-"example class\"``."
+"clase también pueden ser asignados, o sea que puedes cambiar el valor de "
+"``MyClass.i`` mediante asignación. :attr:`~type.__doc__` también es un "
+"atributo válido, que retorna la documentación asociada a la clase: ``\"A "
+"simple example class\"``."
 
 #: ../Doc/tutorial/classes.rst:282
 msgid ""
@@ -612,7 +649,7 @@ msgstr ""
 
 #: ../Doc/tutorial/classes.rst:286 ../Doc/tutorial/classes.rst:303
 msgid "x = MyClass()"
-msgstr ""
+msgstr "x = MyClass()"
 
 #: ../Doc/tutorial/classes.rst:288
 msgid ""
@@ -626,8 +663,8 @@ msgstr ""
 msgid ""
 "The instantiation operation (\"calling\" a class object) creates an empty "
 "object. Many classes like to create objects with instances customized to a "
-"specific initial state. Therefore a class may define a special method named :"
-"meth:`~object.__init__`, like this::"
+"specific initial state. Therefore a class may define a special method "
+"named :meth:`~object.__init__`, like this::"
 msgstr ""
 "La operación de instanciación (\"llamar\" a un objeto clase) crea un objeto "
 "vacío. Muchas clases necesitan crear objetos con instancias en un estado "
@@ -639,6 +676,8 @@ msgid ""
 "def __init__(self):\n"
 "    self.data = []"
 msgstr ""
+"def __init__(self):\n"
+"    self.data = []"
 
 #: ../Doc/tutorial/classes.rst:299
 msgid ""
@@ -674,6 +713,14 @@ msgid ""
 ">>> x.r, x.i\n"
 "(3.0, -4.5)"
 msgstr ""
+">>> class Complex:\n"
+"...     def __init__(self, realpart, imagpart):\n"
+"...         self.r = realpart\n"
+"...         self.i = imagpart\n"
+"...\n"
+">>> x = Complex(3.0, -4.5)\n"
+">>> x.r, x.i\n"
+"(3.0, -4.5)"
 
 #: ../Doc/tutorial/classes.rst:322
 msgid "Instance Objects"
@@ -690,7 +737,6 @@ msgstr ""
 "dos tipos de nombres de atributos válidos, atributos de datos y métodos."
 
 #: ../Doc/tutorial/classes.rst:328
-#, fuzzy
 msgid ""
 "*Data attributes* correspond to \"instance variables\" in Smalltalk, and to "
 "\"data members\" in C++.  Data attributes need not be declared; like local "
@@ -703,8 +749,8 @@ msgstr ""
 "en Smalltalk, y con las \"variables miembro\" en C++. Los atributos de datos "
 "no necesitan ser declarados; tal como las variables locales son creados la "
 "primera vez que se les asigna algo. Por ejemplo, si ``x`` es la instancia "
-"de :class:`!MyClass` creada más arriba, el siguiente pedazo de código va a "
-"imprimir el valor ``16``, sin dejar ningún rastro::"
+"de :class:`!MyClass` creada más arriba, el siguiente fragmento de código "
+"imprimirá el valor ``16``, sin dejar ningún rastro::"
 
 #: ../Doc/tutorial/classes.rst:334
 msgid ""
@@ -714,12 +760,19 @@ msgid ""
 "print(x.counter)\n"
 "del x.counter"
 msgstr ""
+"x.counter = 1\n"
+"while x.counter < 10:\n"
+"    x.counter = x.counter * 2\n"
+"print(x.counter)\n"
+"del x.counter"
 
 #: ../Doc/tutorial/classes.rst:340
 msgid ""
 "The other kind of instance attribute reference is a *method*. A method is a "
 "function that \"belongs to\" an object."
 msgstr ""
+"El otro tipo de referencia a un atributo de instancia es un *método*. Un "
+"método es una función que \"pertenece a\" un objeto."
 
 #: ../Doc/tutorial/classes.rst:345
 msgid ""
@@ -733,10 +786,10 @@ msgstr ""
 "Los nombres válidos de métodos de un objeto instancia dependen de su clase. "
 "Por definición, todos los atributos de clase que son objetos funciones "
 "definen métodos correspondientes de sus instancias.  Entonces, en nuestro "
-"ejemplo, ``x.f`` es una referencia a un método válido, dado que ``MyClass."
-"f`` es una función, pero ``x.i`` no lo es, dado que ``MyClass.i`` no lo es.  "
-"Pero ``x.f`` no es la misma cosa que ``MyClass.f``; es un *objeto método*, "
-"no un objeto función."
+"ejemplo, ``x.f`` es una referencia a un método válido, dado que "
+"``MyClass.f`` es una función, pero ``x.i`` no lo es, dado que ``MyClass.i`` "
+"no lo es.  Pero ``x.f`` no es la misma cosa que ``MyClass.f``; es un *objeto "
+"método*, no un objeto función."
 
 #: ../Doc/tutorial/classes.rst:356
 msgid "Method Objects"
@@ -748,19 +801,19 @@ msgstr "Generalmente, un método es llamado luego de ser vinculado::"
 
 #: ../Doc/tutorial/classes.rst:360
 msgid "x.f()"
-msgstr ""
+msgstr "x.f()"
 
 #: ../Doc/tutorial/classes.rst:362
-#, fuzzy
 msgid ""
 "If ``x = MyClass()``, as above, this will return the string ``'hello "
 "world'``. However, it is not necessary to call a method right away: ``x.f`` "
 "is a method object, and can be stored away and called at a later time.  For "
 "example::"
 msgstr ""
-"En el ejemplo :class:`!MyClass`, esto retorna la cadena ``'hello world'``. "
-"Pero no es necesario llamar al método justo en ese momento: ``x.f`` es un "
-"objeto método, y puede ser guardado y llamado más tarde. Por ejemplo::"
+"Si ``x = MyClass()``, como arriba, esto devolverá la cadena ``'hello "
+"world'``. Pero no es necesario llamar al método justo en ese momento: "
+"``x.f`` es un objeto método, y puede ser guardado y llamado más tarde. Por "
+"ejemplo::"
 
 #: ../Doc/tutorial/classes.rst:366
 msgid ""
@@ -768,6 +821,9 @@ msgid ""
 "while True:\n"
 "    print(xf())"
 msgstr ""
+"xf = x.f\n"
+"while True:\n"
+"    print(xf())"
 
 #: ../Doc/tutorial/classes.rst:370
 msgid "will continue to print ``hello world`` until the end of time."
@@ -775,8 +831,8 @@ msgstr "continuará imprimiendo ``hello world`` hasta el fin de los días."
 
 #: ../Doc/tutorial/classes.rst:372
 msgid ""
-"What exactly happens when a method is called?  You may have noticed that ``x."
-"f()`` was called without an argument above, even though the function "
+"What exactly happens when a method is called?  You may have noticed that "
+"``x.f()`` was called without an argument above, even though the function "
 "definition for :meth:`!f` specified an argument.  What happened to the "
 "argument? Surely Python raises an exception when a function that requires an "
 "argument is called without any --- even if the argument isn't actually "
@@ -808,7 +864,6 @@ msgstr ""
 "primer argumento."
 
 #: ../Doc/tutorial/classes.rst:385
-#, fuzzy
 msgid ""
 "In general, methods work as follows.  When a non-data attribute of an "
 "instance is referenced, the instance's class is searched. If the name "
@@ -818,15 +873,14 @@ msgid ""
 "argument list is constructed from the instance object and the argument list, "
 "and the function object is called with this new argument list."
 msgstr ""
-"Si todavía no entiendes como funcionan los métodos, una mirada a su "
-"implementación quizás pueda aclarar dudas. Cuando un atributo sin datos de "
-"una instancia es referenciado, la clase de la instancia es accedida. Si el "
-"nombre indica un atributo de clase válido que sea un objeto función, se crea "
-"un objeto método empaquetando (apunta a) la instancia y al objeto función, "
-"juntados en un objeto abstracto: este es el objeto método. Cuando el objeto "
-"método es llamado con una lista de argumentos, se crea una nueva lista de "
-"argumentos a partir del objeto instancia y la lista de argumentos. "
-"Finalmente el objeto función es llamado con esta nueva lista de argumentos."
+"En general, los métodos funcionan de la siguiente manera. Cuando se hace "
+"referencia a un atributo de una instancia que no es de datos, se busca en la "
+"clase de la instancia. Si el nombre denota un atributo de clase válido que "
+"es un objeto función, las referencias tanto al objeto instancia como al "
+"objeto función se empaquetan en un objeto método. Cuando se llama al objeto "
+"método con una lista de argumentos, se construye una nueva lista de "
+"argumentos a partir del objeto instancia y la lista de argumentos original, "
+"y el objeto función se llama con esta nueva lista de argumentos."
 
 #: ../Doc/tutorial/classes.rst:398
 msgid "Class and Instance Variables"
@@ -862,6 +916,25 @@ msgid ""
 ">>> e.name                  # unique to e\n"
 "'Buddy'"
 msgstr ""
+"class Dog:\n"
+"\n"
+"    kind = 'canine'         # variable de clase compartida por todas las "
+"instancias\n"
+"\n"
+"    def __init__(self, name):\n"
+"        self.name = name    # variable de instancia única para cada "
+"instancia\n"
+"\n"
+">>> d = Dog('Fido')\n"
+">>> e = Dog('Buddy')\n"
+">>> d.kind                  # compartido por todos los perros\n"
+"'canine'\n"
+">>> e.kind                  # compartido por todos los perros\n"
+"'canine'\n"
+">>> d.name                  # único para d\n"
+"'Fido'\n"
+">>> e.name                  # único para e\n"
+"'Buddy'"
 
 #: ../Doc/tutorial/classes.rst:422
 msgid ""
@@ -896,6 +969,23 @@ msgid ""
 ">>> d.tricks                # unexpectedly shared by all dogs\n"
 "['roll over', 'play dead']"
 msgstr ""
+"class Dog:\n"
+"\n"
+"    tricks = []             # uso erróneo de una variable de clase\n"
+"\n"
+"    def __init__(self, name):\n"
+"        self.name = name\n"
+"\n"
+"    def add_trick(self, trick):\n"
+"        self.tricks.append(trick)\n"
+"\n"
+">>> d = Dog('Fido')\n"
+">>> e = Dog('Buddy')\n"
+">>> d.add_trick('roll over')\n"
+">>> e.add_trick('play dead')\n"
+">>> d.tricks                # inesperadamente compartido por todos los "
+"perros\n"
+"['roll over', 'play dead']"
 
 #: ../Doc/tutorial/classes.rst:445
 msgid "Correct design of the class should use an instance variable instead::"
@@ -922,6 +1012,23 @@ msgid ""
 ">>> e.tricks\n"
 "['play dead']"
 msgstr ""
+"class Dog:\n"
+"\n"
+"    def __init__(self, name):\n"
+"        self.name = name\n"
+"        self.tricks = []    # crea una nueva lista vacía para cada perro\n"
+"\n"
+"    def add_trick(self, trick):\n"
+"        self.tricks.append(trick)\n"
+"\n"
+">>> d = Dog('Fido')\n"
+">>> e = Dog('Buddy')\n"
+">>> d.add_trick('roll over')\n"
+">>> e.add_trick('play dead')\n"
+">>> d.tricks\n"
+"['roll over']\n"
+">>> e.tricks\n"
+"['play dead']"
 
 #: ../Doc/tutorial/classes.rst:469
 msgid "Random Remarks"
@@ -949,6 +1056,17 @@ msgid ""
 ">>> print(w2.purpose, w2.region)\n"
 "storage east"
 msgstr ""
+">>> class Warehouse:\n"
+"...    purpose = 'storage'\n"
+"...    region = 'west'\n"
+"...\n"
+">>> w1 = Warehouse()\n"
+">>> print(w1.purpose, w1.region)\n"
+"storage west\n"
+">>> w2 = Warehouse()\n"
+">>> w2.region = 'east'\n"
+">>> print(w2.purpose, w2.region)\n"
+"storage east"
 
 #: ../Doc/tutorial/classes.rst:488
 msgid ""
@@ -1038,6 +1156,17 @@ msgid ""
 "\n"
 "    h = g"
 msgstr ""
+"# Función definida fuera de la clase\n"
+"def f1(self, x, y):\n"
+"    return min(x, x+y)\n"
+"\n"
+"class C:\n"
+"    f = f1\n"
+"\n"
+"    def g(self):\n"
+"        return 'hello world'\n"
+"\n"
+"    h = g"
 
 #: ../Doc/tutorial/classes.rst:530
 msgid ""
@@ -1073,6 +1202,16 @@ msgid ""
 "        self.add(x)\n"
 "        self.add(x)"
 msgstr ""
+"class Bag:\n"
+"    def __init__(self):\n"
+"        self.data = []\n"
+"\n"
+"    def add(self, x):\n"
+"        self.data.append(x)\n"
+"\n"
+"    def addtwice(self, x):\n"
+"        self.add(x)\n"
+"        self.add(x)"
 
 #: ../Doc/tutorial/classes.rst:549
 msgid ""
@@ -1128,6 +1267,12 @@ msgid ""
 "    .\n"
 "    <statement-N>"
 msgstr ""
+"class DerivedClassName(BaseClassName):\n"
+"    <statement-1>\n"
+"    .\n"
+"    .\n"
+"    .\n"
+"    <statement-N>"
 
 #: ../Doc/tutorial/classes.rst:579
 msgid ""
@@ -1143,7 +1288,7 @@ msgstr ""
 
 #: ../Doc/tutorial/classes.rst:585
 msgid "class DerivedClassName(modname.BaseClassName):"
-msgstr ""
+msgstr "class DerivedClassName(modname.BaseClassName):"
 
 #: ../Doc/tutorial/classes.rst:587
 msgid ""
@@ -1195,10 +1340,10 @@ msgstr ""
 msgid ""
 "An overriding method in a derived class may in fact want to extend rather "
 "than simply replace the base class method of the same name. There is a "
-"simple way to call the base class method directly: just call ``BaseClassName."
-"methodname(self, arguments)``.  This is occasionally useful to clients as "
-"well.  (Note that this only works if the base class is accessible as "
-"``BaseClassName`` in the global scope.)"
+"simple way to call the base class method directly: just call "
+"``BaseClassName.methodname(self, arguments)``.  This is occasionally useful "
+"to clients as well.  (Note that this only works if the base class is "
+"accessible as ``BaseClassName`` in the global scope.)"
 msgstr ""
 "Un método redefinido en una clase derivada puede de hecho querer extender en "
 "vez de simplemente reemplazar al método de la clase base con el mismo "
@@ -1219,8 +1364,8 @@ msgid ""
 "derived from :class:`int`."
 msgstr ""
 "Usar :func:`isinstance` para verificar el tipo de una instancia: "
-"``isinstance(obj, int)`` será ``True`` sólo si ``obj.__class__`` es :class:"
-"`int` o alguna clase derivada de :class:`int`."
+"``isinstance(obj, int)`` será ``True`` sólo si ``obj.__class__`` "
+"es :class:`int` o alguna clase derivada de :class:`int`."
 
 #: ../Doc/tutorial/classes.rst:618
 msgid ""
@@ -1255,6 +1400,12 @@ msgid ""
 "    .\n"
 "    <statement-N>"
 msgstr ""
+"class DerivedClassName(Base1, Base2, Base3):\n"
+"    <statement-1>\n"
+"    .\n"
+"    .\n"
+"    .\n"
+"    <statement-N>"
 
 #: ../Doc/tutorial/classes.rst:640
 msgid ""
@@ -1283,13 +1434,12 @@ msgid ""
 "languages."
 msgstr ""
 "En realidad es un poco más complejo que eso; el orden de resolución de "
-"métodos cambia dinámicamente para soportar las llamadas cooperativas a :func:"
-"`super`.  Este enfoque es conocido en otros lenguajes con herencia múltiple "
-"como \"llámese al siguiente método\" y es más poderoso que la llamada al "
-"superior que se encuentra en lenguajes con sólo herencia simple."
+"métodos cambia dinámicamente para soportar las llamadas cooperativas "
+"a :func:`super`.  Este enfoque es conocido en otros lenguajes con herencia "
+"múltiple como \"llámese al siguiente método\" y es más poderoso que la "
+"llamada al superior que se encuentra en lenguajes con sólo herencia simple."
 
 #: ../Doc/tutorial/classes.rst:653
-#, fuzzy
 msgid ""
 "Dynamic ordering is necessary because all cases of multiple inheritance "
 "exhibit one or more diamond relationships (where at least one of the parent "
@@ -1305,18 +1455,18 @@ msgid ""
 "multiple inheritance.  For more detail, see :ref:`python_2.3_mro`."
 msgstr ""
 "El ordenamiento dinámico es necesario porque todos los casos de herencia "
-"múltiple exhiben una o más relaciones en diamante (cuando se puede llegar al "
-"menos a una de las clases base por distintos caminos desde la clase de más "
-"abajo).  Por ejemplo, todas las clases heredan de :class:`object`, por lo "
-"tanto cualquier caso de herencia múltiple provee más de un camino para "
-"llegar a :class:`object`.  Para que las clases base no sean accedidas más de "
-"una vez, el algoritmo dinámico hace lineal el orden de búsqueda de manera "
-"que se preserve el orden de izquierda a derecha especificado en cada clase, "
-"que se llame a cada clase base sólo una vez, y que sea monótona (lo cual "
-"significa que una clase puede tener clases derivadas sin afectar el orden de "
-"precedencia de sus clases bases).  En conjunto, estas propiedades hacen "
-"posible diseñar clases confiables y extensibles con herencia múltiple. Para "
-"más detalles mirá  https://www.python.org/download/releases/2.3/mro/."
+"múltiple exhiben una o más relaciones en diamante (donde se puede acceder al "
+"menos a una de las clases padre por múltiples caminos desde la clase de más "
+"abajo). Por ejemplo, todas las clases heredan de :class:`object`, por lo que "
+"cualquier caso de herencia múltiple provee más de un camino para llegar "
+"a :class:`object`. Para evitar que las clases base sean accedidas más de una "
+"vez, el algoritmo dinámico linealiza el orden de búsqueda de manera que "
+"preserva el orden de izquierda a derecha especificado en cada clase, que "
+"llama a cada padre solo una vez, y que es monótono (lo que significa que una "
+"clase puede ser subclasificada sin afectar el orden de precedencia de sus "
+"padres). En conjunto, estas propiedades hacen posible diseñar clases "
+"confiables y extensibles con herencia múltiple. Para más detalles, "
+"consulta :ref:`python_2.3_mro`."
 
 #: ../Doc/tutorial/classes.rst:670
 msgid "Private Variables"
@@ -1365,6 +1515,8 @@ msgid ""
 "The :ref:`private name mangling specifications <private-name-mangling>` for "
 "details and special cases."
 msgstr ""
+"Consulte las :ref:`especificaciones de private name mangling <private-name-"
+"mangling>` para obtener detalles y casos especiales."
 
 #: ../Doc/tutorial/classes.rst:696
 msgid ""
@@ -1396,6 +1548,25 @@ msgid ""
 "        for item in zip(keys, values):\n"
 "            self.items_list.append(item)"
 msgstr ""
+"class Mapping:\n"
+"\n"
+"    def __init__(self, iterable):\n"
+"        self.items_list = []\n"
+"        self.__update(iterable)\n"
+"\n"
+"    def update(self, iterable):\n"
+"        for item in iterable:\n"
+"            self.items_list.append(item)\n"
+"\n"
+"    __update = update   # copia privada del método update() original\n"
+"\n"
+"class MappingSubclass(Mapping):\n"
+"\n"
+"    def update(self, keys, values):\n"
+"        # provee una nueva firma para update()\n"
+"        # pero no rompe __init__()\n"
+"        for item in zip(keys, values):\n"
+"            self.items_list.append(item)"
 
 #: ../Doc/tutorial/classes.rst:718
 msgid ""
@@ -1462,6 +1633,13 @@ msgid ""
 "    dept: str\n"
 "    salary: int"
 msgstr ""
+"from dataclasses import dataclass\n"
+"\n"
+"@dataclass\n"
+"class Employee:\n"
+"    name: str\n"
+"    dept: str\n"
+"    salary: int"
 
 #: ../Doc/tutorial/classes.rst:754
 msgid ""
@@ -1471,6 +1649,11 @@ msgid ""
 ">>> john.salary\n"
 "1000"
 msgstr ""
+">>> john = Employee('john', 'computer lab', 1000)\n"
+">>> john.dept\n"
+"'computer lab'\n"
+">>> john.salary\n"
+"1000"
 
 #: ../Doc/tutorial/classes.rst:760
 msgid ""
@@ -1490,16 +1673,16 @@ msgstr ""
 "argumento."
 
 #: ../Doc/tutorial/classes.rst:772
-#, fuzzy
 msgid ""
-":ref:`Instance method objects <instance-methods>` have attributes, too: :"
-"attr:`m.__self__ <method.__self__>` is the instance object with the method :"
-"meth:`!m`, and :attr:`m.__func__ <method.__func__>` is the :ref:`function "
-"object <user-defined-funcs>` corresponding to the method."
+":ref:`Instance method objects <instance-methods>` have attributes, "
+"too: :attr:`m.__self__ <method.__self__>` is the instance object with the "
+"method :meth:`!m`, and :attr:`m.__func__ <method.__func__>` is "
+"the :ref:`function object <user-defined-funcs>` corresponding to the method."
 msgstr ""
-"Los objetos método de instancia tienen atributos también: ``m.__self__`` es "
-"el objeto instancia con el método :meth:`!m`, y ``m.__func__`` es el objeto "
-"función correspondiente al método."
+":ref:`Los objetos método de instancia <instance-methods>` también tienen "
+"atributos: :attr:`m.__self__ <method.__self__>` es el objeto de instancia "
+"con el método :meth:`!m`, y :attr:`m.__func__ <method.__func__>` es "
+"el :ref:`objeto función <user-defined-funcs>` correspondiente al método."
 
 #: ../Doc/tutorial/classes.rst:782
 msgid "Iterators"
@@ -1527,28 +1710,39 @@ msgid ""
 "for line in open(\"myfile.txt\"):\n"
 "    print(line, end='')"
 msgstr ""
+"for element in [1, 2, 3]:\n"
+"    print(element)\n"
+"for element in (1, 2, 3):\n"
+"    print(element)\n"
+"for key in {'one':1, 'two':2}:\n"
+"    print(key)\n"
+"for char in \"123\":\n"
+"    print(char)\n"
+"for line in open(\"myfile.txt\"):\n"
+"    print(line, end='')"
 
 #: ../Doc/tutorial/classes.rst:798
 msgid ""
 "This style of access is clear, concise, and convenient.  The use of "
-"iterators pervades and unifies Python.  Behind the scenes, the :keyword:"
-"`for` statement calls :func:`iter` on the container object.  The function "
-"returns an iterator object that defines the method :meth:`~iterator."
-"__next__` which accesses elements in the container one at a time.  When "
-"there are no more elements, :meth:`~iterator.__next__` raises a :exc:"
-"`StopIteration` exception which tells the :keyword:`!for` loop to "
-"terminate.  You can call the :meth:`~iterator.__next__` method using the :"
-"func:`next` built-in function; this example shows how it all works::"
+"iterators pervades and unifies Python.  Behind the scenes, "
+"the :keyword:`for` statement calls :func:`iter` on the container object.  "
+"The function returns an iterator object that defines the "
+"method :meth:`~iterator.__next__` which accesses elements in the container "
+"one at a time.  When there are no more elements, :meth:`~iterator.__next__` "
+"raises a :exc:`StopIteration` exception which tells the :keyword:`!for` loop "
+"to terminate.  You can call the :meth:`~iterator.__next__` method using "
+"the :func:`next` built-in function; this example shows how it all works::"
 msgstr ""
 "Este estilo de acceso es limpio, conciso y conveniente.  El uso de "
-"iteradores está impregnado y unifica a Python.  En bambalinas, la sentencia :"
-"keyword:`for` llama a :func:`iter` en el objeto contenedor.  La función "
-"retorna un objeto iterador que define el método :meth:`__next__` que accede "
-"elementos en el contenedor de a uno por vez.  Cuando no hay más elementos, :"
-"meth:`~iterator.__next__` lanza una excepción :exc:`StopIteration` que le "
-"avisa al bucle del :keyword:`!for` que hay que terminar.  Podés llamar al "
-"método :meth:`~iterator.__next__` usando la función integrada :func:`next`; "
-"este ejemplo muestra como funciona todo esto::"
+"iteradores está impregnado y unifica a Python.  En bambalinas, la "
+"sentencia :keyword:`for` llama a :func:`iter` en el objeto contenedor.  La "
+"función retorna un objeto iterador que define el método :meth:`__next__` que "
+"accede elementos en el contenedor de a uno por vez.  Cuando no hay más "
+"elementos, :meth:`~iterator.__next__` lanza una "
+"excepción :exc:`StopIteration` que le avisa al bucle del :keyword:`!for` que "
+"hay que terminar.  Podés llamar al método :meth:`~iterator.__next__` usando "
+"la función integrada :func:`next`; este ejemplo muestra como funciona todo "
+"esto::"
 
 #: ../Doc/tutorial/classes.rst:807
 msgid ""
@@ -1568,6 +1762,21 @@ msgid ""
 "    next(it)\n"
 "StopIteration"
 msgstr ""
+">>> s = 'abc'\n"
+">>> it = iter(s)\n"
+">>> it\n"
+"<str_iterator object at 0x10c90e650>\n"
+">>> next(it)\n"
+"'a'\n"
+">>> next(it)\n"
+"'b'\n"
+">>> next(it)\n"
+"'c'\n"
+">>> next(it)\n"
+"Traceback (most recent call last):\n"
+"  File \"<stdin>\", line 1, in <module>\n"
+"    next(it)\n"
+"StopIteration"
 
 #: ../Doc/tutorial/classes.rst:823
 msgid ""
@@ -1578,10 +1787,10 @@ msgid ""
 "``self``::"
 msgstr ""
 "Habiendo visto la mecánica del protocolo de iteración, es fácil agregar "
-"comportamiento de iterador a tus clases. Definí un método :meth:`~container."
-"__iter__` que retorne un objeto con un método :meth:`~iterator.__next__`. Si "
-"la clase define :meth:`!__next__`, entonces alcanza con que :meth:`!"
-"__iter__` retorne ``self``::"
+"comportamiento de iterador a tus clases. Definí un "
+"método :meth:`~container.__iter__` que retorne un objeto con un "
+"método :meth:`~iterator.__next__`. Si la clase define :meth:`!__next__`, "
+"entonces alcanza con que :meth:`!__iter__` retorne ``self``::"
 
 #: ../Doc/tutorial/classes.rst:828
 msgid ""
@@ -1600,6 +1809,20 @@ msgid ""
 "        self.index = self.index - 1\n"
 "        return self.data[self.index]"
 msgstr ""
+"class Reverse:\n"
+"    \"\"\"Iterador para recorrer una secuencia hacia atrás.\"\"\"\n"
+"    def __init__(self, data):\n"
+"        self.data = data\n"
+"        self.index = len(data)\n"
+"\n"
+"    def __iter__(self):\n"
+"        return self\n"
+"\n"
+"    def __next__(self):\n"
+"        if self.index == 0:\n"
+"            raise StopIteration\n"
+"        self.index = self.index - 1\n"
+"        return self.data[self.index]"
 
 #: ../Doc/tutorial/classes.rst:845
 msgid ""
@@ -1614,6 +1837,16 @@ msgid ""
 "p\n"
 "s"
 msgstr ""
+">>> rev = Reverse('spam')\n"
+">>> iter(rev)\n"
+"<__main__.Reverse object at 0x00A1DB50>\n"
+">>> for char in rev:\n"
+"...     print(char)\n"
+"...\n"
+"m\n"
+"a\n"
+"p\n"
+"s"
 
 #: ../Doc/tutorial/classes.rst:860
 msgid "Generators"
@@ -1622,11 +1855,11 @@ msgstr "Generadores"
 #: ../Doc/tutorial/classes.rst:862
 msgid ""
 ":term:`Generators <generator>` are a simple and powerful tool for creating "
-"iterators.  They are written like regular functions but use the :keyword:"
-"`yield` statement whenever they want to return data.  Each time :func:`next` "
-"is called on it, the generator resumes where it left off (it remembers all "
-"the data values and which statement was last executed).  An example shows "
-"that generators can be trivially easy to create::"
+"iterators.  They are written like regular functions but use "
+"the :keyword:`yield` statement whenever they want to return data.  Each "
+"time :func:`next` is called on it, the generator resumes where it left off "
+"(it remembers all the data values and which statement was last executed).  "
+"An example shows that generators can be trivially easy to create::"
 msgstr ""
 ":term:`Generators <generator>` son una herramienta simple y poderosa para "
 "crear iteradores. Están escritas como funciones regulares pero usan la "
@@ -1641,6 +1874,9 @@ msgid ""
 "    for index in range(len(data)-1, -1, -1):\n"
 "        yield data[index]"
 msgstr ""
+"def reverse(data):\n"
+"    for index in range(len(data)-1, -1, -1):\n"
+"        yield data[index]"
 
 #: ../Doc/tutorial/classes.rst:875
 msgid ""
@@ -1652,26 +1888,33 @@ msgid ""
 "o\n"
 "g"
 msgstr ""
+">>> for char in reverse('golf'):\n"
+"...     print(char)\n"
+"...\n"
+"f\n"
+"l\n"
+"o\n"
+"g"
 
 #: ../Doc/tutorial/classes.rst:883
 msgid ""
 "Anything that can be done with generators can also be done with class-based "
 "iterators as described in the previous section.  What makes generators so "
-"compact is that the :meth:`~iterator.__iter__` and :meth:`~generator."
-"__next__` methods are created automatically."
+"compact is that the :meth:`~iterator.__iter__` "
+"and :meth:`~generator.__next__` methods are created automatically."
 msgstr ""
 "Todo lo que puede ser hecho con generadores también puede ser hecho con "
 "iteradores basados en clases, como se describe en la sección anterior. Lo "
-"que hace que los generadores sean tan compactos es que los métodos :meth:"
-"`~iterator.__iter__` y :meth:`~generator.__next__` son creados "
+"que hace que los generadores sean tan compactos es que los "
+"métodos :meth:`~iterator.__iter__` y :meth:`~generator.__next__` son creados "
 "automáticamente."
 
 #: ../Doc/tutorial/classes.rst:888
 msgid ""
 "Another key feature is that the local variables and execution state are "
 "automatically saved between calls.  This made the function easier to write "
-"and much more clear than an approach using instance variables like ``self."
-"index`` and ``self.data``."
+"and much more clear than an approach using instance variables like "
+"``self.index`` and ``self.data``."
 msgstr ""
 "Otra característica clave es que las variables locales y el estado de la "
 "ejecución son guardados automáticamente entre llamadas.  Esto hace que la "
@@ -1686,9 +1929,10 @@ msgid ""
 "effort than writing a regular function."
 msgstr ""
 "Además de la creación automática de métodos y el guardar el estado del "
-"programa, cuando los generadores terminan automáticamente lanzan :exc:"
-"`StopIteration`.  Combinadas, estas características facilitan la creación de "
-"iteradores, y hacen que no sea más esfuerzo que escribir una función regular."
+"programa, cuando los generadores terminan automáticamente "
+"lanzan :exc:`StopIteration`.  Combinadas, estas características facilitan la "
+"creación de iteradores, y hacen que no sea más esfuerzo que escribir una "
+"función regular."
 
 #: ../Doc/tutorial/classes.rst:902
 msgid "Generator Expressions"
@@ -1734,13 +1978,28 @@ msgid ""
 ">>> list(data[i] for i in range(len(data)-1, -1, -1))\n"
 "['f', 'l', 'o', 'g']"
 msgstr ""
+">>> sum(i*i for i in range(10))                 # suma de cuadrados\n"
+"285\n"
+"\n"
+">>> xvec = [10, 20, 30]\n"
+">>> yvec = [7, 5, 3]\n"
+">>> sum(x*y for x,y in zip(xvec, yvec))         # producto escalar\n"
+"260\n"
+"\n"
+">>> unique_words = set(word for line in page  for word in line.split())\n"
+"\n"
+">>> valedictorian = max((student.gpa, student.name) for student in "
+"graduates)\n"
+"\n"
+">>> data = 'golf'\n"
+">>> list(data[i] for i in range(len(data)-1, -1, -1))\n"
+"['f', 'l', 'o', 'g']"
 
 #: ../Doc/tutorial/classes.rst:932
 msgid "Footnotes"
 msgstr "Notas al pie"
 
 #: ../Doc/tutorial/classes.rst:933
-#, fuzzy
 msgid ""
 "Except for one thing.  Module objects have a secret read-only attribute "
 "called :attr:`~object.__dict__` which returns the dictionary used to "
@@ -1749,12 +2008,12 @@ msgid ""
 "namespace implementation, and should be restricted to things like post-"
 "mortem debuggers."
 msgstr ""
-"Excepto por una cosa. Los objetos módulo tienen un atributo de sólo lectura "
-"secreto llamado :attr:`~object.__dict__` que retorna el diccionario usado "
-"para implementar el espacio de nombres del módulo; el nombre :attr:`~object."
-"__dict__` es un atributo pero no un nombre global. Obviamente, usar esto "
-"viola la abstracción de la implementación del espacio de nombres, y debería "
-"ser restringido a cosas como depuradores post-mortem."
+"Excepto por una cosa. Los objetos módulo tienen un atributo secreto de solo "
+"lectura llamado :attr:`~object.__dict__` que retorna el diccionario usado "
+"para implementar el espacio de nombres del módulo; el nombre ``__dict__`` es "
+"un atributo pero no un nombre global. Obviamente, usar esto viola la "
+"abstracción de la implementación del espacio de nombres, y debería estar "
+"restringido a cosas como depuradores post-mortem."
 
 #: ../Doc/tutorial/classes.rst:343
 msgid "object"