diff --git a/sphinx.po b/sphinx.po
index 7d1a5be6e0..d5cd3ef453 100644
--- a/sphinx.po
+++ b/sphinx.po
@@ -56,8 +56,7 @@ msgstr "Qué hay de nuevo en Python %(version)s?"
 msgid ""
 "or <a href=\"%(whatsnew_index)s\">all \"What's new\" documents</a> since 2.0"
 msgstr ""
-"o <a href=\"%(whatsnew_index)s\">todos los \"Qué hay de nuevo\"</a> desde "
-"2.0"
+"o <a href=\"%(whatsnew_index)s\">todos los \"Qué hay de nuevo\"</a> desde 2.0"
 
 #: ../Doc/tools/templates/indexcontent.html:15
 msgid "Tutorial"
diff --git a/tutorial/appendix.po b/tutorial/appendix.po
index eae510d92d..28e0b7d163 100644
--- a/tutorial/appendix.po
+++ b/tutorial/appendix.po
@@ -33,38 +33,38 @@ msgid ""
 "When an error occurs, the interpreter prints an error message and a stack "
 "trace. In interactive mode, it then returns to the primary prompt; when "
 "input came from a file, it exits with a nonzero exit status after printing "
-"the stack trace. (Exceptions handled by an :keyword:`except` clause in a "
-":keyword:`try` statement are not errors in this context.)  Some errors are "
-"unconditionally fatal and cause an exit with a nonzero exit; this applies to"
-" internal inconsistencies and some cases of running out of memory.  All "
-"error messages are written to the standard error stream; normal output from "
+"the stack trace. (Exceptions handled by an :keyword:`except` clause in a :"
+"keyword:`try` statement are not errors in this context.)  Some errors are "
+"unconditionally fatal and cause an exit with a nonzero exit; this applies to "
+"internal inconsistencies and some cases of running out of memory.  All error "
+"messages are written to the standard error stream; normal output from "
 "executed commands is written to standard output."
 msgstr ""
-"Cuando ocurre un error, el intérprete imprime un mensaje de error y la traza"
-" del error.  En el modo interactivo, luego retorna al prompt primario; "
-"cuando la entrada viene de un archivo, el programa termina con código de "
-"salida distinto a cero luego de imprimir la traza del error. (Las "
-"excepciones manejadas por una clausula :keyword:`except` en una sentencia "
-":keyword:`try` no son errores en este contexto).  Algunos errores son "
-"incondicionalmente fatales y causan una terminación con código de salida "
-"distinto de cero; esto se debe a inconsistencias internas o a que el "
-"intérprete se queda sin memoria. Todos los mensajes de error se escriben en "
-"el flujo de errores estándar; las salidas normales de comandos ejecutados se"
-" escriben en la salida estándar."
+"Cuando ocurre un error, el intérprete imprime un mensaje de error y la traza "
+"del error.  En el modo interactivo, luego retorna al prompt primario; cuando "
+"la entrada viene de un archivo, el programa termina con código de salida "
+"distinto a cero luego de imprimir la traza del error. (Las excepciones "
+"manejadas por una clausula :keyword:`except` en una sentencia :keyword:`try` "
+"no son errores en este contexto).  Algunos errores son incondicionalmente "
+"fatales y causan una terminación con código de salida distinto de cero; esto "
+"se debe a inconsistencias internas o a que el intérprete se queda sin "
+"memoria. Todos los mensajes de error se escriben en el flujo de errores "
+"estándar; las salidas normales de comandos ejecutados se escriben en la "
+"salida estándar."
 
 #: ../Doc/tutorial/appendix.rst:28
 msgid ""
 "Typing the interrupt character (usually :kbd:`Control-C` or :kbd:`Delete`) "
 "to the primary or secondary prompt cancels the input and returns to the "
-"primary prompt. [#]_ Typing an interrupt while a command is executing raises"
-" the :exc:`KeyboardInterrupt` exception, which may be handled by a "
-":keyword:`try` statement."
+"primary prompt. [#]_ Typing an interrupt while a command is executing raises "
+"the :exc:`KeyboardInterrupt` exception, which may be handled by a :keyword:"
+"`try` statement."
 msgstr ""
-"Al ingresar el caracter de interrupción (por lo general :kbd:`Control-C` o "
-":kbd:`Supr`) en el prompt primario o secundario, se cancela la entrada y "
+"Al ingresar el caracter de interrupción (por lo general :kbd:`Control-C` o :"
+"kbd:`Supr`) en el prompt primario o secundario, se cancela la entrada y "
 "retorna al prompt primario.  [#]_ Tipear una interrupción mientras un "
-"comando se están ejecutando lanza la excepción :exc:`KeyboardInterrupt`, que"
-" puede ser manejada con una sentencia :keyword:`try`."
+"comando se están ejecutando lanza la excepción :exc:`KeyboardInterrupt`, que "
+"puede ser manejada con una sentencia :keyword:`try`."
 
 #: ../Doc/tutorial/appendix.rst:38
 msgid "Executable Python Scripts"
@@ -83,25 +83,25 @@ msgstr ""
 msgid ""
 "(assuming that the interpreter is on the user's :envvar:`PATH`) at the "
 "beginning of the script and giving the file an executable mode.  The ``#!`` "
-"must be the first two characters of the file.  On some platforms, this first"
-" line must end with a Unix-style line ending (``'\\n'``), not a Windows "
+"must be the first two characters of the file.  On some platforms, this first "
+"line must end with a Unix-style line ending (``'\\n'``), not a Windows "
 "(``'\\r\\n'``) line ending.  Note that the hash, or pound, character, "
 "``'#'``, is used to start a comment in Python."
 msgstr ""
 "...al principio del script y dándole al archivo permisos de ejecución "
 "(asumiendo que el intérprete están en la variable de entorno :envvar:`PATH` "
-"del usuario).  ``#!`` deben ser los primeros dos caracteres del archivo.  En"
-" algunas plataformas, la primera línea debe terminar al estilo Unix "
+"del usuario).  ``#!`` deben ser los primeros dos caracteres del archivo.  En "
+"algunas plataformas, la primera línea debe terminar al estilo Unix "
 "(``'\\n'``), no como en Windows (``'\\r\\n'``).  Notá que el caracter "
 "numeral ``'#'`` se usa en Python para comenzar un comentario."
 
 #: ../Doc/tutorial/appendix.rst:52
 msgid ""
-"The script can be given an executable mode, or permission, using the "
-":program:`chmod` command."
+"The script can be given an executable mode, or permission, using the :"
+"program:`chmod` command."
 msgstr ""
-"Se le puede dar permisos de ejecución al script usando el comando "
-":program:`chmod`::"
+"Se le puede dar permisos de ejecución al script usando el comando :program:"
+"`chmod`::"
 
 #: ../Doc/tutorial/appendix.rst:59
 msgid ""
@@ -129,11 +129,11 @@ msgid ""
 "the name of a file containing your start-up commands.  This is similar to "
 "the :file:`.profile` feature of the Unix shells."
 msgstr ""
-"Cuando usás Python en forma interactiva, suele ser útil que algunos comandos"
-" estándar se ejecuten cada vez que el intérprete se inicia.  Podés hacer "
-"esto configurando la variable de entorno :envvar:`PYTHONSTARTUP` con el "
-"nombre de un archivo que contenga tus comandos de inicio.  Esto es similar "
-"al archivo :file:`.profile` en los intérpretes de comandos de Unix."
+"Cuando usás Python en forma interactiva, suele ser útil que algunos comandos "
+"estándar se ejecuten cada vez que el intérprete se inicia.  Podés hacer esto "
+"configurando la variable de entorno :envvar:`PYTHONSTARTUP` con el nombre de "
+"un archivo que contenga tus comandos de inicio.  Esto es similar al archivo :"
+"file:`.profile` en los intérpretes de comandos de Unix."
 
 #: ../Doc/tutorial/appendix.rst:77
 msgid ""
@@ -141,14 +141,14 @@ msgid ""
 "commands from a script, and not when :file:`/dev/tty` is given as the "
 "explicit source of commands (which otherwise behaves like an interactive "
 "session).  It is executed in the same namespace where interactive commands "
-"are executed, so that objects that it defines or imports can be used without"
-" qualification in the interactive session. You can also change the prompts "
+"are executed, so that objects that it defines or imports can be used without "
+"qualification in the interactive session. You can also change the prompts "
 "``sys.ps1`` and ``sys.ps2`` in this file."
 msgstr ""
 "Este archivo es solo leído en las sesiones interactivas del intérprete, no "
 "cuando Python lee comandos de un script ni cuando :file:`/dev/tty` se "
-"explicita como una fuente de comandos (que de otro modo se comporta como una"
-" sesión interactiva).  Se ejecuta en el mismo espacio de nombres en el que "
+"explicita como una fuente de comandos (que de otro modo se comporta como una "
+"sesión interactiva).  Se ejecuta en el mismo espacio de nombres en el que "
 "los comandos interactivos se ejecutan, entonces los objetos que define o "
 "importa pueden ser usados sin cualificaciones en la sesión interactiva.  En "
 "este archivo también podés cambiar los prompts ``sys.ps1`` y ``sys.ps2``."
@@ -156,16 +156,16 @@ msgstr ""
 #: ../Doc/tutorial/appendix.rst:85
 msgid ""
 "If you want to read an additional start-up file from the current directory, "
-"you can program this in the global start-up file using code like ``if "
-"os.path.isfile('.pythonrc.py'): exec(open('.pythonrc.py').read())``. If you "
-"want to use the startup file in a script, you must do this explicitly in the"
-" script::"
+"you can program this in the global start-up file using code like ``if os."
+"path.isfile('.pythonrc.py'): exec(open('.pythonrc.py').read())``. If you "
+"want to use the startup file in a script, you must do this explicitly in the "
+"script::"
 msgstr ""
 "Si querés leer un archivo de inicio adicional desde el directorio actual, "
-"podés programarlo en el archivo de inicio global usando algo como ``if "
-"os.path.isfile('.pythonrc.py'): exec(open('.pythonrc.py').read())``.  Si "
-"querés usar el archivo de inicio en un script, tenés que hacer lo siguiente "
-"de forma explícita en el script::"
+"podés programarlo en el archivo de inicio global usando algo como ``if os."
+"path.isfile('.pythonrc.py'): exec(open('.pythonrc.py').read())``.  Si querés "
+"usar el archivo de inicio en un script, tenés que hacer lo siguiente de "
+"forma explícita en el script::"
 
 #: ../Doc/tutorial/appendix.rst:102
 msgid "The Customization Modules"
@@ -173,34 +173,34 @@ msgstr "Los módulos de customización"
 
 #: ../Doc/tutorial/appendix.rst:104
 msgid ""
-"Python provides two hooks to let you customize it: :mod:`sitecustomize` and "
-":mod:`usercustomize`.  To see how it works, you need first to find the "
+"Python provides two hooks to let you customize it: :mod:`sitecustomize` and :"
+"mod:`usercustomize`.  To see how it works, you need first to find the "
 "location of your user site-packages directory.  Start Python and run this "
 "code::"
 msgstr ""
-"Python provee dos formas para customizarlo: :mod:`sitecustomize` y "
-":mod:`usercustomize`.  Para ver como funciona, necesitás primero encontrar "
-"dónde está tu directorio para tu usuario de paquetes del sistema.  Arrancá "
-"Python y ejecutá el siguiente código::"
+"Python provee dos formas para customizarlo: :mod:`sitecustomize` y :mod:"
+"`usercustomize`.  Para ver como funciona, necesitás primero encontrar dónde "
+"está tu directorio para tu usuario de paquetes del sistema.  Arrancá Python "
+"y ejecutá el siguiente código::"
 
 #: ../Doc/tutorial/appendix.rst:112
 msgid ""
 "Now you can create a file named :file:`usercustomize.py` in that directory "
-"and put anything you want in it.  It will affect every invocation of Python,"
-" unless it is started with the :option:`-s` option to disable the automatic "
+"and put anything you want in it.  It will affect every invocation of Python, "
+"unless it is started with the :option:`-s` option to disable the automatic "
 "import."
 msgstr ""
 "Ahora podés crear un archivo llamado :file:`usercustomize.py` en ese "
 "directorio y poner lo que quieras en él.  Eso afectará cada ejecución de "
-"Python, a menos que se arranque con la opción :option:`-s` para deshabilitar"
-" esta importación automática."
+"Python, a menos que se arranque con la opción :option:`-s` para deshabilitar "
+"esta importación automática."
 
 #: ../Doc/tutorial/appendix.rst:116
 msgid ""
 ":mod:`sitecustomize` works in the same way, but is typically created by an "
 "administrator of the computer in the global site-packages directory, and is "
-"imported before :mod:`usercustomize`.  See the documentation of the "
-":mod:`site` module for more details."
+"imported before :mod:`usercustomize`.  See the documentation of the :mod:"
+"`site` module for more details."
 msgstr ""
 ":mod:`sitecustomize` funciona de la misma manera, pero normalmente lo crea "
 "el administrador de la computadora en el directorio global de paquetes para "
diff --git a/tutorial/classes.po b/tutorial/classes.po
index bdc8b879f3..c0ad48ad33 100644
--- a/tutorial/classes.po
+++ b/tutorial/classes.po
@@ -54,16 +54,16 @@ msgstr ""
 "Programación Orientada a Objetos: el mecanismo de la herencia de clases "
 "permite múltiples clases base, una clase derivada puede sobre escribir "
 "cualquier método de su(s) clase(s) base, y un método puede llamar al método "
-"de la clase base con el mismo nombre.  Los objetos pueden tener una cantidad"
-" arbitraria de datos de cualquier tipo.  Igual que con los módulos, las "
-"clases participan de la naturaleza dinámica de Python: se crean en tiempo de"
-" ejecución, y pueden modificarse luego de la creación."
+"de la clase base con el mismo nombre.  Los objetos pueden tener una cantidad "
+"arbitraria de datos de cualquier tipo.  Igual que con los módulos, las "
+"clases participan de la naturaleza dinámica de Python: se crean en tiempo de "
+"ejecución, y pueden modificarse luego de la creación."
 
 #: ../Doc/tutorial/classes.rst:23
 msgid ""
 "In C++ terminology, normally class members (including the data members) are "
-"*public* (except see below :ref:`tut-private`), and all member functions are"
-" *virtual*.  As in Modula-3, there are no shorthands for referencing the "
+"*public* (except see below :ref:`tut-private`), and all member functions are "
+"*virtual*.  As in Modula-3, there are no shorthands for referencing the "
 "object's members from its methods: the method function is declared with an "
 "explicit first argument representing the object, which is provided "
 "implicitly by the call.  As in Smalltalk, classes themselves are objects.  "
@@ -75,21 +75,21 @@ msgid ""
 msgstr ""
 "En terminología de C++, normalmente los miembros de las clases (incluyendo "
 "los miembros de datos), son *públicos* (excepto ver abajo :ref:`tut-"
-"private`), y todas las funciones miembro son *virtuales*.  Como en Modula-3,"
-" no hay atajos para hacer referencia a los miembros del objeto desde sus "
+"private`), y todas las funciones miembro son *virtuales*.  Como en Modula-3, "
+"no hay atajos para hacer referencia a los miembros del objeto desde sus "
 "métodos: la función método se declara con un primer argumento explícito que "
-"representa al objeto, el cual se provee implícitamente por la llamada.  Como"
-" en Smalltalk, las clases mismas son objetos.  Esto provee una semántica "
-"para importar y renombrar.  A diferencia de C++ y Modula-3, los tipos de "
-"datos integrados pueden usarse como clases base para que el usuario los "
-"extienda.  También, como en C++ pero a diferencia de Modula-3, la mayoría de"
-" los operadores integrados con sintaxis especial (operadores aritméticos, de"
-" subíndice, etc.) pueden ser redefinidos por instancias de la clase."
+"representa al objeto, el cual se provee implícitamente por la llamada.  Como "
+"en Smalltalk, las clases mismas son objetos.  Esto provee una semántica para "
+"importar y renombrar.  A diferencia de C++ y Modula-3, los tipos de datos "
+"integrados pueden usarse como clases base para que el usuario los extienda.  "
+"También, como en C++ pero a diferencia de Modula-3, la mayoría de los "
+"operadores integrados con sintaxis especial (operadores aritméticos, de "
+"subíndice, etc.) pueden ser redefinidos por instancias de la clase."
 
 #: ../Doc/tutorial/classes.rst:34
 msgid ""
-"(Lacking universally accepted terminology to talk about classes, I will make"
-" occasional use of Smalltalk and C++ terms.  I would use Modula-3 terms, "
+"(Lacking universally accepted terminology to talk about classes, I will make "
+"occasional use of Smalltalk and C++ terms.  I would use Modula-3 terms, "
 "since its object-oriented semantics are closer to those of Python than C++, "
 "but I expect that few readers have heard of it.)"
 msgstr ""
@@ -127,9 +127,9 @@ msgstr ""
 "otros tipos.  Esto se usa normalmente para beneficio del programa, ya que "
 "los renombres funcionan como punteros en algunos aspectos.  Por ejemplo, "
 "pasar un objeto es barato ya que la implementación solamente pasa el "
-"puntero; y si una función modifica el objeto que fue pasado, el que la llama"
-" verá el cambio; esto elimina la necesidad de tener dos formas diferentes de"
-" pasar argumentos, como en Pascal."
+"puntero; y si una función modifica el objeto que fue pasado, el que la llama "
+"verá el cambio; esto elimina la necesidad de tener dos formas diferentes de "
+"pasar argumentos, como en Pascal."
 
 #: ../Doc/tutorial/classes.rst:61
 msgid "Python Scopes and Namespaces"
@@ -161,22 +161,22 @@ msgid ""
 "noticeable in any way (except for performance), and it may change in the "
 "future.  Examples of namespaces are: the set of built-in names (containing "
 "functions such as :func:`abs`, and built-in exception names); the global "
-"names in a module; and the local names in a function invocation.  In a sense"
-" the set of attributes of an object also form a namespace.  The important "
+"names in a module; and the local names in a function invocation.  In a sense "
+"the set of attributes of an object also form a namespace.  The important "
 "thing to know about namespaces is that there is absolutely no relation "
 "between names in different namespaces; for instance, two different modules "
 "may both define a function ``maximize`` without confusion --- users of the "
 "modules must prefix it with the module name."
 msgstr ""
 "Un *espacio de nombres* es una relación de nombres a objetos.  Muchos "
-"espacios de nombres están implementados en este momento como diccionarios de"
-" Python, pero eso no se nota para nada (excepto por el desempeño), y puede "
+"espacios de nombres están implementados en este momento como diccionarios de "
+"Python, pero eso no se nota para nada (excepto por el desempeño), y puede "
 "cambiar en el futuro.  Como ejemplos de espacios de nombres tenés: el "
-"conjunto de nombres incluidos (conteniendo funciones como :func:`abs`, y los"
-" nombres de excepciones integradas); los nombres globales en un módulo; y "
-"los nombres locales en la invocación a una función.  Lo que es importante "
-"saber de los espacios de nombres es que no hay relación en absoluto entre "
-"los nombres de espacios de nombres distintos; por ejemplo, dos módulos "
+"conjunto de nombres incluidos (conteniendo funciones como :func:`abs`, y los "
+"nombres de excepciones integradas); los nombres globales en un módulo; y los "
+"nombres locales en la invocación a una función.  Lo que es importante saber "
+"de los espacios de nombres es que no hay relación en absoluto entre los "
+"nombres de espacios de nombres distintos; por ejemplo, dos módulos "
 "diferentes pueden tener definidos los dos una función ``maximizar`` sin "
 "confusión; los usuarios de los módulos deben usar el nombre del módulo como "
 "prefijo."
@@ -186,11 +186,10 @@ msgid ""
 "By the way, I use the word *attribute* for any name following a dot --- for "
 "example, in the expression ``z.real``, ``real`` is an attribute of the "
 "object ``z``.  Strictly speaking, references to names in modules are "
-"attribute references: in the expression ``modname.funcname``, ``modname`` is"
-" a module object and ``funcname`` is an attribute of it.  In this case there"
-" happens to be a straightforward mapping between the module's attributes and"
-" the global names defined in the module: they share the same namespace!  "
-"[#]_"
+"attribute references: in the expression ``modname.funcname``, ``modname`` is "
+"a module object and ``funcname`` is an attribute of it.  In this case there "
+"happens to be a straightforward mapping between the module's attributes and "
+"the global names defined in the module: they share the same namespace!  [#]_"
 msgstr ""
 "Por cierto, yo uso la palabra *atributo* para cualquier cosa después de un "
 "punto; por ejemplo, en la expresión ``z.real``, ``real`` es un atributo del "
@@ -198,8 +197,7 @@ msgstr ""
 "son referencias a atributos: en la expresión ``modulo.funcion``, ``modulo`` "
 "es un objeto módulo y ``funcion`` es un atributo de éste.  En este caso hay "
 "una relación directa entre los atributos del módulo y los nombres globales "
-"definidos en el módulo: ¡están compartiendo el mismo espacio de nombres! "
-"[#]_"
+"definidos en el módulo: ¡están compartiendo el mismo espacio de nombres! [#]_"
 
 #: ../Doc/tutorial/classes.rst:90
 msgid ""
@@ -207,14 +205,13 @@ msgid ""
 "attributes is possible.  Module attributes are writable: you can write "
 "``modname.the_answer = 42``.  Writable attributes may also be deleted with "
 "the :keyword:`del` statement.  For example, ``del modname.the_answer`` will "
-"remove the attribute :attr:`the_answer` from the object named by "
-"``modname``."
+"remove the attribute :attr:`the_answer` from the object named by ``modname``."
 msgstr ""
-"Los atributos pueden ser de sólo lectura, o de escritura.  En el último caso"
-" es posible la asignación a atributos.  Los atributos de módulo pueden "
+"Los atributos pueden ser de sólo lectura, o de escritura.  En el último caso "
+"es posible la asignación a atributos.  Los atributos de módulo pueden "
 "escribirse: ``modulo.la_respuesta = 42``.  Los atributos de escritura se "
-"pueden borrar también con la declaración :keyword:`del`.  Por ejemplo, ``del"
-" modulo.la_respuesta`` va a eliminar el atributo :attr:`la_respuesta` del "
+"pueden borrar también con la declaración :keyword:`del`.  Por ejemplo, ``del "
+"modulo.la_respuesta`` va a eliminar el atributo :attr:`la_respuesta` del "
 "objeto con nombre ``modulo``."
 
 #: ../Doc/tutorial/classes.rst:96
@@ -225,9 +222,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 "
@@ -235,30 +232,30 @@ msgstr ""
 "nombres global de un módulo se crea cuando se lee la definición de un "
 "módulo; normalmente, los espacios de nombres de módulos también duran hasta "
 "que el intérprete finaliza.  Las instrucciones ejecutadas en el nivel de "
-"llamadas superior del intérprete, ya sea desde un script o interactivamente,"
-" se consideran parte del módulo llamado :mod:`__main__`, por lo tanto tienen"
-" su propio espacio de nombres global.  (Los nombres incluidos en realidad "
+"llamadas superior del intérprete, ya sea desde un script o interactivamente, "
+"se consideran parte del módulo llamado :mod:`__main__`, por lo tanto tienen "
+"su propio espacio de nombres global.  (Los nombres incluidos en realidad "
 "también viven en un módulo; este se llama :mod:`builtins`.)"
 
 #: ../Doc/tutorial/classes.rst:106
 msgid ""
 "The local namespace for a function is created when the function is called, "
 "and deleted when the function returns or raises an exception that is not "
-"handled within the function.  (Actually, forgetting would be a better way to"
-" describe what actually happens.)  Of course, recursive invocations each "
-"have their own local namespace."
+"handled within the function.  (Actually, forgetting would be a better way to "
+"describe what actually happens.)  Of course, recursive invocations each have "
+"their own local namespace."
 msgstr ""
 "El espacio de nombres local a una función se crea cuando la función es "
-"llamada, y se elimina cuando la función retorna o lanza una excepción que no"
-" se maneje dentro de la función.  (Podríamos decir que lo que pasa en "
+"llamada, y se elimina cuando la función retorna o lanza una excepción que no "
+"se maneje dentro de la función.  (Podríamos decir que lo que pasa en "
 "realidad es que ese espacio de nombres se \"olvida\".)  Por supuesto, las "
 "llamadas recursivas tienen cada una su propio espacio de nombres local."
 
 #: ../Doc/tutorial/classes.rst:112
 msgid ""
 "A *scope* is a textual region of a Python program where a namespace is "
-"directly accessible.  \"Directly accessible\" here means that an unqualified"
-" reference to a name attempts to find the name in the namespace."
+"directly accessible.  \"Directly accessible\" here means that an unqualified "
+"reference to a name attempts to find the name in the namespace."
 msgstr ""
 "Un *ámbito* es una región textual de un programa en Python donde un espacio "
 "de nombres es accesible directamente.  \"Accesible directamente\" significa "
@@ -267,8 +264,8 @@ msgstr ""
 
 #: ../Doc/tutorial/classes.rst:116
 msgid ""
-"Although scopes are determined statically, they are used dynamically. At any"
-" time during execution, there are at least three nested scopes whose "
+"Although scopes are determined statically, they are used dynamically. At any "
+"time during execution, there are at least three nested scopes whose "
 "namespaces are directly accessible:"
 msgstr ""
 "Aunque los alcances se determinan estáticamente, se usan dinámicamente. En "
@@ -299,11 +296,11 @@ msgstr ""
 msgid ""
 "If a name is declared global, then all references and assignments go "
 "directly to the middle 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 como global, entonces todas las referencias y "
 "asignaciones al mismo van directo al ámbito intermedio que contiene los "
@@ -331,8 +328,8 @@ msgid ""
 "scope of a function defined in a module is that module's namespace, no "
 "matter from where or by what alias the function is called.  On the other "
 "hand, the actual search for names is done dynamically, at run time --- "
-"however, the language definition is evolving towards static name resolution,"
-" at \"compile\" time, so don't rely on dynamic name resolution!  (In fact, "
+"however, the language definition is evolving towards static name resolution, "
+"at \"compile\" time, so don't rely on dynamic name resolution!  (In fact, "
 "local variables are already determined statically.)"
 msgstr ""
 "Es importante notar que los alcances se determinan textualmente: el ámbito "
@@ -346,31 +343,31 @@ msgstr ""
 
 #: ../Doc/tutorial/classes.rst:146
 msgid ""
-"A special quirk of Python is that -- if no :keyword:`global` statement is in"
-" effect -- assignments to names always go into the innermost scope.  "
+"A special quirk of Python is that -- if no :keyword:`global` 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."
+"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 "
@@ -388,8 +385,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:191
 msgid "The output of the example code is:"
@@ -397,20 +394,20 @@ msgstr "El resultado del código ejemplo es:"
 
 #: ../Doc/tutorial/classes.rst:200
 msgid ""
-"Note how the *local* assignment (which is default) didn't change "
-"*scope_test*\\'s binding of *spam*.  The :keyword:`nonlocal` assignment "
-"changed *scope_test*\\'s binding of *spam*, and the :keyword:`global` "
-"assignment changed the module-level binding."
+"Note how the *local* assignment (which is default) didn't change *scope_test*"
+"\\'s binding of *spam*.  The :keyword:`nonlocal` assignment changed "
+"*scope_test*\\'s binding of *spam*, and the :keyword:`global` assignment "
+"changed the module-level binding."
 msgstr ""
 "Notá como la asignación *local* (que es el comportamiento normal) no cambió "
-"la vinculación de *algo* de *prueba_ambitos*.  La asignación "
-":keyword:`nonlocal` cambió la vinculación de *algo* de *prueba_ambitos*, y "
-"la asignación :keyword:`global` cambió la vinculación a nivel de módulo."
+"la vinculación de *algo* de *prueba_ambitos*.  La asignación :keyword:"
+"`nonlocal` cambió la vinculación de *algo* de *prueba_ambitos*, 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 *algo* antes de la "
 "asignación :keyword:`global`."
@@ -450,9 +447,9 @@ msgstr ""
 #: ../Doc/tutorial/classes.rst:236
 msgid ""
 "In practice, the statements inside a class definition will usually be "
-"function definitions, but other statements are allowed, and sometimes useful"
-" --- we'll come back to this later.  The function definitions inside a class"
-" normally have a peculiar form of argument list, dictated by the calling "
+"function definitions, but other statements are allowed, and sometimes useful "
+"--- we'll come back to this later.  The function definitions inside a class "
+"normally have a peculiar form of argument list, dictated by the calling "
 "conventions for methods --- again, this is explained later."
 msgstr ""
 "En la práctica, las declaraciones dentro de una clase son definiciones de "
@@ -466,32 +463,32 @@ msgstr ""
 msgid ""
 "When a class definition is entered, a new namespace is created, and used as "
 "the local scope --- thus, all assignments to local variables go into this "
-"new namespace.  In particular, function definitions bind the name of the new"
-" function here."
+"new namespace.  In particular, function definitions bind the name of the new "
+"function here."
 msgstr ""
 "Cuando se ingresa una definición de clase, se crea un nuevo espacio de "
 "nombres, el cual se usa como ámbito local; por lo tanto, todas las "
 "asignaciones a variables locales van a este nuevo espacio de nombres.  En "
-"particular, las definiciones de funciones asocian el nombre de las funciones"
-" nuevas allí."
+"particular, las definiciones de funciones asocian el nombre de las funciones "
+"nuevas allí."
 
 #: ../Doc/tutorial/classes.rst:247
 msgid ""
 "When a class definition is left normally (via the end), a *class object* is "
 "created.  This is basically a wrapper around the contents of the namespace "
-"created by the class definition; we'll learn more about class objects in the"
-" next section.  The original local scope (the one in effect just before the "
+"created by the class definition; we'll learn more about class objects in the "
+"next section.  The original local scope (the one in effect just before the "
 "class definition was entered) is reinstated, and the class object is bound "
-"here to the class name given in the class definition header "
-"(:class:`ClassName` in the example)."
+"here to the class name given in the class definition header (:class:"
+"`ClassName` in the example)."
 msgstr ""
 "Cuando una definición de clase se finaliza normalmente se crea un *objeto "
 "clase*.  Básicamente, este objeto envuelve los contenidos del espacio de "
-"nombres creado por la definición de la clase; aprenderemos más acerca de los"
-" objetos clase en la sección siguiente.  El ámbito local original (el que "
+"nombres creado por la definición de la clase; aprenderemos más acerca de los "
+"objetos clase en la sección siguiente.  El ámbito local original (el que "
 "tenía efecto justo antes de que ingrese la definición de la clase) es "
-"restablecido, y el objeto clase se asocia allí al nombre que se le puso a la"
-" clase en el encabezado de su definición (:class:`Clase` en el ejemplo)."
+"restablecido, y el objeto clase se asocia allí al nombre que se le puso a la "
+"clase en el encabezado de su definición (:class:`Clase` en el ejemplo)."
 
 #: ../Doc/tutorial/classes.rst:259
 msgid "Class Objects"
@@ -508,15 +505,15 @@ msgstr ""
 #: ../Doc/tutorial/classes.rst:264
 msgid ""
 "*Attribute references* use the standard syntax used for all attribute "
-"references in Python: ``obj.name``.  Valid attribute names are all the names"
-" that were in the class's namespace when the class object was created.  So, "
+"references in Python: ``obj.name``.  Valid attribute names are all the names "
+"that were in the class's namespace when the class object was created.  So, "
 "if the class definition looked like this::"
 msgstr ""
-"Para *hacer referencia a atributos* se usa la sintaxis estándar de todas las"
-" referencias a atributos en Python: ``objeto.nombre``.  Los nombres de "
+"Para *hacer referencia a atributos* se usa la sintaxis estándar de todas las "
+"referencias a atributos en Python: ``objeto.nombre``.  Los nombres de "
 "atributo válidos son todos los nombres que estaban en el espacio de nombres "
-"de la clase cuando ésta se creó.  Por lo tanto, si la definición de la clase"
-" es así::"
+"de la clase cuando ésta se creó.  Por lo tanto, si la definición de la clase "
+"es así::"
 
 #: ../Doc/tutorial/classes.rst:276
 msgid ""
@@ -530,14 +527,14 @@ msgstr ""
 "válidas, que devuelven 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 ``MiClase.i`` mediante asignación.  :attr:`__doc__` también es un "
-"atributo válido, que devuelve la documentación asociada a la clase: "
-"``\"Simple clase de ejemplo\"``."
+"atributo válido, que devuelve la documentación asociada a la clase: ``"
+"\"Simple clase de ejemplo\"``."
 
 #: ../Doc/tutorial/classes.rst:282
 msgid ""
 "Class *instantiation* uses function notation.  Just pretend that the class "
-"object is a parameterless function that returns a new instance of the class."
-" For example (assuming the above class)::"
+"object is a parameterless function that returns a new instance of the class. "
+"For example (assuming the above class)::"
 msgstr ""
 "La *instanciación* de clases usa la notación de funciones.  Hacé de cuenta "
 "que el objeto de clase es una función sin parámetros que devuelve una nueva "
@@ -548,26 +545,27 @@ msgid ""
 "creates a new *instance* of the class and assigns this object to the local "
 "variable ``x``."
 msgstr ""
-"...crea una nueva *instancia* de la clase y asigna este objeto a la variable"
-" local ``x``."
+"...crea una nueva *instancia* de la clase y asigna este objeto a la variable "
+"local ``x``."
 
 #: ../Doc/tutorial/classes.rst:291
 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:`__init__`, like this::"
+"specific initial state. Therefore a class may define a special method named :"
+"meth:`__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 "
-"inicial particular.  Por lo tanto una clase puede definir un método especial"
-" llamado :meth:`__init__`, de esta forma::"
+"inicial particular.  Por lo tanto una clase puede definir un método especial "
+"llamado :meth:`__init__`, de esta forma::"
 
 #: ../Doc/tutorial/classes.rst:299
 msgid ""
 "When a class defines an :meth:`__init__` method, class instantiation "
-"automatically invokes :meth:`__init__` for the newly-created class instance."
-"  So in this example, a new, initialized instance can be obtained by::"
+"automatically invokes :meth:`__init__` for the newly-created class "
+"instance.  So in this example, a new, initialized instance can be obtained "
+"by::"
 msgstr ""
 "Cuando una clase define un método :meth:`__init__`, la instanciación de la "
 "clase automáticamente invoca a :meth:`__init__` para la instancia recién "
@@ -591,12 +589,12 @@ msgstr "Objetos instancia"
 
 #: ../Doc/tutorial/classes.rst:324
 msgid ""
-"Now what can we do with instance objects?  The only operations understood by"
-" instance objects are attribute references.  There are two kinds of valid "
+"Now what can we do with instance objects?  The only operations understood by "
+"instance objects are attribute references.  There are two kinds of valid "
 "attribute names, data attributes and methods."
 msgstr ""
-"Ahora, ¿Qué podemos hacer con los objetos instancia?  La única operación que"
-" es entendida por los objetos instancia es la referencia de atributos.  Hay "
+"Ahora, ¿Qué podemos hacer con los objetos instancia?  La única operación que "
+"es entendida por los objetos instancia es la referencia de atributos.  Hay "
 "dos tipos de nombres de atributos válidos, atributos de datos y métodos."
 
 #: ../Doc/tutorial/classes.rst:328
@@ -619,16 +617,16 @@ msgstr ""
 msgid ""
 "The other kind of instance attribute reference is a *method*. A method is a "
 "function that \"belongs to\" an object.  (In Python, the term method is not "
-"unique to class instances: other object types can have methods as well.  For"
-" example, list objects have methods called append, insert, remove, sort, and"
-" so on. However, in the following discussion, we'll use the term method "
+"unique to class instances: other object types can have methods as well.  For "
+"example, list objects have methods called append, insert, remove, sort, and "
+"so on. However, in the following discussion, we'll use the term method "
 "exclusively to mean methods of class instance objects, unless explicitly "
 "stated otherwise.)"
 msgstr ""
 "El otro tipo de atributo de instancia es el *método*.  Un método es una "
-"función que \"pertenece a\" un objeto.  En Python, el término método no está"
-" limitado a instancias de clase: otros tipos de objetos pueden tener métodos"
-" también.  Por ejemplo, los objetos lista tienen métodos llamados append, "
+"función que \"pertenece a\" un objeto.  En Python, el término método no está "
+"limitado a instancias de clase: otros tipos de objetos pueden tener métodos "
+"también.  Por ejemplo, los objetos lista tienen métodos llamados append, "
 "insert, remove, sort, y así sucesivamente.  Pero, en la siguiente "
 "explicación, usaremos el término método para referirnos exclusivamente a "
 "métodos de objetos instancia de clase, a menos que se especifique "
@@ -646,10 +644,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 "
-"``MiClase.f`` es una función, pero ``x.i`` no lo es, dado que ``MiClase.i`` "
-"no lo es.  Pero ``x.f`` no es la misma cosa que ``MiClase.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 ``MiClase."
+"f`` es una función, pero ``x.i`` no lo es, dado que ``MiClase.i`` no lo es.  "
+"Pero ``x.f`` no es la misma cosa que ``MiClase.f``; es un *objeto método*, "
+"no un objeto función."
 
 #: ../Doc/tutorial/classes.rst:360
 msgid "Method Objects"
@@ -676,47 +674,47 @@ msgstr "...continuará imprimiendo ``hola mundo`` hasta el fin de los días."
 
 #: ../Doc/tutorial/classes.rst:376
 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 "
+"argument? Surely Python raises an exception when a function that requires an "
+"argument is called without any --- even if the argument isn't actually "
 "used..."
 msgstr ""
-"¿Qué sucede exactamente cuando un método es llamado?  Debés haber notado que"
-" ``x.f()`` fue llamado más arriba sin ningún argumento, a pesar de que la "
-"definición de función de :meth:`f` especificaba un argumento.  ¿Qué pasó con"
-" ese argumento?  Seguramente Python levanta una excepción cuando una función"
-" que requiere un argumento es llamada sin ninguno, aún si el argumento no es"
-" utilizado..."
+"¿Qué sucede exactamente cuando un método es llamado?  Debés haber notado que "
+"``x.f()`` fue llamado más arriba sin ningún argumento, a pesar de que la "
+"definición de función de :meth:`f` especificaba un argumento.  ¿Qué pasó con "
+"ese argumento?  Seguramente Python levanta una excepción cuando una función "
+"que requiere un argumento es llamada sin ninguno, aún si el argumento no es "
+"utilizado..."
 
 #: ../Doc/tutorial/classes.rst:382
 msgid ""
 "Actually, you may have guessed the answer: the special thing about methods "
-"is that the instance object is passed as the first argument of the function."
-"  In our example, the call ``x.f()`` is exactly equivalent to "
-"``MyClass.f(x)``.  In general, calling a method with a list of *n* arguments"
-" is equivalent to calling the corresponding function with an argument list "
+"is that the instance object is passed as the first argument of the "
+"function.  In our example, the call ``x.f()`` is exactly equivalent to "
+"``MyClass.f(x)``.  In general, calling a method with a list of *n* arguments "
+"is equivalent to calling the corresponding function with an argument list "
 "that is created by inserting the method's instance object before the first "
 "argument."
 msgstr ""
 "De hecho, tal vez hayas adivinado la respuesta: lo que tienen de especial "
 "los métodos es que el objeto es pasado como el primer argumento de la "
-"función. En nuestro ejemplo, la llamada ``x.f()`` es exactamente equivalente"
-" a ``MiClase.f(x)``.  En general, llamar a un método con una lista de *n* "
+"función. En nuestro ejemplo, la llamada ``x.f()`` es exactamente equivalente "
+"a ``MiClase.f(x)``.  En general, llamar a un método con una lista de *n* "
 "argumentos es equivalente a llamar a la función correspondiente con una "
 "lista de argumentos que es creada insertando el objeto del método antes del "
 "primer argumento."
 
 #: ../Doc/tutorial/classes.rst:389
 msgid ""
-"If you still don't understand how methods work, a look at the implementation"
-" can perhaps clarify matters.  When a non-data attribute of an instance is "
+"If you still don't understand how methods work, a look at the implementation "
+"can perhaps clarify matters.  When a non-data attribute of an instance is "
 "referenced, the instance's class is searched.  If the name denotes a valid "
 "class attribute that is a function object, a method object is created by "
-"packing (pointers to) the instance object and the function object just found"
-" together in an abstract object: this is the method object.  When the method"
-" object is called with an argument list, a new argument list is constructed "
+"packing (pointers to) the instance object and the function object just found "
+"together in an abstract object: this is the method object.  When the method "
+"object is called with an argument list, a new argument list is constructed "
 "from the instance object and the argument list, and the function object is "
 "called with this new argument list."
 msgstr ""
@@ -743,8 +741,8 @@ msgid ""
 "not be used as a class variable because just a single list would be shared "
 "by all *Dog* instances::"
 msgstr ""
-"Como se vió en :ref:`tut-object`, los datos compartidos pueden tener efectos"
-" inesperados que involucren objetos :term:`mutables` como ser listas y "
+"Como se vió en :ref:`tut-object`, los datos compartidos pueden tener efectos "
+"inesperados que involucren objetos :term:`mutables` como ser listas y "
 "diccionarios. Por ejemplo, la lista *trucos* en el siguiente código no "
 "debería ser usada como variable de clase porque una sola lista sería "
 "compartida por todos las instancias de *Perro*::"
@@ -772,8 +770,8 @@ msgstr ""
 "nombre; para evitar conflictos de nombre accidentales, que pueden causar "
 "errores difíciles de encontrar en programas grandes, es prudente usar algún "
 "tipo de convención que minimice las posibilidades de dichos conflictos. "
-"Algunas convenciones pueden ser poner los nombres de métodos con mayúsculas,"
-" prefijar los nombres de atributos de datos con una pequeña cadena única (a "
+"Algunas convenciones pueden ser poner los nombres de métodos con mayúsculas, "
+"prefijar los nombres de atributos de datos con una pequeña cadena única (a "
 "lo mejor sólo un guión bajo), o usar verbos para los métodos y sustantivos "
 "para los atributos."
 
@@ -783,44 +781,44 @@ msgid ""
 "(\"clients\") of an object.  In other words, classes are not usable to "
 "implement pure abstract data types.  In fact, nothing in Python makes it "
 "possible to enforce data hiding --- it is all based upon convention.  (On "
-"the other hand, the Python implementation, written in C, can completely hide"
-" implementation details and control access to an object if necessary; this "
+"the other hand, the Python implementation, written in C, can completely hide "
+"implementation details and control access to an object if necessary; this "
 "can be used by extensions to Python written in C.)"
 msgstr ""
 "A los atributos de datos los pueden hacer referencia tanto los métodos como "
-"los usuarios (\"clientes\") ordinarios de un objeto.  En otras palabras, las"
-" clases no se usan para implementar tipos de datos abstractos puros.  De "
-"hecho, en Python no hay nada que haga cumplir el ocultar datos; todo se basa"
-" en convención.  (Por otro lado, la implementación de Python, escrita en C, "
-"puede ocultar por completo detalles de implementación y el control de acceso"
-" a un objeto si es necesario; esto se puede usar en extensiones a Python "
+"los usuarios (\"clientes\") ordinarios de un objeto.  En otras palabras, las "
+"clases no se usan para implementar tipos de datos abstractos puros.  De "
+"hecho, en Python no hay nada que haga cumplir el ocultar datos; todo se basa "
+"en convención.  (Por otro lado, la implementación de Python, escrita en C, "
+"puede ocultar por completo detalles de implementación y el control de acceso "
+"a un objeto si es necesario; esto se puede usar en extensiones a Python "
 "escritas en C.)"
 
 #: ../Doc/tutorial/classes.rst:493
 msgid ""
 "Clients should use data attributes with care --- clients may mess up "
 "invariants maintained by the methods by stamping on their data attributes.  "
-"Note that clients may add data attributes of their own to an instance object"
-" without affecting the validity of the methods, as long as name conflicts "
-"are avoided --- again, a naming convention can save a lot of headaches here."
+"Note that clients may add data attributes of their own to an instance object "
+"without affecting the validity of the methods, as long as name conflicts are "
+"avoided --- again, a naming convention can save a lot of headaches here."
 msgstr ""
 "Los clientes deben usar los atributos de datos con cuidado; éstos pueden "
 "romper invariantes que mantienen los métodos si pisan los atributos de "
-"datos. Observá que los clientes pueden añadir sus propios atributos de datos"
-" a una instancia sin afectar la validez de sus métodos, siempre y cuando se "
+"datos. Observá que los clientes pueden añadir sus propios atributos de datos "
+"a una instancia sin afectar la validez de sus métodos, siempre y cuando se "
 "eviten conflictos de nombres; de nuevo, una convención de nombres puede "
 "ahorrar un montón de dolores de cabeza."
 
 #: ../Doc/tutorial/classes.rst:499
 msgid ""
 "There is no shorthand for referencing data attributes (or other methods!) "
-"from within methods.  I find that this actually increases the readability of"
-" methods: there is no chance of confusing local variables and instance "
+"from within methods.  I find that this actually increases the readability of "
+"methods: there is no chance of confusing local variables and instance "
 "variables when glancing through a method."
 msgstr ""
 "No hay un atajo para hacer referencia a atributos de datos (¡u otros "
-"métodos!) desde dentro de un método.  A mi parecer, esto en realidad aumenta"
-" la legibilidad de los métodos: no existe posibilidad alguna de confundir "
+"métodos!) desde dentro de un método.  A mi parecer, esto en realidad aumenta "
+"la legibilidad de los métodos: no existe posibilidad alguna de confundir "
 "variables locales con variables de instancia cuando repasamos un método."
 
 #: ../Doc/tutorial/classes.rst:504
@@ -828,41 +826,41 @@ msgid ""
 "Often, the first argument of a method is called ``self``.  This is nothing "
 "more than a convention: the name ``self`` has absolutely no special meaning "
 "to Python.  Note, however, that by not following the convention your code "
-"may be less readable to other Python programmers, and it is also conceivable"
-" that a *class browser* program might be written that relies upon such a "
+"may be less readable to other Python programmers, and it is also conceivable "
+"that a *class browser* program might be written that relies upon such a "
 "convention."
 msgstr ""
 "A menudo, el primer argumento de un método se llama ``self`` (uno mismo).  "
-"Esto no es nada más que una convención: el nombre ``self`` no significa nada"
-" en especial para Python.  Observá que, sin embargo, si no seguís la "
+"Esto no es nada más que una convención: el nombre ``self`` no significa nada "
+"en especial para Python.  Observá que, sin embargo, si no seguís la "
 "convención tu código puede resultar menos legible a otros programadores de "
 "Python, y puede llegar a pasar que un programa *navegador de clases* pueda "
 "escribirse de una manera que dependa de dicha convención."
 
 #: ../Doc/tutorial/classes.rst:510
 msgid ""
-"Any function object that is a class attribute defines a method for instances"
-" of that class.  It is not necessary that the function definition is "
-"textually enclosed in the class definition: assigning a function object to a"
-" local variable in the class is also ok.  For example::"
+"Any function object that is a class attribute defines a method for instances "
+"of that class.  It is not necessary that the function definition is "
+"textually enclosed in the class definition: assigning a function object to a "
+"local variable in the class is also ok.  For example::"
 msgstr ""
 "Cualquier objeto función que es un atributo de clase define un método para "
-"instancias de esa clase.  No es necesario que el la definición de la función"
-" esté textualmente dentro de la definición de la clase: asignando un objeto "
+"instancias de esa clase.  No es necesario que el la definición de la función "
+"esté textualmente dentro de la definición de la clase: asignando un objeto "
 "función a una variable local en la clase también está bien.  Por ejemplo::"
 
 #: ../Doc/tutorial/classes.rst:527
 msgid ""
-"Now ``f``, ``g`` and ``h`` are all attributes of class :class:`C` that refer"
-" to function objects, and consequently they are all methods of instances of "
-":class:`C` --- ``h`` being exactly equivalent to ``g``.  Note that this "
+"Now ``f``, ``g`` and ``h`` are all attributes of class :class:`C` that refer "
+"to function objects, and consequently they are all methods of instances of :"
+"class:`C` --- ``h`` being exactly equivalent to ``g``.  Note that this "
 "practice usually only serves to confuse the reader of a program."
 msgstr ""
 "Ahora ``f``, ``g`` y ``h`` son todos atributos de la clase :class:`C` que "
 "hacen referencia a objetos función, y consecuentemente son todos métodos de "
 "las instancias de :class:`C`; ``h`` siendo exactamente equivalente a ``g``. "
-"Fijate que esta práctica normalmente sólo sirve para confundir al que lea un"
-" programa."
+"Fijate que esta práctica normalmente sólo sirve para confundir al que lea un "
+"programa."
 
 #: ../Doc/tutorial/classes.rst:532
 msgid ""
@@ -881,8 +879,8 @@ msgid ""
 "legitimate uses of the global scope: for one thing, functions and modules "
 "imported into the global scope can be used by methods, as well as functions "
 "and classes defined in it.  Usually, the class containing the method is "
-"itself defined in this global scope, and in the next section we'll find some"
-" good reasons why a method would want to reference its own class."
+"itself defined in this global scope, and in the next section we'll find some "
+"good reasons why a method would want to reference its own class."
 msgstr ""
 "Los métodos pueden hacer referencia a nombres globales de la misma manera "
 "que lo hacen las funciones comunes.  El ámbito global asociado a un método "
@@ -892,8 +890,8 @@ msgstr ""
 "menos, las funciones y módulos importados en el ámbito global pueden usarse "
 "por los métodos, al igual que las funciones y clases definidas en él. "
 "Habitualmente, la clase que contiene el método está definida en este ámbito "
-"global, y en la siguiente sección veremos algunas buenas razones por las que"
-" un método querría hacer referencia a su propia clase."
+"global, y en la siguiente sección veremos algunas buenas razones por las que "
+"un método querría hacer referencia a su propia clase."
 
 #: ../Doc/tutorial/classes.rst:556
 msgid ""
@@ -924,25 +922,25 @@ msgid ""
 "expressions are also allowed.  This can be useful, for example, when the "
 "base class is defined in another module::"
 msgstr ""
-"El nombre :class:`ClaseBase` debe estar definido en un ámbito que contenga a"
-" la definición de la clase derivada.  En el lugar del nombre de la clase "
-"base se permiten otras expresiones arbitrarias.  Esto puede ser útil, por "
+"El nombre :class:`ClaseBase` debe estar definido en un ámbito que contenga a "
+"la definición de la clase derivada.  En el lugar del nombre de la clase base "
+"se permiten otras expresiones arbitrarias.  Esto puede ser útil, por "
 "ejemplo, cuando la clase base está definida en otro módulo::"
 
 #: ../Doc/tutorial/classes.rst:583
 msgid ""
 "Execution of a derived class definition proceeds the same as for a base "
 "class. When the class object is constructed, the base class is remembered.  "
-"This is used for resolving attribute references: if a requested attribute is"
-" not found in the class, the search proceeds to look in the base class.  "
-"This rule is applied recursively if the base class itself is derived from "
-"some other class."
+"This is used for resolving attribute references: if a requested attribute is "
+"not found in the class, the search proceeds to look in the base class.  This "
+"rule is applied recursively if the base class itself is derived from some "
+"other class."
 msgstr ""
 "La ejecución de una definición de clase derivada procede de la misma forma "
-"que una clase base.  Cuando el objeto clase se construye, se tiene en cuenta"
-" a la clase base.  Esto se usa para resolver referencias a atributos: si un "
-"atributo solicitado no se encuentra en la clase, la búsqueda continúa por la"
-" clase base. Esta regla se aplica recursivamente si la clase base misma "
+"que una clase base.  Cuando el objeto clase se construye, se tiene en cuenta "
+"a la clase base.  Esto se usa para resolver referencias a atributos: si un "
+"atributo solicitado no se encuentra en la clase, la búsqueda continúa por la "
+"clase base. Esta regla se aplica recursivamente si la clase base misma "
 "deriva de alguna otra clase."
 
 #: ../Doc/tutorial/classes.rst:589
@@ -954,41 +952,41 @@ msgid ""
 "method reference is valid if this yields a function object."
 msgstr ""
 "No hay nada en especial en la instanciación de clases derivadas: "
-"``ClaseDerivada()`` crea una nueva instancia de la clase.  Las referencias a"
-" métodos se resuelven de la siguiente manera: se busca el atributo de clase "
+"``ClaseDerivada()`` crea una nueva instancia de la clase.  Las referencias a "
+"métodos se resuelven de la siguiente manera: se busca el atributo de clase "
 "correspondiente, descendiendo por la cadena de clases base si es necesario, "
 "y la referencia al método es válida si se entrega un objeto función."
 
 #: ../Doc/tutorial/classes.rst:595
 msgid ""
-"Derived classes may override methods of their base classes.  Because methods"
-" have no special privileges when calling other methods of the same object, a"
-" method of a base class that calls another method defined in the same base "
+"Derived classes may override methods of their base classes.  Because methods "
+"have no special privileges when calling other methods of the same object, a "
+"method of a base class that calls another method defined in the same base "
 "class may end up calling a method of a derived class that overrides it.  "
 "(For C++ programmers: all methods in Python are effectively ``virtual``.)"
 msgstr ""
 "Las clases derivadas pueden redefinir métodos de su clase base.  Como los "
 "métodos no tienen privilegios especiales cuando llaman a otros métodos del "
-"mismo objeto, un método de la clase base que llame a otro método definido en"
-" la misma clase base puede terminar llamando a un método de la clase "
-"derivada que lo haya redefinido.  (Para los programadores de C++: en Python "
-"todos los métodos son en efecto ``virtuales``.)"
+"mismo objeto, un método de la clase base que llame a otro método definido en "
+"la misma clase base puede terminar llamando a un método de la clase derivada "
+"que lo haya redefinido.  (Para los programadores de C++: en Python todos los "
+"métodos son en efecto ``virtuales``.)"
 
 #: ../Doc/tutorial/classes.rst:601
 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 "
+"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 "
 "nombre. Hay una manera simple de llamar al método de la clase base "
 "directamente: simplemente llamás a ``ClaseBase.metodo(self, argumentos)``.  "
-"En ocasiones esto es útil para los clientes también.  (Observá que esto sólo"
-" funciona si la clase base es accesible como ``ClaseBase`` en el ámbito "
+"En ocasiones esto es útil para los clientes también.  (Observá que esto sólo "
+"funciona si la clase base es accesible como ``ClaseBase`` en el ámbito "
 "global.)"
 
 #: ../Doc/tutorial/classes.rst:608
@@ -997,15 +995,15 @@ msgstr "Python tiene dos funciones integradas que funcionan con herencia:"
 
 #: ../Doc/tutorial/classes.rst:610
 msgid ""
-"Use :func:`isinstance` to check an instance's type: ``isinstance(obj, int)``"
-" will be ``True`` only if ``obj.__class__`` is :class:`int` or some class "
+"Use :func:`isinstance` to check an instance's type: ``isinstance(obj, int)`` "
+"will be ``True`` only if ``obj.__class__`` is :class:`int` or some class "
 "derived from :class:`int`."
 msgstr ""
 
 #: ../Doc/tutorial/classes.rst:614
 msgid ""
-"Use :func:`issubclass` to check class inheritance: ``issubclass(bool, int)``"
-" is ``True`` since :class:`bool` is a subclass of :class:`int`.  However, "
+"Use :func:`issubclass` to check class inheritance: ``issubclass(bool, int)`` "
+"is ``True`` since :class:`bool` is a subclass of :class:`int`.  However, "
 "``issubclass(float, int)`` is ``False`` since :class:`float` is not a "
 "subclass of :class:`int`."
 msgstr ""
@@ -1028,16 +1026,16 @@ msgid ""
 "attributes inherited from a parent class as depth-first, left-to-right, not "
 "searching twice in the same class where there is an overlap in the "
 "hierarchy. Thus, if an attribute is not found in :class:`DerivedClassName`, "
-"it is searched for in :class:`Base1`, then (recursively) in the base classes"
-" of :class:`Base1`, and if it was not found there, it was searched for in "
-":class:`Base2`, and so on."
+"it is searched for in :class:`Base1`, then (recursively) in the base classes "
+"of :class:`Base1`, and if it was not found there, it was searched for in :"
+"class:`Base2`, and so on."
 msgstr ""
-"Para la mayoría de los propósitos, en los casos más simples, podés pensar en"
-" la búsqueda de los atributos heredados de clases padres como primero en "
+"Para la mayoría de los propósitos, en los casos más simples, podés pensar en "
+"la búsqueda de los atributos heredados de clases padres como primero en "
 "profundidad, de izquierda a derecha, sin repetir la misma clase cuando está "
-"dos veces en la jerarquía.  Por lo tanto, si un atributo no se encuentra en "
-":class:`ClaseDerivada`, se busca en :class:`Base1`, luego (recursivamente) "
-"en las clases base de :class:`Base1`, y sólo si no se encuentra allí se lo "
+"dos veces en la jerarquía.  Por lo tanto, si un atributo no se encuentra en :"
+"class:`ClaseDerivada`, se busca en :class:`Base1`, luego (recursivamente) en "
+"las clases base de :class:`Base1`, y sólo si no se encuentra allí se lo "
 "busca en :class:`Base2`, y así sucesivamente."
 
 #: ../Doc/tutorial/classes.rst:643
@@ -1049,10 +1047,10 @@ 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:649
 msgid ""
@@ -1067,20 +1065,20 @@ msgid ""
 "and that is monotonic (meaning that a class can be subclassed without "
 "affecting the precedence order of its parents). Taken together, these "
 "properties make it possible to design reliable and extensible classes with "
-"multiple inheritance.  For more detail, see "
-"https://www.python.org/download/releases/2.3/mro/."
+"multiple inheritance.  For more detail, see https://www.python.org/download/"
+"releases/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 "
+"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 "
+"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 "
+"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/."
 
@@ -1090,8 +1088,8 @@ msgstr "Variables privadas"
 
 #: ../Doc/tutorial/classes.rst:668
 msgid ""
-"\"Private\" instance variables that cannot be accessed except from inside an"
-" object don't exist in Python.  However, there is a convention that is "
+"\"Private\" instance variables that cannot be accessed except from inside an "
+"object don't exist in Python.  However, there is a convention that is "
 "followed by most Python code: a name prefixed with an underscore (e.g. "
 "``_spam``) should be treated as a non-public part of the API (whether it is "
 "a function, a method or a data member).  It should be considered an "
@@ -1099,8 +1097,8 @@ msgid ""
 msgstr ""
 "Las variables \"privadas\" de instancia, que no pueden accederse excepto "
 "desde dentro de un objeto, no existen en Python.  Sin embargo, hay una "
-"convención que se sigue en la mayoría del código Python: un nombre prefijado"
-" con un guión bajo (por ejemplo, ``_spam``) debería tratarse como una parte "
+"convención que se sigue en la mayoría del código Python: un nombre prefijado "
+"con un guión bajo (por ejemplo, ``_spam``) debería tratarse como una parte "
 "no pública de la API (más allá de que sea una función, un método, o un "
 "dato).  Debería considerarse un detalle de implementación y que está sujeto "
 "a cambios sin aviso."
@@ -1112,9 +1110,9 @@ msgid ""
 "support for such a mechanism, called :dfn:`name mangling`.  Any identifier "
 "of the form ``__spam`` (at least two leading underscores, at most one "
 "trailing underscore) is textually replaced with ``_classname__spam``, where "
-"``classname`` is the current class name with leading underscore(s) stripped."
-"  This mangling is done without regard to the syntactic position of the "
-"identifier, as long as it occurs within the definition of a class."
+"``classname`` is the current class name with leading underscore(s) "
+"stripped.  This mangling is done without regard to the syntactic position of "
+"the identifier, as long as it occurs within the definition of a class."
 msgstr ""
 "Ya que hay un caso de uso válido para los identificadores privados de clase "
 "(a saber: colisión de nombres con nombres definidos en las subclases), hay "
@@ -1137,8 +1135,8 @@ msgstr ""
 
 #: ../Doc/tutorial/classes.rst:709
 msgid ""
-"The above example would work even if ``MappingSubclass`` were to introduce a"
-" ``__update`` identifier since it is replaced with ``_Mapping__update`` in "
+"The above example would work even if ``MappingSubclass`` were to introduce a "
+"``__update`` identifier since it is replaced with ``_Mapping__update`` in "
 "the ``Mapping`` class  and ``_MappingSubclass__update`` in the "
 "``MappingSubclass`` class respectively."
 msgstr ""
@@ -1146,13 +1144,14 @@ msgstr ""
 #: ../Doc/tutorial/classes.rst:714
 msgid ""
 "Note that the mangling rules are designed mostly to avoid accidents; it "
-"still is possible to access or modify a variable that is considered private."
-"  This can even be useful in special circumstances, such as in the debugger."
+"still is possible to access or modify a variable that is considered "
+"private.  This can even be useful in special circumstances, such as in the "
+"debugger."
 msgstr ""
 "Hay que aclarar que las reglas de modificación de nombres están diseñadas "
 "principalmente para evitar accidentes; es posible acceder o modificar una "
-"variable que es considerada como privada.  Esto hasta puede resultar útil en"
-" circunstancias especiales, tales como en el depurador."
+"variable que es considerada como privada.  Esto hasta puede resultar útil en "
+"circunstancias especiales, tales como en el depurador."
 
 #: ../Doc/tutorial/classes.rst:718
 msgid ""
@@ -1187,24 +1186,24 @@ msgstr ""
 #: ../Doc/tutorial/classes.rst:745
 msgid ""
 "A piece of Python code that expects a particular abstract data type can "
-"often be passed a class that emulates the methods of that data type instead."
-"  For instance, if you have a function that formats some data from a file "
-"object, you can define a class with methods :meth:`read` and "
-":meth:`!readline` that get the data from a string buffer instead, and pass "
-"it as an argument."
+"often be passed a class that emulates the methods of that data type "
+"instead.  For instance, if you have a function that formats some data from a "
+"file object, you can define a class with methods :meth:`read` and :meth:`!"
+"readline` that get the data from a string buffer instead, and pass it as an "
+"argument."
 msgstr ""
 "Algún código Python que espera un tipo abstracto de datos en particular "
 "puede frecuentemente recibir en cambio una clase que emula los métodos de "
-"aquel tipo de datos.  Por ejemplo, si tenés una función que formatea algunos"
-" datos a partir de un objeto archivo, podés definir una clase con métodos "
-":meth:`read` y :meth:`!readline` que obtengan los datos de alguna cadena en "
+"aquel tipo de datos.  Por ejemplo, si tenés una función que formatea algunos "
+"datos a partir de un objeto archivo, podés definir una clase con métodos :"
+"meth:`read` y :meth:`!readline` que obtengan los datos de alguna cadena en "
 "memoria intermedia, y pasarlo como argumento."
 
 #: ../Doc/tutorial/classes.rst:756
 msgid ""
-"Instance method objects have attributes, too: ``m.__self__`` is the instance"
-" object with the method :meth:`m`, and ``m.__func__`` is the function object"
-" corresponding to the method."
+"Instance method objects have attributes, too: ``m.__self__`` is the instance "
+"object with the method :meth:`m`, and ``m.__func__`` is the function object "
+"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 "
@@ -1225,24 +1224,24 @@ msgstr ""
 #: ../Doc/tutorial/classes.rst:780
 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 "
-"devuelve 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__` levanta 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:`~iterator.__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 "
+"devuelve 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__` levanta 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:"
+"`~iterator.__next__`; este ejemplo muestra como funciona todo esto::"
 
 #: ../Doc/tutorial/classes.rst:805
 msgid ""
@@ -1253,8 +1252,8 @@ msgid ""
 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:`__iter__` "
-"que devuelva un objeto con un método :meth:`__next__`.  Si la clase define "
-":meth:`__next__`, entonces alcanza con que :meth:`__iter__` devuelva "
+"que devuelva un objeto con un método :meth:`__next__`.  Si la clase define :"
+"meth:`__next__`, entonces alcanza con que :meth:`__iter__` devuelva "
 "``self``::"
 
 #: ../Doc/tutorial/classes.rst:842
@@ -1263,43 +1262,43 @@ msgstr "Generadores"
 
 #: ../Doc/tutorial/classes.rst:844
 msgid ""
-":term:`Generator`\\s are a simple and powerful tool for creating iterators."
-"  They are written like regular functions but use the :keyword:`yield` "
+":term:`Generator`\\s 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::"
 msgstr ""
 "Los `generadores` son una simple y poderosa herramienta para crear "
-"iteradores.  Se escriben como funciones regulares pero usan la sentencia "
-":keyword:`yield` cuando quieren devolver datos.  Cada vez que se llama "
-":func:`next` sobre él, el generador continúa desde donde dejó (y recuerda "
-"todos los valores de datos y cual sentencia fue ejecutada última).  Un "
-"ejemplo muestra que los generadores pueden ser muy fáciles de crear::"
+"iteradores.  Se escriben como funciones regulares pero usan la sentencia :"
+"keyword:`yield` cuando quieren devolver datos.  Cada vez que se llama :func:"
+"`next` sobre él, el generador continúa desde donde dejó (y recuerda todos "
+"los valores de datos y cual sentencia fue ejecutada última).  Un ejemplo "
+"muestra que los generadores pueden ser muy fáciles de crear::"
 
 #: ../Doc/tutorial/classes.rst:865
 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:`__iter__` and :meth:`~generator.__next__` methods"
-" are created automatically."
+"compact is that the :meth:`__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:`__iter__` y :meth:`__next__` son creados automáticamente."
+"que hace que los generadores sean tan compactos es que los métodos :meth:"
+"`__iter__` y :meth:`__next__` son creados automáticamente."
 
 #: ../Doc/tutorial/classes.rst:870
 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 "
-"función sea más fácil de escribir y quede mucho más claro que hacerlo usando"
-" variables de instancia tales como ``self.indice`` y ``self.datos``."
+"función sea más fácil de escribir y quede mucho más claro que hacerlo usando "
+"variables de instancia tales como ``self.indice`` y ``self.datos``."
 
 #: ../Doc/tutorial/classes.rst:875
 msgid ""
@@ -1309,10 +1308,9 @@ 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 levantan "
-":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 levantan :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:884
 msgid "Generator Expressions"
@@ -1320,11 +1318,11 @@ msgstr "Expresiones generadoras"
 
 #: ../Doc/tutorial/classes.rst:886
 msgid ""
-"Some simple generators can be coded succinctly as expressions using a syntax"
-" similar to list comprehensions but with parentheses instead of square "
+"Some simple generators can be coded succinctly as expressions using a syntax "
+"similar to list comprehensions but with parentheses instead of square "
 "brackets. These expressions are designed for situations where the generator "
-"is used right away by an enclosing function.  Generator expressions are more"
-" compact but less versatile than full generator definitions and tend to be "
+"is used right away by an enclosing function.  Generator expressions are more "
+"compact but less versatile than full generator definitions and tend to be "
 "more memory friendly than equivalent list comprehensions."
 msgstr ""
 
diff --git a/tutorial/errors.po b/tutorial/errors.po
index 4eb4e6efea..0d0dced5a6 100644
--- a/tutorial/errors.po
+++ b/tutorial/errors.po
@@ -45,19 +45,19 @@ msgstr ""
 
 #: ../Doc/tutorial/errors.rst:26
 msgid ""
-"The parser repeats the offending line and displays a little 'arrow' pointing"
-" at the earliest point in the line where the error was detected.  The error "
+"The parser repeats the offending line and displays a little 'arrow' pointing "
+"at the earliest point in the line where the error was detected.  The error "
 "is caused by (or at least detected at) the token *preceding* the arrow: in "
 "the example, the error is detected at the function :func:`print`, since a "
-"colon (``':'``) is missing before it.  File name and line number are printed"
-" so you know where to look in case the input came from a script."
+"colon (``':'``) is missing before it.  File name and line number are printed "
+"so you know where to look in case the input came from a script."
 msgstr ""
 "El intérprete repite la línea culpable y muestra una pequeña 'flecha' que "
-"apunta al primer lugar donde se detectó el error.  Este es causado por (o al"
-" menos detectado en) el símbolo que *precede* a la flecha: en el ejemplo, el"
-" error se detecta en la función :func:`print`, ya que faltan dos puntos "
-"(``':'``) antes del mismo.  Se muestran el nombre del archivo y el número de"
-" línea para que sepas dónde mirar en caso de que la entrada venga de un "
+"apunta al primer lugar donde se detectó el error.  Este es causado por (o al "
+"menos detectado en) el símbolo que *precede* a la flecha: en el ejemplo, el "
+"error se detecta en la función :func:`print`, ya que faltan dos puntos "
+"(``':'``) antes del mismo.  Se muestran el nombre del archivo y el número de "
+"línea para que sepas dónde mirar en caso de que la entrada venga de un "
 "programa."
 
 #: ../Doc/tutorial/errors.rst:37
@@ -77,35 +77,35 @@ msgstr ""
 "generar un error cuando se intenta ejecutarla.  Los errores detectados "
 "durante la ejecución se llaman *excepciones*, y no son incondicionalmente "
 "fatales: pronto aprenderás cómo manejarlos en los programas en Python.  Sin "
-"embargo, la mayoría de las excepciones no son manejadas por los programas, y"
-" resultan en mensajes de error como los mostrados aquí::"
+"embargo, la mayoría de las excepciones no son manejadas por los programas, y "
+"resultan en mensajes de error como los mostrados aquí::"
 
 #: ../Doc/tutorial/errors.rst:58
 msgid ""
 "The last line of the error message indicates what happened. Exceptions come "
 "in different types, and the type is printed as part of the message: the "
-"types in the example are :exc:`ZeroDivisionError`, :exc:`NameError` and "
-":exc:`TypeError`. The string printed as the exception type is the name of "
-"the built-in exception that occurred.  This is true for all built-in "
-"exceptions, but need not be true for user-defined exceptions (although it is"
-" a useful convention). Standard exception names are built-in identifiers "
-"(not reserved keywords)."
+"types in the example are :exc:`ZeroDivisionError`, :exc:`NameError` and :exc:"
+"`TypeError`. The string printed as the exception type is the name of the "
+"built-in exception that occurred.  This is true for all built-in exceptions, "
+"but need not be true for user-defined exceptions (although it is a useful "
+"convention). Standard exception names are built-in identifiers (not reserved "
+"keywords)."
 msgstr ""
 "La última línea de los mensajes de error indica qué sucedió.  Las "
 "excepciones vienen de distintos tipos, y el tipo se imprime como parte del "
-"mensaje: los tipos en el ejemplo son: :exc:`ZeroDivisionError`, "
-":exc:`NameError` y :exc:`TypeError`.  La cadena mostrada como tipo de la "
+"mensaje: los tipos en el ejemplo son: :exc:`ZeroDivisionError`, :exc:"
+"`NameError` y :exc:`TypeError`.  La cadena mostrada como tipo de la "
 "excepción es el nombre de la excepción predefinida que ocurrió.  Esto es "
 "verdad para todas las excepciones predefinidas del intérprete, pero no "
-"necesita ser verdad para excepciones definidas por el usuario (aunque es una"
-" convención útil).  Los nombres de las excepciones estándar son "
+"necesita ser verdad para excepciones definidas por el usuario (aunque es una "
+"convención útil).  Los nombres de las excepciones estándar son "
 "identificadores incorporados al intérprete (no son palabras clave "
 "reservadas)."
 
 #: ../Doc/tutorial/errors.rst:66
 msgid ""
-"The rest of the line provides detail based on the type of exception and what"
-" caused it."
+"The rest of the line provides detail based on the type of exception and what "
+"caused it."
 msgstr ""
 "El resto de la línea provee un detalle basado en el tipo de la excepción y "
 "qué la causó."
@@ -113,8 +113,8 @@ msgstr ""
 #: ../Doc/tutorial/errors.rst:69
 msgid ""
 "The preceding part of the error message shows the context where the "
-"exception happened, in the form of a stack traceback. In general it contains"
-" a stack traceback listing source lines; however, it will not display lines "
+"exception happened, in the form of a stack traceback. In general it contains "
+"a stack traceback listing source lines; however, it will not display lines "
 "read from standard input."
 msgstr ""
 "La parte anterior del mensaje de error muestra el contexto donde la "
@@ -136,17 +136,17 @@ msgstr "Manejando excepciones"
 msgid ""
 "It is possible to write programs that handle selected exceptions. Look at "
 "the following example, which asks the user for input until a valid integer "
-"has been entered, but allows the user to interrupt the program (using "
-":kbd:`Control-C` or whatever the operating system supports); note that a "
-"user-generated interruption is signalled by raising the "
-":exc:`KeyboardInterrupt` exception. ::"
-msgstr ""
-"Es posible escribir programas que manejen determinadas excepciones.  Mirá el"
-" siguiente ejemplo, que le pide al usuario una entrada hasta que ingrese un "
-"entero válido, pero permite al usuario interrumpir el programa (usando "
-":kbd:`Control-C` o lo que sea que el sistema operativo soporte); notá que "
-"una interrupción generada por el usuario se señaliza generando la excepción "
-":exc:`KeyboardInterrupt`. ::"
+"has been entered, but allows the user to interrupt the program (using :kbd:"
+"`Control-C` or whatever the operating system supports); note that a user-"
+"generated interruption is signalled by raising the :exc:`KeyboardInterrupt` "
+"exception. ::"
+msgstr ""
+"Es posible escribir programas que manejen determinadas excepciones.  Mirá el "
+"siguiente ejemplo, que le pide al usuario una entrada hasta que ingrese un "
+"entero válido, pero permite al usuario interrumpir el programa (usando :kbd:"
+"`Control-C` o lo que sea que el sistema operativo soporte); notá que una "
+"interrupción generada por el usuario se señaliza generando la excepción :exc:"
+"`KeyboardInterrupt`. ::"
 
 #: ../Doc/tutorial/errors.rst:96
 msgid "The :keyword:`try` statement works as follows."
@@ -154,22 +154,22 @@ msgstr "La declaración :keyword:`try` funciona de la siguiente manera:"
 
 #: ../Doc/tutorial/errors.rst:98
 msgid ""
-"First, the *try clause* (the statement(s) between the :keyword:`try` and "
-":keyword:`except` keywords) is executed."
+"First, the *try clause* (the statement(s) between the :keyword:`try` and :"
+"keyword:`except` keywords) is executed."
 msgstr ""
 
 #: ../Doc/tutorial/errors.rst:101
 msgid ""
-"If no exception occurs, the *except clause* is skipped and execution of the "
-":keyword:`try` statement is finished."
+"If no exception occurs, the *except clause* is skipped and execution of the :"
+"keyword:`try` statement is finished."
 msgstr ""
 
 #: ../Doc/tutorial/errors.rst:104
 msgid ""
 "If an exception occurs during execution of the try clause, the rest of the "
-"clause is skipped.  Then if its type matches the exception named after the "
-":keyword:`except` keyword, the except clause is executed, and then execution"
-" continues after the :keyword:`try` statement."
+"clause is skipped.  Then if its type matches the exception named after the :"
+"keyword:`except` keyword, the except clause is executed, and then execution "
+"continues after the :keyword:`try` statement."
 msgstr ""
 
 #: ../Doc/tutorial/errors.rst:109
@@ -188,18 +188,18 @@ msgid ""
 "not in other handlers of the same :keyword:`!try` statement.  An except "
 "clause may name multiple exceptions as a parenthesized tuple, for example::"
 msgstr ""
-"Una declaración :keyword:`try` puede tener más de un :keyword:`except`, para"
-" especificar manejadores para distintas excepciones.  A lo sumo un manejador"
-" será ejecutado.  Sólo se manejan excepciones que ocurren en el "
-"correspondiente :keyword:`try`, no en otros manejadores del mismo "
-":keyword:`try`.  Un :keyword:`except` puede nombrar múltiples excepciones "
-"usando paréntesis, por ejemplo::"
+"Una declaración :keyword:`try` puede tener más de un :keyword:`except`, para "
+"especificar manejadores para distintas excepciones.  A lo sumo un manejador "
+"será ejecutado.  Sólo se manejan excepciones que ocurren en el "
+"correspondiente :keyword:`try`, no en otros manejadores del mismo :keyword:"
+"`try`.  Un :keyword:`except` puede nombrar múltiples excepciones usando "
+"paréntesis, por ejemplo::"
 
 #: ../Doc/tutorial/errors.rst:123
 msgid ""
-"A class in an :keyword:`except` clause is compatible with an exception if it"
-" is the same class or a base class thereof (but not the other way around ---"
-" an except clause listing a derived class is not compatible with a base "
+"A class in an :keyword:`except` clause is compatible with an exception if it "
+"is the same class or a base class thereof (but not the other way around --- "
+"an except clause listing a derived class is not compatible with a base "
 "class).  For example, the following code will print B, C, D in that order::"
 msgstr ""
 "Una clase en una clausula :keyword:`except` es compatible con una excepción "
@@ -211,8 +211,7 @@ msgstr ""
 #: ../Doc/tutorial/errors.rst:147
 msgid ""
 "Note that if the except clauses were reversed (with ``except B`` first), it "
-"would have printed B, B, B --- the first matching except clause is "
-"triggered."
+"would have printed B, B, B --- the first matching except clause is triggered."
 msgstr ""
 "Notese que si las clausulas de except estuvieran invertidas (con ``except "
 "B`` primero), habría impreso B, B, B --- la primera clausula de except "
@@ -226,9 +225,9 @@ msgid ""
 "message and then re-raise the exception (allowing a caller to handle the "
 "exception as well)::"
 msgstr ""
-"El último :keyword:`except` puede omitir nombrar qué excepción captura, para"
-" servir como comodín.  Usá esto con extremo cuidado, ya que de esta manera "
-"es fácil ocultar un error real de programación.  También puede usarse para "
+"El último :keyword:`except` puede omitir nombrar qué excepción captura, para "
+"servir como comodín.  Usá esto con extremo cuidado, ya que de esta manera es "
+"fácil ocultar un error real de programación.  También puede usarse para "
 "mostrar un mensaje de error y luego re-generar la excepción (permitiéndole "
 "al que llama, manejar también la excepción)::"
 
@@ -240,48 +239,48 @@ msgid ""
 "exception.  For example::"
 msgstr ""
 "Las declaraciones :keyword:`try` ... :keyword:`except` tienen un *bloque "
-"else* opcional, el cual, cuando está presente, debe seguir a los except.  Es"
-" útil para aquel código que debe ejecutarse si el *bloque try* no genera una"
-" excepción.  Por ejemplo::"
+"else* opcional, el cual, cuando está presente, debe seguir a los except.  Es "
+"útil para aquel código que debe ejecutarse si el *bloque try* no genera una "
+"excepción.  Por ejemplo::"
 
 #: ../Doc/tutorial/errors.rst:183
 msgid ""
-"The use of the :keyword:`!else` clause is better than adding additional code"
-" to the :keyword:`try` clause because it avoids accidentally catching an "
-"exception that wasn't raised by the code being protected by the "
-":keyword:`!try` ... :keyword:`!except` statement."
+"The use of the :keyword:`!else` clause is better than adding additional code "
+"to the :keyword:`try` clause because it avoids accidentally catching an "
+"exception that wasn't raised by the code being protected by the :keyword:`!"
+"try` ... :keyword:`!except` statement."
 msgstr ""
-"El uso de :keyword:`else` es mejor que agregar código adicional en el "
-":keyword:`try` porque evita capturar accidentalmente una excepción que no "
-"fue generada por el código que está protegido por la declaración "
-":keyword:`try` ... :keyword:`except`."
+"El uso de :keyword:`else` es mejor que agregar código adicional en el :"
+"keyword:`try` porque evita capturar accidentalmente una excepción que no fue "
+"generada por el código que está protegido por la declaración :keyword:"
+"`try` ... :keyword:`except`."
 
 #: ../Doc/tutorial/errors.rst:188
 msgid ""
-"When an exception occurs, it may have an associated value, also known as the"
-" exception's *argument*. The presence and type of the argument depend on the"
-" exception type."
+"When an exception occurs, it may have an associated value, also known as the "
+"exception's *argument*. The presence and type of the argument depend on the "
+"exception type."
 msgstr ""
-"Cuando ocurre una excepción, puede tener un valor asociado, también conocido"
-" como el *argumento* de la excepción.  La presencia y el tipo de argumento "
+"Cuando ocurre una excepción, puede tener un valor asociado, también conocido "
+"como el *argumento* de la excepción.  La presencia y el tipo de argumento "
 "depende del tipo de excepción."
 
 #: ../Doc/tutorial/errors.rst:192
 msgid ""
 "The except clause may specify a variable after the exception name.  The "
 "variable is bound to an exception instance with the arguments stored in "
-"``instance.args``.  For convenience, the exception instance defines "
-":meth:`__str__` so the arguments can be printed directly without having to "
+"``instance.args``.  For convenience, the exception instance defines :meth:"
+"`__str__` so the arguments can be printed directly without having to "
 "reference ``.args``.  One may also instantiate an exception first before "
 "raising it and add any attributes to it as desired. ::"
 msgstr ""
 "El :keyword:`except` puede especificar una variable luego del nombre de "
 "excepción.  La variable se vincula a una instancia de excepción con los "
-"argumentos almacenados en ``instance.args``.  Por conveniencia, la instancia"
-" de excepción define :meth:`__str__` para que se pueda mostrar los "
-"argumentos directamente, sin necesidad de hacer referencia a ``.args``.  "
-"También se puede instanciar la excepción primero, antes de generarla, y "
-"agregarle los atributos que se desee::"
+"argumentos almacenados en ``instance.args``.  Por conveniencia, la instancia "
+"de excepción define :meth:`__str__` para que se pueda mostrar los argumentos "
+"directamente, sin necesidad de hacer referencia a ``.args``.  También se "
+"puede instanciar la excepción primero, antes de generarla, y agregarle los "
+"atributos que se desee::"
 
 #: ../Doc/tutorial/errors.rst:216
 msgid ""
@@ -293,8 +292,8 @@ msgstr ""
 
 #: ../Doc/tutorial/errors.rst:219
 msgid ""
-"Exception handlers don't just handle exceptions if they occur immediately in"
-" the try clause, but also if they occur inside functions that are called "
+"Exception handlers don't just handle exceptions if they occur immediately in "
+"the try clause, but also if they occur inside functions that are called "
 "(even indirectly) in the try clause. For example::"
 msgstr ""
 "Los manejadores de excepciones no manejan solamente las excepciones que "
@@ -322,17 +321,17 @@ msgid ""
 "will be implicitly instantiated by calling its constructor with no "
 "arguments::"
 msgstr ""
-"El único argumento a :keyword:`raise` indica la excepción a generarse. Tiene"
-" que ser o una instancia de excepción, o una clase de excepción (una clase "
+"El único argumento a :keyword:`raise` indica la excepción a generarse. Tiene "
+"que ser o una instancia de excepción, o una clase de excepción (una clase "
 "que hereda de :class:`Exception`). Si se pasa una clase de excepción, la "
 "misma sera instanciada implicitamente llamandoa su constructor sin "
 "argumentos::"
 
 #: ../Doc/tutorial/errors.rst:254
 msgid ""
-"If you need to determine whether an exception was raised but don't intend to"
-" handle it, a simpler form of the :keyword:`raise` statement allows you to "
-"re-raise the exception::"
+"If you need to determine whether an exception was raised but don't intend to "
+"handle it, a simpler form of the :keyword:`raise` statement allows you to re-"
+"raise the exception::"
 msgstr ""
 "Si necesitás determinar cuando una excepción fue lanzada pero no querés "
 "manejarla, una forma simplificada de la instrucción :keyword:`raise` te "
@@ -349,40 +348,40 @@ msgid ""
 "typically be derived from the :exc:`Exception` class, either directly or "
 "indirectly."
 msgstr ""
-"Los programas pueden nombrar sus propias excepciones creando una nueva clase"
-" excepción (mirá :ref:`tut-classes` para más información sobre las clases de"
-" Python).  Las excepciones, típicamente, deberán derivar de la clase "
-":exc:`Exception`, directa o indirectamente."
+"Los programas pueden nombrar sus propias excepciones creando una nueva clase "
+"excepción (mirá :ref:`tut-classes` para más información sobre las clases de "
+"Python).  Las excepciones, típicamente, deberán derivar de la clase :exc:"
+"`Exception`, directa o indirectamente."
 
 #: ../Doc/tutorial/errors.rst:279
 msgid ""
 "Exception classes can be defined which do anything any other class can do, "
-"but are usually kept simple, often only offering a number of attributes that"
-" allow information about the error to be extracted by handlers for the "
-"exception.  When creating a module that can raise several distinct errors, a"
-" common practice is to create a base class for exceptions defined by that "
-"module, and subclass that to create specific exception classes for different"
-" error conditions::"
+"but are usually kept simple, often only offering a number of attributes that "
+"allow information about the error to be extracted by handlers for the "
+"exception.  When creating a module that can raise several distinct errors, a "
+"common practice is to create a base class for exceptions defined by that "
+"module, and subclass that to create specific exception classes for different "
+"error conditions::"
 msgstr ""
 "Las clases de Excepciones pueden ser definidas de la misma forma que "
 "cualquier otra clase, pero usualmente se mantienen simples, a menudo solo "
 "ofreciendo un número de atributos con información sobre el error que leerán "
-"los manejadores de la excepción.  Al crear un módulo que puede lanzar varios"
-" errores distintos, una práctica común es crear una clase base para "
+"los manejadores de la excepción.  Al crear un módulo que puede lanzar varios "
+"errores distintos, una práctica común es crear una clase base para "
 "excepciones definidas en ese módulo y extenderla para crear clases "
 "excepciones específicas para distintas condiciones de error::"
 
 #: ../Doc/tutorial/errors.rst:317
 msgid ""
-"Most exceptions are defined with names that end in \"Error\", similar to the"
-" naming of the standard exceptions."
+"Most exceptions are defined with names that end in \"Error\", similar to the "
+"naming of the standard exceptions."
 msgstr ""
 
 #: ../Doc/tutorial/errors.rst:320
 msgid ""
 "Many standard modules define their own exceptions to report errors that may "
-"occur in functions they define.  More information on classes is presented in"
-" chapter :ref:`tut-classes`."
+"occur in functions they define.  More information on classes is presented in "
+"chapter :ref:`tut-classes`."
 msgstr ""
 "Muchos módulos estándar definen sus propias excepciones para reportar "
 "errores que pueden ocurrir en funciones propias. Se puede encontrar más "
@@ -406,35 +405,35 @@ msgstr ""
 msgid ""
 "A *finally clause* is always executed before leaving the :keyword:`try` "
 "statement, whether an exception has occurred or not. When an exception has "
-"occurred in the :keyword:`!try` clause and has not been handled by an "
-":keyword:`except` clause (or it has occurred in an :keyword:`!except` or "
-":keyword:`!else` clause), it is re-raised after the :keyword:`finally` "
-"clause has been executed.  The :keyword:`!finally` clause is also executed "
-"\"on the way out\" when any other clause of the :keyword:`!try` statement is"
-" left via a :keyword:`break`, :keyword:`continue` or :keyword:`return` "
-"statement.  A more complicated example::"
-msgstr ""
-"Una *cláusula finally* siempre es ejecutada antes de salir de la declaración"
-" :keyword:`try`, ya sea que una excepción haya ocurrido o no.  Cuando ocurre"
-" una excepción en la cláusula :keyword:`try` y no fue manejada por una "
-"cláusula :keyword:`except` (o ocurrió en una cláusula :keyword:`except` o "
-":keyword:`else`), es relanzada luego de que se ejecuta la cláusula "
-":keyword:`finally`. El :keyword:`finally` es también ejecutado \"a la "
-"salida\" cuando cualquier otra cláusula de la declaración :keyword:`try` es "
-"dejada via :keyword:`break`, :keyword:`continue` or :keyword:`return`.  Un "
-"ejemplo más complicado::"
+"occurred in the :keyword:`!try` clause and has not been handled by an :"
+"keyword:`except` clause (or it has occurred in an :keyword:`!except` or :"
+"keyword:`!else` clause), it is re-raised after the :keyword:`finally` clause "
+"has been executed.  The :keyword:`!finally` clause is also executed \"on the "
+"way out\" when any other clause of the :keyword:`!try` statement is left via "
+"a :keyword:`break`, :keyword:`continue` or :keyword:`return` statement.  A "
+"more complicated example::"
+msgstr ""
+"Una *cláusula finally* siempre es ejecutada antes de salir de la "
+"declaración :keyword:`try`, ya sea que una excepción haya ocurrido o no.  "
+"Cuando ocurre una excepción en la cláusula :keyword:`try` y no fue manejada "
+"por una cláusula :keyword:`except` (o ocurrió en una cláusula :keyword:"
+"`except` o :keyword:`else`), es relanzada luego de que se ejecuta la "
+"cláusula :keyword:`finally`. El :keyword:`finally` es también ejecutado \"a "
+"la salida\" cuando cualquier otra cláusula de la declaración :keyword:`try` "
+"es dejada via :keyword:`break`, :keyword:`continue` or :keyword:`return`.  "
+"Un ejemplo más complicado::"
 
 #: ../Doc/tutorial/errors.rst:377
 msgid ""
-"As you can see, the :keyword:`finally` clause is executed in any event.  The"
-" :exc:`TypeError` raised by dividing two strings is not handled by the "
-":keyword:`except` clause and therefore re-raised after the "
-":keyword:`!finally` clause has been executed."
+"As you can see, the :keyword:`finally` clause is executed in any event.  "
+"The :exc:`TypeError` raised by dividing two strings is not handled by the :"
+"keyword:`except` clause and therefore re-raised after the :keyword:`!"
+"finally` clause has been executed."
 msgstr ""
 "Como podés ver, la cláusula :keyword:`finally` es ejecutada siempre.  La "
 "excepción :exc:`TypeError` lanzada al dividir dos cadenas de texto no es "
-"manejado por la cláusula :keyword:`except` y por lo tanto es relanzada luego"
-" de que se ejecuta la cláusula :keyword:`finally`."
+"manejado por la cláusula :keyword:`except` y por lo tanto es relanzada luego "
+"de que se ejecuta la cláusula :keyword:`finally`."
 
 #: ../Doc/tutorial/errors.rst:382
 msgid ""
@@ -453,8 +452,8 @@ msgstr "Acciones predefinidas de limpieza"
 #: ../Doc/tutorial/errors.rst:392
 msgid ""
 "Some objects define standard clean-up actions to be undertaken when the "
-"object is no longer needed, regardless of whether or not the operation using"
-" the object succeeded or failed. Look at the following example, which tries "
+"object is no longer needed, regardless of whether or not the operation using "
+"the object succeeded or failed. Look at the following example, which tries "
 "to open a file and print its contents to the screen. ::"
 msgstr ""
 "Algunos objetos definen acciones de limpieza estándar que llevar a cabo "
@@ -468,13 +467,13 @@ msgid ""
 "The problem with this code is that it leaves the file open for an "
 "indeterminate amount of time after this part of the code has finished "
 "executing. This is not an issue in simple scripts, but can be a problem for "
-"larger applications. The :keyword:`with` statement allows objects like files"
-" to be used in a way that ensures they are always cleaned up promptly and "
+"larger applications. The :keyword:`with` statement allows objects like files "
+"to be used in a way that ensures they are always cleaned up promptly and "
 "correctly. ::"
 msgstr ""
-"El problema con este código es que deja el archivo abierto por un periodo de"
-" tiempo indeterminado luego de que esta parte termine de ejecutarse.  Esto "
-"no es un problema en scripts simples, pero puede ser un problema en "
+"El problema con este código es que deja el archivo abierto por un periodo de "
+"tiempo indeterminado luego de que esta parte termine de ejecutarse.  Esto no "
+"es un problema en scripts simples, pero puede ser un problema en "
 "aplicaciones más grandes.  La declaración :keyword:`with` permite que "
 "objetos como archivos sean usados de una forma que asegure que siempre se "
 "los libera rápido y en forma correcta.::"
diff --git a/tutorial/floatingpoint.po b/tutorial/floatingpoint.po
index 760967a345..6f2545eb3a 100644
--- a/tutorial/floatingpoint.po
+++ b/tutorial/floatingpoint.po
@@ -55,9 +55,9 @@ msgid ""
 msgstr ""
 "Desafortunadamente, la mayoría de las fracciones decimales no pueden "
 "representarse exactamente como fracciones binarias.  Como consecuencia, en "
-"general los números de punto flotante decimal que ingresás en la computadora"
-" son sólo aproximados por los números de punto flotante binario que "
-"realmente se guardan en la máquina."
+"general los números de punto flotante decimal que ingresás en la computadora "
+"son sólo aproximados por los números de punto flotante binario que realmente "
+"se guardan en la máquina."
 
 #: ../Doc/tutorial/floatingpoint.rst:32
 msgid ""
@@ -82,8 +82,8 @@ msgstr ""
 
 #: ../Doc/tutorial/floatingpoint.rst:49
 msgid ""
-"In the same way, no matter how many base 2 digits you're willing to use, the"
-" decimal value 0.1 cannot be represented exactly as a base 2 fraction.  In "
+"In the same way, no matter how many base 2 digits you're willing to use, the "
+"decimal value 0.1 cannot be represented exactly as a base 2 fraction.  In "
 "base 2, 1/10 is the infinitely repeating fraction ::"
 msgstr ""
 "De la misma manera, no importa cuantos dígitos en base 2 quieras usar, el "
@@ -95,15 +95,15 @@ msgstr ""
 msgid ""
 "Stop at any finite number of bits, and you get an approximation.  On most "
 "machines today, floats are approximated using a binary fraction with the "
-"numerator using the first 53 bits starting with the most significant bit and"
-" with the denominator as a power of two.  In the case of 1/10, the binary "
-"fraction is ``3602879701896397 / 2 ** 55`` which is close to but not exactly"
-" equal to the true value of 1/10."
-msgstr ""
-"Frená en cualquier número finito de bits, y tendrás una aproximación.  En la"
-" mayoría de las máquinas hoy en día, los float se aproximan usando una "
-"fracción binaria con el numerador usando los primeros 53 bits con el bit más"
-" significativos y el denominador como una potencia de dos.  En el caso de "
+"numerator using the first 53 bits starting with the most significant bit and "
+"with the denominator as a power of two.  In the case of 1/10, the binary "
+"fraction is ``3602879701896397 / 2 ** 55`` which is close to but not exactly "
+"equal to the true value of 1/10."
+msgstr ""
+"Frená en cualquier número finito de bits, y tendrás una aproximación.  En la "
+"mayoría de las máquinas hoy en día, los float se aproximan usando una "
+"fracción binaria con el numerador usando los primeros 53 bits con el bit más "
+"significativos y el denominador como una potencia de dos.  En el caso de "
 "1/10, la fracción binaria es ``3602879701896397 / 2 ** 55`` que está cerca "
 "pero no es exactamente el valor verdadero de 1/10."
 
@@ -118,14 +118,14 @@ msgstr ""
 "La mayoría de los usuarios no son conscientes de esta aproximación por la "
 "forma en que se muestran los valores.  Python solamente muestra una "
 "aproximación decimal al valor verdadero decimal de la aproximación binaria "
-"almacenada por la máquina.  En la mayoría de las máquinas, si Python fuera a"
-" imprimir el verdadero valor decimal de la aproximación binaria almacenada "
+"almacenada por la máquina.  En la mayoría de las máquinas, si Python fuera a "
+"imprimir el verdadero valor decimal de la aproximación binaria almacenada "
 "para 0.1, debería mostrar ::"
 
 #: ../Doc/tutorial/floatingpoint.rst:71
 msgid ""
-"That is more digits than most people find useful, so Python keeps the number"
-" of digits manageable by displaying a rounded value instead ::"
+"That is more digits than most people find useful, so Python keeps the number "
+"of digits manageable by displaying a rounded value instead ::"
 msgstr ""
 "Esos son más dígitos que lo que la mayoría de la gente encuentra útil, por "
 "lo que Python mantiene manejable la cantidad de dígitos al mostrar en su "
@@ -162,21 +162,21 @@ msgstr ""
 msgid ""
 "Historically, the Python prompt and built-in :func:`repr` function would "
 "choose the one with 17 significant digits, ``0.10000000000000001``.   "
-"Starting with Python 3.1, Python (on most systems) is now able to choose the"
-" shortest of these and simply display ``0.1``."
+"Starting with Python 3.1, Python (on most systems) is now able to choose the "
+"shortest of these and simply display ``0.1``."
 msgstr ""
 "Históricamente, el prompt de Python y la función integrada :func:`repr` "
 "eligieron el valor con los 17 dígitos, ``0.10000000000000001``.  Desde "
-"Python 3.1, en la mayoría de los sistemas Python ahora es capaz de elegir la"
-" forma más corta de ellos y mostrar ``0.1``."
+"Python 3.1, en la mayoría de los sistemas Python ahora es capaz de elegir la "
+"forma más corta de ellos y mostrar ``0.1``."
 
 #: ../Doc/tutorial/floatingpoint.rst:93
 msgid ""
-"Note that this is in the very nature of binary floating-point: this is not a"
-" bug in Python, and it is not a bug in your code either.  You'll see the "
-"same kind of thing in all languages that support your hardware's floating-"
-"point arithmetic (although some languages may not *display* the difference "
-"by default, or in all output modes)."
+"Note that this is in the very nature of binary floating-point: this is not a "
+"bug in Python, and it is not a bug in your code either.  You'll see the same "
+"kind of thing in all languages that support your hardware's floating-point "
+"arithmetic (although some languages may not *display* the difference by "
+"default, or in all output modes)."
 msgstr ""
 "Notá que esta es la verdadera naturaleza del punto flotante binario: no es "
 "un error de Python, y tampoco es un error en tu código.  Verás lo mismo en "
@@ -186,33 +186,33 @@ msgstr ""
 
 #: ../Doc/tutorial/floatingpoint.rst:99
 msgid ""
-"For more pleasant output, you may wish to use string formatting to produce a"
-" limited number of significant digits::"
+"For more pleasant output, you may wish to use string formatting to produce a "
+"limited number of significant digits::"
 msgstr ""
 "Para una salida más elegante, quizás quieras usar el formateo de cadenas de "
 "texto para generar un número limitado de dígitos significativos::"
 
 #: ../Doc/tutorial/floatingpoint.rst:111
 msgid ""
-"It's important to realize that this is, in a real sense, an illusion: you're"
-" simply rounding the *display* of the true machine value."
+"It's important to realize that this is, in a real sense, an illusion: you're "
+"simply rounding the *display* of the true machine value."
 msgstr ""
 "Es importante darse cuenta que esto es, realmente, una ilusión: estás "
 "simplemente redondeando al *mostrar* el valor verdadero de la máquina."
 
 #: ../Doc/tutorial/floatingpoint.rst:114
 msgid ""
-"One illusion may beget another.  For example, since 0.1 is not exactly 1/10,"
-" summing three values of 0.1 may not yield exactly 0.3, either::"
+"One illusion may beget another.  For example, since 0.1 is not exactly 1/10, "
+"summing three values of 0.1 may not yield exactly 0.3, either::"
 msgstr ""
 "Una ilusión puede generar otra.  Por ejemplo, ya que 0.1 no es exactamente "
 "1/10, sumar tres veces 0.1 podría también no generar exactamente 0.3::"
 
 #: ../Doc/tutorial/floatingpoint.rst:120
 msgid ""
-"Also, since the 0.1 cannot get any closer to the exact value of 1/10 and 0.3"
-" cannot get any closer to the exact value of 3/10, then pre-rounding with "
-":func:`round` function cannot help::"
+"Also, since the 0.1 cannot get any closer to the exact value of 1/10 and 0.3 "
+"cannot get any closer to the exact value of 3/10, then pre-rounding with :"
+"func:`round` function cannot help::"
 msgstr ""
 "También, ya que 0.1 no puede acercarse más al valor exacto de 1/10 y 0.3 no "
 "puede acercarse más al valor exacto de 3/10, redondear primero con la "
@@ -220,25 +220,25 @@ msgstr ""
 
 #: ../Doc/tutorial/floatingpoint.rst:127
 msgid ""
-"Though the numbers cannot be made closer to their intended exact values, the"
-" :func:`round` function can be useful for post-rounding so that results with"
-" inexact values become comparable to one another::"
+"Though the numbers cannot be made closer to their intended exact values, "
+"the :func:`round` function can be useful for post-rounding so that results "
+"with inexact values become comparable to one another::"
 msgstr ""
 "A pesar que los números no pueden acercarse a los valores exactos que "
 "pretendemos, la función :func:`round` puede ser útil para redondear a "
-"posteriori, para que los resultados con valores inexactos se puedan comparar"
-" entre sí::"
+"posteriori, para que los resultados con valores inexactos se puedan comparar "
+"entre sí::"
 
 #: ../Doc/tutorial/floatingpoint.rst:134
 msgid ""
 "Binary floating-point arithmetic holds many surprises like this.  The "
 "problem with \"0.1\" is explained in precise detail below, in the "
-"\"Representation Error\" section.  See `The Perils of Floating Point "
-"<http://www.lahey.com/float.htm>`_ for a more complete account of other "
-"common surprises."
+"\"Representation Error\" section.  See `The Perils of Floating Point <http://"
+"www.lahey.com/float.htm>`_ for a more complete account of other common "
+"surprises."
 msgstr ""
-"La aritmética de punto flotante binaria tiene varias sorpresas como esta. El"
-" problema con \"0.1\" es explicado con detalle abajo, en la sección \"Error "
+"La aritmética de punto flotante binaria tiene varias sorpresas como esta. El "
+"problema con \"0.1\" es explicado con detalle abajo, en la sección \"Error "
 "de Representación\".  Mirá los Peligros del Punto Flotante (en inglés, `The "
 "Perils of Floating Point <http://www.lahey.com/float.htm>`_) para una más "
 "completa recopilación de otras sorpresas normales."
@@ -254,42 +254,42 @@ msgid ""
 "error."
 msgstr ""
 "Como dice cerca del final, \"no hay respuestas fáciles\".  A pesar de eso, "
-"¡no le tengas mucho miedo al punto flotante!  Los errores en las operaciones"
-" flotantes de Python se heredan del hardware de punto flotante, y en la "
-"mayoría de las máquinas están en el orden de no más de una 1 parte en "
-"2\\*\\*53 por operación.  Eso es más que adecuado para la mayoría de las "
-"tareas, pero necesitás tener en cuenta que no es aritmética decimal, y que "
-"cada operación de punto flotante sufre un nuevo error de redondeo."
+"¡no le tengas mucho miedo al punto flotante!  Los errores en las operaciones "
+"flotantes de Python se heredan del hardware de punto flotante, y en la "
+"mayoría de las máquinas están en el orden de no más de una 1 parte en 2\\*"
+"\\*53 por operación.  Eso es más que adecuado para la mayoría de las tareas, "
+"pero necesitás tener en cuenta que no es aritmética decimal, y que cada "
+"operación de punto flotante sufre un nuevo error de redondeo."
 
 #: ../Doc/tutorial/floatingpoint.rst:146
 msgid ""
 "While pathological cases do exist, for most casual use of floating-point "
 "arithmetic you'll see the result you expect in the end if you simply round "
 "the display of your final results to the number of decimal digits you "
-"expect. :func:`str` usually suffices, and for finer control see the "
-":meth:`str.format` method's format specifiers in :ref:`formatstrings`."
+"expect. :func:`str` usually suffices, and for finer control see the :meth:"
+"`str.format` method's format specifiers in :ref:`formatstrings`."
 msgstr ""
 "A pesar de que existen casos patológicos, para la mayoría de usos casuales "
 "de la aritmética de punto flotante al final verás el resultado que esperás "
 "si simplemente redondeás lo que mostrás de tus resultados finales al número "
 "de dígitos decimales que esperás.  :func:`str` es normalmente suficiente, y "
-"para un control más fino mirá los parámetros del método de formateo "
-":meth:`str.format` en :ref:`string-formatting`."
+"para un control más fino mirá los parámetros del método de formateo :meth:"
+"`str.format` en :ref:`string-formatting`."
 
 #: ../Doc/tutorial/floatingpoint.rst:152
 msgid ""
-"For use cases which require exact decimal representation, try using the "
-":mod:`decimal` module which implements decimal arithmetic suitable for "
-"accounting applications and high-precision applications."
+"For use cases which require exact decimal representation, try using the :mod:"
+"`decimal` module which implements decimal arithmetic suitable for accounting "
+"applications and high-precision applications."
 msgstr ""
-"Para los casos de uso que necesitan una representación decimal exacta, probá"
-" el módulo :mod:`decimal`, que implementa aritmética decimal útil para "
+"Para los casos de uso que necesitan una representación decimal exacta, probá "
+"el módulo :mod:`decimal`, que implementa aritmética decimal útil para "
 "aplicaciones de contabilidad y de alta precisión."
 
 #: ../Doc/tutorial/floatingpoint.rst:156
 msgid ""
-"Another form of exact arithmetic is supported by the :mod:`fractions` module"
-" which implements arithmetic based on rational numbers (so the numbers like "
+"Another form of exact arithmetic is supported by the :mod:`fractions` module "
+"which implements arithmetic based on rational numbers (so the numbers like "
 "1/3 can be represented exactly)."
 msgstr ""
 "El módulo :mod:`fractions` soporta otra forma de aritmética exacta, ya que "
@@ -299,31 +299,29 @@ msgstr ""
 #: ../Doc/tutorial/floatingpoint.rst:160
 msgid ""
 "If you are a heavy user of floating point operations you should take a look "
-"at the Numerical Python package and many other packages for mathematical and"
-" statistical operations supplied by the SciPy project. See "
-"<https://scipy.org>."
+"at the Numerical Python package and many other packages for mathematical and "
+"statistical operations supplied by the SciPy project. See <https://scipy."
+"org>."
 msgstr ""
 "Si sos un usuario frecuente de las operaciones de punto flotante deberías "
 "pegarle una mirada al paquete Numerical Python y otros paquetes para "
-"operaciones matemáticas y estadísticas provistos por el proyecto SciPy. Mirá"
-" <https://scipy.org>."
+"operaciones matemáticas y estadísticas provistos por el proyecto SciPy. Mirá "
+"<https://scipy.org>."
 
 #: ../Doc/tutorial/floatingpoint.rst:164
 msgid ""
 "Python provides tools that may help on those rare occasions when you really "
-"*do* want to know the exact value of a float.  The "
-":meth:`float.as_integer_ratio` method expresses the value of a float as a "
-"fraction::"
+"*do* want to know the exact value of a float.  The :meth:`float."
+"as_integer_ratio` method expresses the value of a float as a fraction::"
 msgstr ""
 "Python provee herramientas que pueden ayudar en esas raras ocasiones cuando "
-"realmente *querés* saber el valor exacto de un float. El método "
-":meth:`float.as_integer_ratio` expresa el valor del float como una "
-"fracción::"
+"realmente *querés* saber el valor exacto de un float. El método :meth:`float."
+"as_integer_ratio` expresa el valor del float como una fracción::"
 
 #: ../Doc/tutorial/floatingpoint.rst:173
 msgid ""
-"Since the ratio is exact, it can be used to losslessly recreate the original"
-" value::"
+"Since the ratio is exact, it can be used to losslessly recreate the original "
+"value::"
 msgstr ""
 "Ya que la fracción es exacta, se puede usar para recrear sin pérdidas el "
 "valor original::"
@@ -338,8 +336,8 @@ msgstr ""
 
 #: ../Doc/tutorial/floatingpoint.rst:185
 msgid ""
-"This precise hexadecimal representation can be used to reconstruct the float"
-" value exactly::"
+"This precise hexadecimal representation can be used to reconstruct the float "
+"value exactly::"
 msgstr ""
 "Esta representación hexadecimal precisa se puede usar para reconstruir el "
 "valor exacto del float::"
@@ -359,13 +357,13 @@ msgstr ""
 #: ../Doc/tutorial/floatingpoint.rst:195
 msgid ""
 "Another helpful tool is the :func:`math.fsum` function which helps mitigate "
-"loss-of-precision during summation.  It tracks \"lost digits\" as values are"
-" added onto a running total.  That can make a difference in overall accuracy"
-" so that the errors do not accumulate to the point where they affect the "
+"loss-of-precision during summation.  It tracks \"lost digits\" as values are "
+"added onto a running total.  That can make a difference in overall accuracy "
+"so that the errors do not accumulate to the point where they affect the "
 "final total:"
 msgstr ""
-"Otra herramienta útil es la función :func:`math.fsum` que ayuda a mitigar la"
-" pérdida de precisión durante la suma.  Esta función lleva la cuenta de "
+"Otra herramienta útil es la función :func:`math.fsum` que ayuda a mitigar la "
+"pérdida de precisión durante la suma.  Esta función lleva la cuenta de "
 "\"dígitos perdidos\" mientras se suman los valores en un total.  Eso puede "
 "hacer una diferencia en la exactitud de lo que se va sumando para que los "
 "errores no se acumulen al punto en que afecten el total final::"
@@ -395,27 +393,27 @@ msgid ""
 msgstr ""
 ":dfn:`Error de representación` se refiere al hecho de que algunas (la "
 "mayoría) de las fracciones decimales no pueden representarse exactamente "
-"como fracciones binarias (en base 2).  Esta es la razón principal de por qué"
-" Python (o Perl, C, C++, Java, Fortran, y tantos otros) frecuentemente no "
+"como fracciones binarias (en base 2).  Esta es la razón principal de por qué "
+"Python (o Perl, C, C++, Java, Fortran, y tantos otros) frecuentemente no "
 "mostrarán el número decimal exacto que esperás."
 
 #: ../Doc/tutorial/floatingpoint.rst:220
 msgid ""
-"Why is that?  1/10 is not exactly representable as a binary fraction. Almost"
-" all machines today (November 2000) use IEEE-754 floating point arithmetic, "
-"and almost all platforms map Python floats to IEEE-754 \"double precision\"."
-"  754 doubles contain 53 bits of precision, so on input the computer strives"
-" to convert 0.1 to the closest fraction it can of the form *J*/2**\\ *N* "
-"where *J* is an integer containing exactly 53 bits.  Rewriting ::"
+"Why is that?  1/10 is not exactly representable as a binary fraction. Almost "
+"all machines today (November 2000) use IEEE-754 floating point arithmetic, "
+"and almost all platforms map Python floats to IEEE-754 \"double precision"
+"\".  754 doubles contain 53 bits of precision, so on input the computer "
+"strives to convert 0.1 to the closest fraction it can of the form *J*/2**\\ "
+"*N* where *J* is an integer containing exactly 53 bits.  Rewriting ::"
 msgstr ""
 "¿Por qué es eso?  1/10 no es representable exactamente como una fracción "
 "binaria.  Casi todas las máquinas de hoy en día (Noviembre del 2000) usan "
 "aritmética de punto flotante IEEE-754, y casi todas las plataformas mapean "
-"los flotantes de Python al \"doble precisión\" de IEEE-754.  Estos "
-"\"dobles\" tienen 53 bits de precisión, por lo tanto en la entrada la "
-"computadora intenta convertir 0.1 a la fracción más cercana que puede de la "
-"forma *J*/2\\*\\**N* donde *J* es un entero que contiene exactamente 53 "
-"bits. Reescribiendo ::"
+"los flotantes de Python al \"doble precisión\" de IEEE-754.  Estos \"dobles"
+"\" tienen 53 bits de precisión, por lo tanto en la entrada la computadora "
+"intenta convertir 0.1 a la fracción más cercana que puede de la forma "
+"*J*/2\\*\\**N* donde *J* es un entero que contiene exactamente 53 bits. "
+"Reescribiendo ::"
 
 #: ../Doc/tutorial/floatingpoint.rst:229
 msgid "as ::"
@@ -431,8 +429,8 @@ msgstr ""
 
 #: ../Doc/tutorial/floatingpoint.rst:239
 msgid ""
-"That is, 56 is the only value for *N* that leaves *J* with exactly 53 bits."
-"  The best possible value for *J* is then that quotient rounded::"
+"That is, 56 is the only value for *N* that leaves *J* with exactly 53 bits.  "
+"The best possible value for *J* is then that quotient rounded::"
 msgstr ""
 "O sea, 56 es el único valor para *N* que deja *J* con exactamente 53 bits. "
 "El mejor valor posible para *J* es entonces el cociente redondeado::"
@@ -473,23 +471,22 @@ msgid ""
 "given above, the best 754 double approximation it can get::"
 msgstr ""
 "Entonces la computadora nunca \"ve\" 1/10:  lo que ve es la fracción exacta "
-"de arriba, la mejor aproximación al flotante doble de 754 que puede "
-"obtener::"
+"de arriba, la mejor aproximación al flotante doble de 754 que puede obtener::"
 
 #: ../Doc/tutorial/floatingpoint.rst:270
 msgid ""
 "If we multiply that fraction by 10\\*\\*55, we can see the value out to 55 "
 "decimal digits::"
 msgstr ""
-"Si multiplicamos esa fracción por 10\\*\\*55, podemos ver el valor hasta los"
-" 55 dígitos decimales::"
+"Si multiplicamos esa fracción por 10\\*\\*55, podemos ver el valor hasta los "
+"55 dígitos decimales::"
 
 #: ../Doc/tutorial/floatingpoint.rst:276
 msgid ""
-"meaning that the exact number stored in the computer is equal to the decimal"
-" value 0.1000000000000000055511151231257827021181583404541015625. Instead of"
-" displaying the full decimal value, many languages (including older versions"
-" of Python), round the result to 17 significant digits::"
+"meaning that the exact number stored in the computer is equal to the decimal "
+"value 0.1000000000000000055511151231257827021181583404541015625. Instead of "
+"displaying the full decimal value, many languages (including older versions "
+"of Python), round the result to 17 significant digits::"
 msgstr ""
 "...lo que significa que el valor exacto almacenado en la computadora es "
 "igual al valor decimal "
diff --git a/tutorial/interactive.po b/tutorial/interactive.po
index f76789feb6..8c0ee481f5 100644
--- a/tutorial/interactive.po
+++ b/tutorial/interactive.po
@@ -22,11 +22,11 @@ msgstr "Edición de entrada interactiva y sustitución de historial"
 
 #: ../Doc/tutorial/interactive.rst:7
 msgid ""
-"Some versions of the Python interpreter support editing of the current input"
-" line and history substitution, similar to facilities found in the Korn "
-"shell and the GNU Bash shell.  This is implemented using the `GNU Readline`_"
-" library, which supports various styles of editing.  This library has its "
-"own documentation which we won't duplicate here."
+"Some versions of the Python interpreter support editing of the current input "
+"line and history substitution, similar to facilities found in the Korn shell "
+"and the GNU Bash shell.  This is implemented using the `GNU Readline`_ "
+"library, which supports various styles of editing.  This library has its own "
+"documentation which we won't duplicate here."
 msgstr ""
 "Algunas versiones del intérprete de Python permiten editar la línea de "
 "entrada actual, y sustituir en base al historial, de forma similar a las "
@@ -47,24 +47,23 @@ msgid ""
 "current local variables, and the available module names.  For dotted "
 "expressions such as ``string.a``, it will evaluate the expression up to the "
 "final ``'.'`` and then suggest completions from the attributes of the "
-"resulting object.  Note that this may execute application-defined code if an"
-" object with a :meth:`__getattr__` method is part of the expression.  The "
-"default configuration also saves your history into a file named "
-":file:`.python_history` in your user directory. The history will be "
-"available again during the next interactive interpreter session."
+"resulting object.  Note that this may execute application-defined code if an "
+"object with a :meth:`__getattr__` method is part of the expression.  The "
+"default configuration also saves your history into a file named :file:`."
+"python_history` in your user directory. The history will be available again "
+"during the next interactive interpreter session."
 msgstr ""
 "El autocompletado de variables y nombres de módulos es ``activado "
-"automáticamente`` al iniciar el intérprete, por lo tanto la tecla :kbd:`Tab`"
-" invoca la función de autocompletado; ésta mira en los nombres de sentencia,"
-" las variables locales y los nombres de módulos disponibles. Para "
-"expresiones con puntos como ``string.a``, va a evaluar la expresión hasta el"
-" ``'.'`` final y entonces sugerir autocompletado para los atributos del "
-"objeto resultante. Nota que esto quizás ejecute código de aplicaciones "
-"definidas si un objeto con un método :meth:`__getattr__` es parte de la "
-"expresión. La configuración por omisión también guarda tu historial en un "
-"archivo llamado :file:`.python_history` en tu directorio de usuario. El "
-"historial estará disponible durante la próxima sesión interactiva del "
-"intérprete."
+"automáticamente`` al iniciar el intérprete, por lo tanto la tecla :kbd:`Tab` "
+"invoca la función de autocompletado; ésta mira en los nombres de sentencia, "
+"las variables locales y los nombres de módulos disponibles. Para expresiones "
+"con puntos como ``string.a``, va a evaluar la expresión hasta el ``'.'`` "
+"final y entonces sugerir autocompletado para los atributos del objeto "
+"resultante. Nota que esto quizás ejecute código de aplicaciones definidas si "
+"un objeto con un método :meth:`__getattr__` es parte de la expresión. La "
+"configuración por omisión también guarda tu historial en un archivo llamado :"
+"file:`.python_history` en tu directorio de usuario. El historial estará "
+"disponible durante la próxima sesión interactiva del intérprete."
 
 #: ../Doc/tutorial/interactive.rst:36
 msgid "Alternatives to the Interactive Interpreter"
@@ -74,14 +73,14 @@ msgstr "Alternativas al intérprete interactivo"
 msgid ""
 "This facility is an enormous step forward compared to earlier versions of "
 "the interpreter; however, some wishes are left: It would be nice if the "
-"proper indentation were suggested on continuation lines (the parser knows if"
-" an indent token is required next).  The completion mechanism might use the "
+"proper indentation were suggested on continuation lines (the parser knows if "
+"an indent token is required next).  The completion mechanism might use the "
 "interpreter's symbol table.  A command to check (or even suggest) matching "
 "parentheses, quotes, etc., would also be useful."
 msgstr ""
 "Esta funcionalidad es un paso enorme hacia adelante comparado con versiones "
-"anteriores del interprete; de todos modos, quedan pendientes algunos deseos:"
-" sería bueno que el sangrado correcto se sugiriera en las lineas de "
+"anteriores del interprete; de todos modos, quedan pendientes algunos deseos: "
+"sería bueno que el sangrado correcto se sugiriera en las lineas de "
 "continuación (el parser sabe si se requiere un sangrado a continuación). El "
 "mecanismo de completado podría usar la tabla de símbolos del intérprete. Un "
 "comando para verificar (o incluso sugerir) coincidencia de paréntesis, "
diff --git a/tutorial/modules.po b/tutorial/modules.po
index c31c46d700..853b8f1e85 100644
--- a/tutorial/modules.po
+++ b/tutorial/modules.po
@@ -220,8 +220,8 @@ msgid ""
 "For efficiency reasons, each module is only imported once per interpreter "
 "session.  Therefore, if you change your modules, you must restart the "
 "interpreter -- or, if it's just one module you want to test interactively, "
-"use :func:`importlib.reload`, e.g. ``import importlib; "
-"importlib.reload(modulename)``."
+"use :func:`importlib.reload`, e.g. ``import importlib; importlib."
+"reload(modulename)``."
 msgstr ""
 
 #: ../Doc/tutorial/modules.rst:146
@@ -238,8 +238,8 @@ msgid ""
 "with the ``__name__`` set to ``\"__main__\"``.  That means that by adding "
 "this code at the end of your module::"
 msgstr ""
-"...el código en el módulo será ejecutado, tal como si lo hubieses importado,"
-" pero con ``__name__`` con el valor de ``\"__main__\"``.  Eso significa que "
+"...el código en el módulo será ejecutado, tal como si lo hubieses importado, "
+"pero con ``__name__`` con el valor de ``\"__main__\"``.  Eso significa que "
 "agregando este código al final de tu módulo::"
 
 #: ../Doc/tutorial/modules.rst:160
@@ -249,8 +249,8 @@ msgid ""
 "executed as the \"main\" file:"
 msgstr ""
 "...podés hacer que el archivo sea utilizable tanto como script, como módulo "
-"importable, porque el código que analiza la linea de órdenes sólo se ejecuta"
-" si el módulo es ejecutado como archivo principal:"
+"importable, porque el código que analiza la linea de órdenes sólo se ejecuta "
+"si el módulo es ejecutado como archivo principal:"
 
 #: ../Doc/tutorial/modules.rst:169
 msgid "If the module is imported, the code is not run::"
@@ -274,14 +274,14 @@ msgstr "El camino de búsqueda de los módulos"
 msgid ""
 "When a module named :mod:`spam` is imported, the interpreter first searches "
 "for a built-in module with that name. If not found, it then searches for a "
-"file named :file:`spam.py` in a list of directories given by the variable "
-":data:`sys.path`.  :data:`sys.path` is initialized from these locations:"
+"file named :file:`spam.py` in a list of directories given by the variable :"
+"data:`sys.path`.  :data:`sys.path` is initialized from these locations:"
 msgstr ""
-"Cuando se importa un módulo llamado :mod:`spam`, el intérprete busca primero"
-" por un módulo con ese nombre que esté integrado en el intérprete. Si no lo "
+"Cuando se importa un módulo llamado :mod:`spam`, el intérprete busca primero "
+"por un módulo con ese nombre que esté integrado en el intérprete. Si no lo "
 "encuentra, entonces busca un archivo llamado  :file:`spam.py` en una lista "
-"de directorios especificada por la variable :data:`sys.path`. "
-":data:`sys.path` se inicializa con las siguientes ubicaciones:"
+"de directorios especificada por la variable :data:`sys.path`. :data:`sys."
+"path` se inicializa con las siguientes ubicaciones:"
 
 #: ../Doc/tutorial/modules.rst:190
 msgid ""
@@ -312,15 +312,15 @@ msgid ""
 "directory containing the script being run is placed at the beginning of the "
 "search path, ahead of the standard library path. This means that scripts in "
 "that directory will be loaded instead of modules of the same name in the "
-"library directory. This is an error unless the replacement is intended.  See"
-" section :ref:`tut-standardmodules` for more information."
-msgstr ""
-"Luego de la inicialización, los programas Python pueden modificar "
-":data:`sys.path`. El directorio que contiene el script que se está "
-"ejecutando se ubica al principio de la búsqueda, adelante de la biblioteca "
-"estándar. Esto significa que se cargarán scripts en ese directorio en lugar "
-"de módulos de la biblioteca estándar con el mismo nombre. Esto es un error a"
-" menos que se esté reemplazando intencionalmente. Mirá la sección :ref:`tut-"
+"library directory. This is an error unless the replacement is intended.  See "
+"section :ref:`tut-standardmodules` for more information."
+msgstr ""
+"Luego de la inicialización, los programas Python pueden modificar :data:`sys."
+"path`. El directorio que contiene el script que se está ejecutando se ubica "
+"al principio de la búsqueda, adelante de la biblioteca estándar. Esto "
+"significa que se cargarán scripts en ese directorio en lugar de módulos de "
+"la biblioteca estándar con el mismo nombre. Esto es un error a menos que se "
+"esté reemplazando intencionalmente. Mirá la sección :ref:`tut-"
 "standardmodules` para más información."
 
 #: ../Doc/tutorial/modules.rst:212
@@ -330,22 +330,21 @@ msgstr "Archivos \"compilados\" de Python"
 #: ../Doc/tutorial/modules.rst:214
 msgid ""
 "To speed up loading modules, Python caches the compiled version of each "
-"module in the ``__pycache__`` directory under the name "
-":file:`module.{version}.pyc`, where the version encodes the format of the "
-"compiled file; it generally contains the Python version number.  For "
-"example, in CPython release 3.3 the compiled version of spam.py would be "
-"cached as ``__pycache__/spam.cpython-33.pyc``.  This naming convention "
-"allows compiled modules from different releases and different versions of "
-"Python to coexist."
-msgstr ""
-"Para acelerar la carga de módulos, Python cachea las versiones compiladas de"
-" cada módulo en el directorio ``__pycache__`` bajo el nombre "
-":file:`module.{version}.pyc` dónde la versión codifica el formato del "
-"archivo compilado; generalmente contiene el número de version de Python. Por"
-" ejemplo, en CPython release 3.3 la version compilada de spam.py sería "
-"cacheada como ``__pycache__/spam.cpython-33.pyc``. Este convensión de nombre"
-" permite compilar módulos desde diferentes releases y versiones de Python "
-"para coexistir."
+"module in the ``__pycache__`` directory under the name :file:`module."
+"{version}.pyc`, where the version encodes the format of the compiled file; "
+"it generally contains the Python version number.  For example, in CPython "
+"release 3.3 the compiled version of spam.py would be cached as ``__pycache__/"
+"spam.cpython-33.pyc``.  This naming convention allows compiled modules from "
+"different releases and different versions of Python to coexist."
+msgstr ""
+"Para acelerar la carga de módulos, Python cachea las versiones compiladas de "
+"cada módulo en el directorio ``__pycache__`` bajo el nombre :file:`module."
+"{version}.pyc` dónde la versión codifica el formato del archivo compilado; "
+"generalmente contiene el número de version de Python. Por ejemplo, en "
+"CPython release 3.3 la version compilada de spam.py sería cacheada como "
+"``__pycache__/spam.cpython-33.pyc``. Este convensión de nombre permite "
+"compilar módulos desde diferentes releases y versiones de Python para "
+"coexistir."
 
 #: ../Doc/tutorial/modules.rst:222
 msgid ""
@@ -367,8 +366,8 @@ msgid ""
 "recompiles and does not store the result for the module that's loaded "
 "directly from the command line.  Second, it does not check the cache if "
 "there is no source module.  To support a non-source (compiled only) "
-"distribution, the compiled module must be in the source directory, and there"
-" must not be a source module."
+"distribution, the compiled module must be in the source directory, and there "
+"must not be a source module."
 msgstr ""
 "Python no chequea el caché en dos circuntancias. Primero, siempre recompila "
 "y no graba el resultado del módulo que es cargado directamente desde la "
@@ -380,11 +379,11 @@ msgstr "Algunos consejos para expertos:"
 
 #: ../Doc/tutorial/modules.rst:236
 msgid ""
-"You can use the :option:`-O` or :option:`-OO` switches on the Python command"
-" to reduce the size of a compiled module.  The ``-O`` switch removes assert "
+"You can use the :option:`-O` or :option:`-OO` switches on the Python command "
+"to reduce the size of a compiled module.  The ``-O`` switch removes assert "
 "statements, the ``-OO`` switch removes both assert statements and __doc__ "
-"strings.  Since some programs may rely on having these available, you should"
-" only use this option if you know what you're doing.  \"Optimized\" modules "
+"strings.  Since some programs may rely on having these available, you should "
+"only use this option if you know what you're doing.  \"Optimized\" modules "
 "have an ``opt-`` tag and are usually smaller.  Future releases may change "
 "the effects of optimization."
 msgstr ""
@@ -433,8 +432,8 @@ msgstr ""
 "del lenguaje pero que sin embargo están integrados, tanto por eficiencia "
 "como para proveer acceso a primitivas del sistema operativo, como llamadas "
 "al sistema.  El conjunto de tales módulos es una opción de configuración el "
-"cual también depende de la plataforma subyacente.  Por ejemplo, el módulo "
-":mod:`winreg` sólo se provee en sistemas Windows.  Un módulo en particular "
+"cual también depende de la plataforma subyacente.  Por ejemplo, el módulo :"
+"mod:`winreg` sólo se provee en sistemas Windows.  Un módulo en particular "
 "merece algo de atención: :mod:`sys`, el que está integrado en todos los "
 "intérpretes de Python.  Las variables ``sys.ps1`` y ``sys.ps2`` definen las "
 "cadenas usadas como cursores primarios y secundarios::"
@@ -451,13 +450,13 @@ msgstr ""
 msgid ""
 "The variable ``sys.path`` is a list of strings that determines the "
 "interpreter's search path for modules. It is initialized to a default path "
-"taken from the environment variable :envvar:`PYTHONPATH`, or from a built-in"
-" default if :envvar:`PYTHONPATH` is not set.  You can modify it using "
+"taken from the environment variable :envvar:`PYTHONPATH`, or from a built-in "
+"default if :envvar:`PYTHONPATH` is not set.  You can modify it using "
 "standard list operations::"
 msgstr ""
 "La variable  ``sys.path`` es una lista de cadenas que determinan el camino "
-"de búsqueda del intérprete para los módulos.  Se inicializa por omisión a un"
-" camino tomado de la variable de entorno :envvar:`PYTHONPATH`, o a un valor "
+"de búsqueda del intérprete para los módulos.  Se inicializa por omisión a un "
+"camino tomado de la variable de entorno :envvar:`PYTHONPATH`, o a un valor "
 "predefinido en el intérprete si :envvar:`PYTHONPATH` no está configurada.  "
 "Lo podés modificar usando las operaciones estándar de listas::"
 
@@ -470,8 +469,8 @@ msgid ""
 "The built-in function :func:`dir` is used to find out which names a module "
 "defines.  It returns a sorted list of strings::"
 msgstr ""
-"La función integrada :func:`dir` se usa para encontrar qué nombres define un"
-" módulo.  Devuelve una lista ordenada de cadenas::"
+"La función integrada :func:`dir` se usa para encontrar qué nombres define un "
+"módulo.  Devuelve una lista ordenada de cadenas::"
 
 #: ../Doc/tutorial/modules.rst:327
 msgid ""
@@ -489,13 +488,13 @@ msgstr ""
 
 #: ../Doc/tutorial/modules.rst:339
 msgid ""
-":func:`dir` does not list the names of built-in functions and variables.  If"
-" you want a list of those, they are defined in the standard module "
-":mod:`builtins`::"
+":func:`dir` does not list the names of built-in functions and variables.  If "
+"you want a list of those, they are defined in the standard module :mod:"
+"`builtins`::"
 msgstr ""
 ":func:`dir` no lista los nombres de las funciones y variables integradas.  "
-"Si querés una lista de esos, están definidos en el módulo estándar "
-":mod:`builtins`::"
+"Si querés una lista de esos, están definidos en el módulo estándar :mod:"
+"`builtins`::"
 
 #: ../Doc/tutorial/modules.rst:378
 msgid "Packages"
@@ -504,11 +503,11 @@ msgstr "Paquetes"
 #: ../Doc/tutorial/modules.rst:380
 msgid ""
 "Packages are a way of structuring Python's module namespace by using "
-"\"dotted module names\".  For example, the module name :mod:`A.B` designates"
-" a submodule named ``B`` in a package named ``A``.  Just like the use of "
+"\"dotted module names\".  For example, the module name :mod:`A.B` designates "
+"a submodule named ``B`` in a package named ``A``.  Just like the use of "
 "modules saves the authors of different modules from having to worry about "
-"each other's global variable names, the use of dotted module names saves the"
-" authors of multi-module packages like NumPy or Pillow from having to worry "
+"each other's global variable names, the use of dotted module names saves the "
+"authors of multi-module packages like NumPy or Pillow from having to worry "
 "about each other's module names."
 msgstr ""
 
@@ -531,21 +530,21 @@ msgstr ""
 "de archivos de sonido (normalmente reconocidos por su extensión, por "
 "ejemplo: :file:`.wav`, :file:`.aiff`, :file:`.au`), por lo que tenés que "
 "crear y mantener una colección siempre creciente de módulos para la "
-"conversión entre los distintos formatos de archivos.  Hay muchas operaciones"
-" diferentes que quizás quieras ejecutar en los datos de sonido (como "
+"conversión entre los distintos formatos de archivos.  Hay muchas operaciones "
+"diferentes que quizás quieras ejecutar en los datos de sonido (como "
 "mezclarlos, añadir eco, aplicar una función ecualizadora, crear un efecto "
-"estéreo artificial), por lo que ademas estarás escribiendo una lista sin fin"
-" de módulos para realizar estas operaciones.  Aquí hay una posible "
-"estructura para tu paquete (expresados en términos de un sistema jerárquico "
-"de archivos):"
+"estéreo artificial), por lo que ademas estarás escribiendo una lista sin fin "
+"de módulos para realizar estas operaciones.  Aquí hay una posible estructura "
+"para tu paquete (expresados en términos de un sistema jerárquico de "
+"archivos):"
 
 #: ../Doc/tutorial/modules.rst:425
 msgid ""
-"When importing the package, Python searches through the directories on "
-"``sys.path`` looking for the package subdirectory."
+"When importing the package, Python searches through the directories on ``sys."
+"path`` looking for the package subdirectory."
 msgstr ""
-"Al importar el paquete, Python busca a través de los directorios en "
-"``sys.path``, buscando el subdirectorio del paquete."
+"Al importar el paquete, Python busca a través de los directorios en ``sys."
+"path``, buscando el subdirectorio del paquete."
 
 #: ../Doc/tutorial/modules.rst:428
 msgid ""
@@ -562,8 +561,8 @@ msgid ""
 "Users of the package can import individual modules from the package, for "
 "example::"
 msgstr ""
-"Los usuarios del paquete pueden importar módulos individuales del mismo, por"
-" ejemplo::"
+"Los usuarios del paquete pueden importar módulos individuales del mismo, por "
+"ejemplo::"
 
 #: ../Doc/tutorial/modules.rst:440
 msgid ""
@@ -594,8 +593,8 @@ msgstr ""
 
 #: ../Doc/tutorial/modules.rst:458
 msgid ""
-"Again, this loads the submodule :mod:`echo`, but this makes its function "
-":func:`echofilter` directly available::"
+"Again, this loads the submodule :mod:`echo`, but this makes its function :"
+"func:`echofilter` directly available::"
 msgstr ""
 "De nuevo, esto carga el submódulo :mod:`echo`, pero deja directamente "
 "disponible a la función :func:`echofilter`::"
@@ -603,30 +602,30 @@ msgstr ""
 #: ../Doc/tutorial/modules.rst:463
 msgid ""
 "Note that when using ``from package import item``, the item can be either a "
-"submodule (or subpackage) of the package, or some  other name defined in the"
-" package, like a function, class or variable.  The ``import`` statement "
-"first tests whether the item is defined in the package; if not, it assumes "
-"it is a module and attempts to load it.  If it fails to find it, an "
-":exc:`ImportError` exception is raised."
+"submodule (or subpackage) of the package, or some  other name defined in the "
+"package, like a function, class or variable.  The ``import`` statement first "
+"tests whether the item is defined in the package; if not, it assumes it is a "
+"module and attempts to load it.  If it fails to find it, an :exc:"
+"`ImportError` exception is raised."
 msgstr ""
 "Notá que al usar ``from package import item`` el ítem puede ser tanto un "
 "submódulo (o subpaquete) del paquete, o algún otro nombre definido en el "
 "paquete, como una función, clase, o variable.  La declaración ``import`` "
-"primero verifica si el ítem está definido en el paquete; si no, asume que es"
-" un módulo y trata de cargarlo.  Si no lo puede encontrar, se genera una "
+"primero verifica si el ítem está definido en el paquete; si no, asume que es "
+"un módulo y trata de cargarlo.  Si no lo puede encontrar, se genera una "
 "excepción :exc:`ImportError`."
 
 #: ../Doc/tutorial/modules.rst:470
 msgid ""
 "Contrarily, when using syntax like ``import item.subitem.subsubitem``, each "
-"item except for the last must be a package; the last item can be a module or"
-" a package but can't be a class or function or variable defined in the "
+"item except for the last must be a package; the last item can be a module or "
+"a package but can't be a class or function or variable defined in the "
 "previous item."
 msgstr ""
-"Por otro lado, cuando se usa la sintaxis como ``import "
-"item.subitem.subsubitem``, cada ítem excepto el último debe ser un paquete; "
-"el mismo puede ser un módulo o un paquete pero no puede ser una clase, "
-"función o variable definida en el ítem previo."
+"Por otro lado, cuando se usa la sintaxis como ``import item.subitem."
+"subsubitem``, cada ítem excepto el último debe ser un paquete; el mismo "
+"puede ser un módulo o un paquete pero no puede ser una clase, función o "
+"variable definida en el ítem previo."
 
 #: ../Doc/tutorial/modules.rst:479
 msgid "Importing \\* From a Package"
@@ -650,23 +649,23 @@ msgstr ""
 #: ../Doc/tutorial/modules.rst:489
 msgid ""
 "The only solution is for the package author to provide an explicit index of "
-"the package.  The :keyword:`import` statement uses the following convention:"
-" if a package's :file:`__init__.py` code defines a list named ``__all__``, "
-"it is taken to be the list of module names that should be imported when "
-"``from package import *`` is encountered.  It is up to the package author to"
-" keep this list up-to-date when a new version of the package is released.  "
-"Package authors may also decide not to support it, if they don't see a use "
-"for importing \\* from their package.  For example, the file "
-":file:`sound/effects/__init__.py` could contain the following code::"
-msgstr ""
-"La única solución es que el autor del paquete provea un índice explícito del"
-" paquete.  La declaración :keyword:`import` usa la siguiente convención: si "
+"the package.  The :keyword:`import` statement uses the following convention: "
+"if a package's :file:`__init__.py` code defines a list named ``__all__``, it "
+"is taken to be the list of module names that should be imported when ``from "
+"package import *`` is encountered.  It is up to the package author to keep "
+"this list up-to-date when a new version of the package is released.  Package "
+"authors may also decide not to support it, if they don't see a use for "
+"importing \\* from their package.  For example, the file :file:`sound/"
+"effects/__init__.py` could contain the following code::"
+msgstr ""
+"La única solución es que el autor del paquete provea un índice explícito del "
+"paquete.  La declaración :keyword:`import` usa la siguiente convención: si "
 "el código del :file:`__init__.py` de un paquete define una lista llamada "
 "``__all__``, se toma como la lista de los nombres de módulos que deberían "
-"ser importados cuando se hace ``from package import *``.  Es tarea del autor"
-" del paquete mantener actualizada esta lista cuando se libera una nueva "
-"versión del paquete.  Los autores de paquetes podrían decidir no soportarlo,"
-" si no ven un uso para importar \\* en sus paquetes.  Por ejemplo, el "
+"ser importados cuando se hace ``from package import *``.  Es tarea del autor "
+"del paquete mantener actualizada esta lista cuando se libera una nueva "
+"versión del paquete.  Los autores de paquetes podrían decidir no soportarlo, "
+"si no ven un uso para importar \\* en sus paquetes.  Por ejemplo, el "
 "archivo :file:`sound/effects/__init__.py` podría contener el siguiente "
 "código::"
 
@@ -680,22 +679,22 @@ msgstr ""
 
 #: ../Doc/tutorial/modules.rst:504
 msgid ""
-"If ``__all__`` is not defined, the statement ``from sound.effects import *``"
-" does *not* import all submodules from the package :mod:`sound.effects` into"
-" the current namespace; it only ensures that the package "
-":mod:`sound.effects` has been imported (possibly running any initialization "
-"code in :file:`__init__.py`) and then imports whatever names are defined in "
-"the package.  This includes any names defined (and submodules explicitly "
-"loaded) by :file:`__init__.py`.  It also includes any submodules of the "
-"package that were explicitly loaded by previous :keyword:`import` "
-"statements.  Consider this code::"
+"If ``__all__`` is not defined, the statement ``from sound.effects import *`` "
+"does *not* import all submodules from the package :mod:`sound.effects` into "
+"the current namespace; it only ensures that the package :mod:`sound.effects` "
+"has been imported (possibly running any initialization code in :file:"
+"`__init__.py`) and then imports whatever names are defined in the package.  "
+"This includes any names defined (and submodules explicitly loaded) by :file:"
+"`__init__.py`.  It also includes any submodules of the package that were "
+"explicitly loaded by previous :keyword:`import` statements.  Consider this "
+"code::"
 msgstr ""
 "Si no se define ``__all__``, la declaración ``from sound.effects import *`` "
 "*no* importa todos los submódulos del paquete :mod:`sound.effects` al "
-"espacio de nombres actual; sólo se asegura que se haya importado el paquete "
-":mod:`sound.effects` (posiblemente ejecutando algún código de inicialización"
-" que haya en :file:`__init__.py`) y luego importa aquellos nombres que estén"
-" definidos en el paquete.  Esto incluye cualquier nombre definido (y "
+"espacio de nombres actual; sólo se asegura que se haya importado el paquete :"
+"mod:`sound.effects` (posiblemente ejecutando algún código de inicialización "
+"que haya en :file:`__init__.py`) y luego importa aquellos nombres que estén "
+"definidos en el paquete.  Esto incluye cualquier nombre definido (y "
 "submódulos explícitamente cargados) por :file:`__init__.py`.  También "
 "incluye cualquier submódulo del paquete que pudiera haber sido "
 "explícitamente cargado por declaraciones :keyword:`import` previas.  "
@@ -703,8 +702,8 @@ msgstr ""
 
 #: ../Doc/tutorial/modules.rst:517
 msgid ""
-"In this example, the :mod:`echo` and :mod:`surround` modules are imported in"
-" the current namespace because they are defined in the :mod:`sound.effects` "
+"In this example, the :mod:`echo` and :mod:`surround` modules are imported in "
+"the current namespace because they are defined in the :mod:`sound.effects` "
 "package when the ``from...import`` statement is executed.  (This also works "
 "when ``__all__`` is defined.)"
 msgstr ""
@@ -738,29 +737,28 @@ msgstr "Referencias internas en paquetes"
 #: ../Doc/tutorial/modules.rst:535
 msgid ""
 "When packages are structured into subpackages (as with the :mod:`sound` "
-"package in the example), you can use absolute imports to refer to submodules"
-" of siblings packages.  For example, if the module "
-":mod:`sound.filters.vocoder` needs to use the :mod:`echo` module in the "
-":mod:`sound.effects` package, it can use ``from sound.effects import echo``."
-msgstr ""
-"Cuando se estructuran los paquetes en subpaquetes (como en el ejemplo "
-":mod:`sound`), podés usar ``import`` absolutos para referirte a submódulos "
-"de paquetes hermanos.  Por ejemplo, si el módulo "
-":mod:`sound.filters.vocoder` necesita usar el módulo :mod:`echo` en el "
-"paquete :mod:`sound.effects`, puede hacer ``from sound.effects import "
-"echo``."
+"package in the example), you can use absolute imports to refer to submodules "
+"of siblings packages.  For example, if the module :mod:`sound.filters."
+"vocoder` needs to use the :mod:`echo` module in the :mod:`sound.effects` "
+"package, it can use ``from sound.effects import echo``."
+msgstr ""
+"Cuando se estructuran los paquetes en subpaquetes (como en el ejemplo :mod:"
+"`sound`), podés usar ``import`` absolutos para referirte a submódulos de "
+"paquetes hermanos.  Por ejemplo, si el módulo :mod:`sound.filters.vocoder` "
+"necesita usar el módulo :mod:`echo` en el paquete :mod:`sound.effects`, "
+"puede hacer ``from sound.effects import echo``."
 
 #: ../Doc/tutorial/modules.rst:541
 msgid ""
 "You can also write relative imports, with the ``from module import name`` "
 "form of import statement.  These imports use leading dots to indicate the "
-"current and parent packages involved in the relative import.  From the "
-":mod:`surround` module for example, you might use::"
+"current and parent packages involved in the relative import.  From the :mod:"
+"`surround` module for example, you might use::"
 msgstr ""
 "También podés escribir ``import`` relativos con la forma ``from module "
-"import name``.  Estos imports usan puntos adelante para indicar los paquetes"
-" actual o padres involucrados en el import relativo. En el ejemplo "
-":mod:`surround`, podrías hacer::"
+"import name``.  Estos imports usan puntos adelante para indicar los paquetes "
+"actual o padres involucrados en el import relativo. En el ejemplo :mod:"
+"`surround`, podrías hacer::"
 
 #: ../Doc/tutorial/modules.rst:550
 msgid ""
@@ -770,9 +768,9 @@ msgid ""
 "absolute imports."
 msgstr ""
 "Notá que los imports relativos se basan en el nombre del módulo actual.  Ya "
-"que el nombre del módulo principal es siempre ``\"__main__\"``,  los módulos"
-" pensados para usarse como módulo principal de una aplicación Python siempre"
-" deberían usar ``import`` absolutos."
+"que el nombre del módulo principal es siempre ``\"__main__\"``,  los módulos "
+"pensados para usarse como módulo principal de una aplicación Python siempre "
+"deberían usar ``import`` absolutos."
 
 #: ../Doc/tutorial/modules.rst:556
 msgid "Packages in Multiple Directories"
diff --git a/tutorial/stdlib.po b/tutorial/stdlib.po
index 73223fea75..6f771c7556 100644
--- a/tutorial/stdlib.po
+++ b/tutorial/stdlib.po
@@ -39,8 +39,8 @@ msgid ""
 "function which operates much differently."
 msgstr ""
 "Asegurate de usar el estilo ``import os`` en lugar de ``from os import *``. "
-"Esto evitará que :func:`os.open` oculte a la función integrada :func:`open`,"
-" que trabaja bastante diferente."
+"Esto evitará que :func:`os.open` oculte a la función integrada :func:`open`, "
+"que trabaja bastante diferente."
 
 #: ../Doc/tutorial/stdlib.rst:29
 msgid ""
@@ -55,9 +55,8 @@ msgid ""
 "For daily file and directory management tasks, the :mod:`shutil` module "
 "provides a higher level interface that is easier to use::"
 msgstr ""
-"Para tareas diarias de administración de archivos y directorios, el módulo "
-":mod:`shutil` provee una interfaz de más alto nivel que es más fácil de "
-"usar::"
+"Para tareas diarias de administración de archivos y directorios, el módulo :"
+"mod:`shutil` provee una interfaz de más alto nivel que es más fácil de usar::"
 
 #: ../Doc/tutorial/stdlib.rst:51
 msgid "File Wildcards"
@@ -78,14 +77,14 @@ msgstr "Argumentos de linea de órdenes"
 #: ../Doc/tutorial/stdlib.rst:66
 msgid ""
 "Common utility scripts often need to process command line arguments. These "
-"arguments are stored in the :mod:`sys` module's *argv* attribute as a list."
-"  For instance the following output results from running ``python demo.py "
-"one two three`` at the command line::"
+"arguments are stored in the :mod:`sys` module's *argv* attribute as a list.  "
+"For instance the following output results from running ``python demo.py one "
+"two three`` at the command line::"
 msgstr ""
 "Los programas frecuentemente necesitan procesar argumentos de linea de "
-"órdenes. Estos argumentos se almacenan en el atributo *argv* del módulo "
-":mod:`sys` como una lista.  Por ejemplo, la siguiente salida resulta de "
-"ejecutar ``python demo.py uno dos tres`` en la línea de órdenes::"
+"órdenes. Estos argumentos se almacenan en el atributo *argv* del módulo :mod:"
+"`sys` como una lista.  Por ejemplo, la siguiente salida resulta de ejecutar "
+"``python demo.py uno dos tres`` en la línea de órdenes::"
 
 #: ../Doc/tutorial/stdlib.rst:75
 msgid ""
@@ -122,8 +121,8 @@ msgstr "Coincidencia en patrones de cadenas"
 #: ../Doc/tutorial/stdlib.rst:100
 msgid ""
 "The :mod:`re` module provides regular expression tools for advanced string "
-"processing. For complex matching and manipulation, regular expressions offer"
-" succinct, optimized solutions::"
+"processing. For complex matching and manipulation, regular expressions offer "
+"succinct, optimized solutions::"
 msgstr ""
 "El módulo :mod:`re` provee herramientas de expresiones regulares para un "
 "procesamiento avanzado de cadenas.  Para manipulación y coincidencias "
@@ -183,12 +182,11 @@ msgid ""
 "retrieving data from URLs and :mod:`smtplib` for sending mail::"
 msgstr ""
 "Hay varios módulos para acceder a internet y procesar sus protocolos.  Dos "
-"de los más simples son :mod:`urllib.request` para traer data de URLs y "
-":mod:`smtplib` para mandar correos::"
+"de los más simples son :mod:`urllib.request` para traer data de URLs y :mod:"
+"`smtplib` para mandar correos::"
 
 #: ../Doc/tutorial/stdlib.rst:186
-msgid ""
-"(Note that the second example needs a mailserver running on localhost.)"
+msgid "(Note that the second example needs a mailserver running on localhost.)"
 msgstr ""
 "(Notá que el segundo ejemplo necesita un servidor de correo corriendo en la "
 "máquina local)"
@@ -199,10 +197,10 @@ msgstr "Fechas y tiempos"
 
 #: ../Doc/tutorial/stdlib.rst:194
 msgid ""
-"The :mod:`datetime` module supplies classes for manipulating dates and times"
-" in both simple and complex ways. While date and time arithmetic is "
-"supported, the focus of the implementation is on efficient member extraction"
-" for output formatting and manipulation.  The module also supports objects "
+"The :mod:`datetime` module supplies classes for manipulating dates and times "
+"in both simple and complex ways. While date and time arithmetic is "
+"supported, the focus of the implementation is on efficient member extraction "
+"for output formatting and manipulation.  The module also supports objects "
 "that are timezone aware. ::"
 msgstr ""
 "El módulo :mod:`datetime` ofrece clases para manejar fechas y tiempos tanto "
@@ -218,12 +216,12 @@ msgstr "Compresión de datos"
 #: ../Doc/tutorial/stdlib.rst:220
 msgid ""
 "Common data archiving and compression formats are directly supported by "
-"modules including: :mod:`zlib`, :mod:`gzip`, :mod:`bz2`, :mod:`lzma`, "
-":mod:`zipfile` and :mod:`tarfile`. ::"
+"modules including: :mod:`zlib`, :mod:`gzip`, :mod:`bz2`, :mod:`lzma`, :mod:"
+"`zipfile` and :mod:`tarfile`. ::"
 msgstr ""
 "Los formatos para archivar y comprimir datos se soportan directamente con "
-"los módulos: :mod:`zlib`, :mod:`gzip`, :mod:`bz2`, :mod:`lzma`, "
-":mod:`zipfile` y :mod:`tarfile`.  ::"
+"los módulos: :mod:`zlib`, :mod:`gzip`, :mod:`bz2`, :mod:`lzma`, :mod:"
+"`zipfile` y :mod:`tarfile`.  ::"
 
 #: ../Doc/tutorial/stdlib.rst:240
 msgid "Performance Measurement"
@@ -236,15 +234,15 @@ msgid ""
 "measurement tool that answers those questions immediately."
 msgstr ""
 "Algunos usuarios de Python desarrollan un profundo interés en saber el "
-"rendimiento relativo de las diferentes soluciones al mismo problema.  Python"
-" provee una herramienta de medición que responde esas preguntas "
+"rendimiento relativo de las diferentes soluciones al mismo problema.  Python "
+"provee una herramienta de medición que responde esas preguntas "
 "inmediatamente."
 
 #: ../Doc/tutorial/stdlib.rst:246
 msgid ""
 "For example, it may be tempting to use the tuple packing and unpacking "
-"feature instead of the traditional approach to swapping arguments. The "
-":mod:`timeit` module quickly demonstrates a modest performance advantage::"
+"feature instead of the traditional approach to swapping arguments. The :mod:"
+"`timeit` module quickly demonstrates a modest performance advantage::"
 msgstr ""
 "Por ejemplo, puede ser tentador usar la característica de empaquetamiento y "
 "desempaquetamiento de las tuplas en lugar de la solución tradicional para "
@@ -253,13 +251,13 @@ msgstr ""
 
 #: ../Doc/tutorial/stdlib.rst:256
 msgid ""
-"In contrast to :mod:`timeit`'s fine level of granularity, the :mod:`profile`"
-" and :mod:`pstats` modules provide tools for identifying time critical "
+"In contrast to :mod:`timeit`'s fine level of granularity, the :mod:`profile` "
+"and :mod:`pstats` modules provide tools for identifying time critical "
 "sections in larger blocks of code."
 msgstr ""
-"En contraste con el fino nivel de granularidad del módulo :mod:`timeit`, los"
-" módulos :mod:`profile` y :mod:`pstats` proveen herramientas para "
-"identificar secciones críticas de tiempo en bloques de código más grandes."
+"En contraste con el fino nivel de granularidad del módulo :mod:`timeit`, los "
+"módulos :mod:`profile` y :mod:`pstats` proveen herramientas para identificar "
+"secciones críticas de tiempo en bloques de código más grandes."
 
 #: ../Doc/tutorial/stdlib.rst:264
 msgid "Quality Control"
@@ -267,30 +265,30 @@ msgstr "Control de calidad"
 
 #: ../Doc/tutorial/stdlib.rst:266
 msgid ""
-"One approach for developing high quality software is to write tests for each"
-" function as it is developed and to run those tests frequently during the "
+"One approach for developing high quality software is to write tests for each "
+"function as it is developed and to run those tests frequently during the "
 "development process."
 msgstr ""
-"Una forma para desarrollar software de alta calidad es escribir pruebas para"
-" cada función mientras se la desarrolla, y correr esas pruebas "
-"frecuentemente durante el proceso de desarrollo."
+"Una forma para desarrollar software de alta calidad es escribir pruebas para "
+"cada función mientras se la desarrolla, y correr esas pruebas frecuentemente "
+"durante el proceso de desarrollo."
 
 #: ../Doc/tutorial/stdlib.rst:270
 msgid ""
 "The :mod:`doctest` module provides a tool for scanning a module and "
 "validating tests embedded in a program's docstrings.  Test construction is "
 "as simple as cutting-and-pasting a typical call along with its results into "
-"the docstring. This improves the documentation by providing the user with an"
-" example and it allows the doctest module to make sure the code remains true"
-" to the documentation::"
+"the docstring. This improves the documentation by providing the user with an "
+"example and it allows the doctest module to make sure the code remains true "
+"to the documentation::"
 msgstr ""
 "El módulo :mod:`doctest` provee una herramienta para revisar un módulo y "
 "validar las pruebas integradas en las cadenas de documentación (o "
 "*docstring*) del programa.  La construcción de las pruebas es tan sencillo "
 "como cortar y pegar una ejecución típica junto con sus resultados en los "
-"docstrings.  Esto mejora la documentación al proveer al usuario un ejemplo y"
-" permite que el módulo :mod:`doctest` se asegure que el código permanece "
-"fiel a la documentación::"
+"docstrings.  Esto mejora la documentación al proveer al usuario un ejemplo y "
+"permite que el módulo :mod:`doctest` se asegure que el código permanece fiel "
+"a la documentación::"
 
 #: ../Doc/tutorial/stdlib.rst:288
 msgid ""
@@ -298,9 +296,9 @@ msgid ""
 "module, but it allows a more comprehensive set of tests to be maintained in "
 "a separate file::"
 msgstr ""
-"El módulo :mod:`unittest` necesita más esfuerzo que el módulo "
-":mod:`doctest`, pero permite que se mantenga en un archivo separado un "
-"conjunto más comprensivo de pruebas::"
+"El módulo :mod:`unittest` necesita más esfuerzo que el módulo :mod:"
+"`doctest`, pero permite que se mantenga en un archivo separado un conjunto "
+"más comprensivo de pruebas::"
 
 #: ../Doc/tutorial/stdlib.rst:310
 msgid "Batteries Included"
diff --git a/tutorial/stdlib2.po b/tutorial/stdlib2.po
index eb26c286ea..c5d6e8ea54 100644
--- a/tutorial/stdlib2.po
+++ b/tutorial/stdlib2.po
@@ -44,15 +44,14 @@ msgstr ""
 msgid ""
 "The :mod:`pprint` module offers more sophisticated control over printing "
 "both built-in and user defined objects in a way that is readable by the "
-"interpreter. When the result is longer than one line, the \"pretty printer\""
-" adds line breaks and indentation to more clearly reveal data structure::"
+"interpreter. When the result is longer than one line, the \"pretty printer\" "
+"adds line breaks and indentation to more clearly reveal data structure::"
 msgstr ""
-"El módulo :mod:`pprint` ofrece un control más sofisticado de la forma en que"
-" se imprimen tanto los objetos predefinidos como los objetos definidos por "
-"el usuario, de manera que sean legibles por el intérprete. Cuando el "
-"resultado ocupa más de una línea, el generador de \"impresiones lindas\" "
-"agrega saltos de línea y sangrías para mostrar la estructura de los datos "
-"más claramente::"
+"El módulo :mod:`pprint` ofrece un control más sofisticado de la forma en que "
+"se imprimen tanto los objetos predefinidos como los objetos definidos por el "
+"usuario, de manera que sean legibles por el intérprete. Cuando el resultado "
+"ocupa más de una línea, el generador de \"impresiones lindas\" agrega saltos "
+"de línea y sangrías para mostrar la estructura de los datos más claramente::"
 
 #: ../Doc/tutorial/stdlib2.rst:39
 msgid ""
@@ -68,8 +67,8 @@ msgid ""
 "formats. The grouping attribute of locale's format function provides a "
 "direct way of formatting numbers with group separators::"
 msgstr ""
-"El módulo :mod:`locale` accede a una base de datos de formatos específicos a"
-" una cultura.  El atributo `grouping` de la función :func:`format` permite "
+"El módulo :mod:`locale` accede a una base de datos de formatos específicos a "
+"una cultura.  El atributo `grouping` de la función :func:`format` permite "
 "una forma directa de formatear números con separadores de grupo::"
 
 #: ../Doc/tutorial/stdlib2.rst:72
@@ -83,39 +82,39 @@ msgid ""
 "allows users to customize their applications without having to alter the "
 "application."
 msgstr ""
-"El módulo :mod:`string` incluye una clase versátil :class:`~string.Template`"
-" (plantilla) con una sintaxis simplificada apta para ser editada por "
-"usuarios finales.  Esto permite que los usuarios personalicen sus "
-"aplicaciones sin necesidad de modificar la aplicación en sí."
+"El módulo :mod:`string` incluye una clase versátil :class:`~string.Template` "
+"(plantilla) con una sintaxis simplificada apta para ser editada por usuarios "
+"finales.  Esto permite que los usuarios personalicen sus aplicaciones sin "
+"necesidad de modificar la aplicación en sí."
 
 #: ../Doc/tutorial/stdlib2.rst:78
 msgid ""
 "The format uses placeholder names formed by ``$`` with valid Python "
 "identifiers (alphanumeric characters and underscores).  Surrounding the "
 "placeholder with braces allows it to be followed by more alphanumeric "
-"letters with no intervening spaces.  Writing ``$$`` creates a single escaped"
-" ``$``::"
+"letters with no intervening spaces.  Writing ``$$`` creates a single escaped "
+"``$``::"
 msgstr ""
 "El formato usa marcadores cuyos nombres se forman con ``$`` seguido de "
 "identificadores Python válidos (caracteres alfanuméricos y guión de "
 "subrayado). Si se los encierra entre llaves, pueden seguir más caracteres "
-"alfanuméricos sin necesidad de dejar espacios en blanco. ``$$`` genera un "
-"``$``::"
+"alfanuméricos sin necesidad de dejar espacios en blanco. ``$$`` genera un ``"
+"$``::"
 
 #: ../Doc/tutorial/stdlib2.rst:88
 msgid ""
-"The :meth:`~string.Template.substitute` method raises a :exc:`KeyError` when"
-" a placeholder is not supplied in a dictionary or a keyword argument.  For "
-"mail-merge style applications, user supplied data may be incomplete and the "
-":meth:`~string.Template.safe_substitute` method may be more appropriate --- "
+"The :meth:`~string.Template.substitute` method raises a :exc:`KeyError` when "
+"a placeholder is not supplied in a dictionary or a keyword argument.  For "
+"mail-merge style applications, user supplied data may be incomplete and the :"
+"meth:`~string.Template.safe_substitute` method may be more appropriate --- "
 "it will leave placeholders unchanged if data is missing::"
 msgstr ""
 "El método :meth:`~string.Temaplte.substitute` lanza :exc:`KeyError` cuando "
 "no se suministra ningún valor para un marcador mediante un diccionario o "
-"argumento por nombre.  Para algunas aplicaciones los datos suministrados por"
-" el usuario puede ser incompletos, y el método "
-":meth:`~string.Template.safe_substitute` puede ser más apropiado: deja los "
-"marcadores inalterados cuando hay datos faltantes::"
+"argumento por nombre.  Para algunas aplicaciones los datos suministrados por "
+"el usuario puede ser incompletos, y el método :meth:`~string.Template."
+"safe_substitute` puede ser más apropiado: deja los marcadores inalterados "
+"cuando hay datos faltantes::"
 
 #: ../Doc/tutorial/stdlib2.rst:103
 msgid ""
@@ -135,8 +134,8 @@ msgid ""
 "details of multiple output formats.  This makes it possible to substitute "
 "custom templates for XML files, plain text reports, and HTML web reports."
 msgstr ""
-"Las plantillas también pueden ser usadas para separar la lógica del programa"
-" de los detalles de múltiples formatos de salida.  Esto permite sustituir "
+"Las plantillas también pueden ser usadas para separar la lógica del programa "
+"de los detalles de múltiples formatos de salida.  Esto permite sustituir "
 "plantillas específicas para archivos XML, reportes en texto plano, y "
 "reportes web en HTML."
 
@@ -146,21 +145,20 @@ msgstr "Trabajar con registros estructurados conteniendo datos binarios"
 
 #: ../Doc/tutorial/stdlib2.rst:135
 msgid ""
-"The :mod:`struct` module provides :func:`~struct.pack` and "
-":func:`~struct.unpack` functions for working with variable length binary "
-"record formats.  The following example shows how to loop through header "
-"information in a ZIP file without using the :mod:`zipfile` module.  Pack "
-"codes ``\"H\"`` and ``\"I\"`` represent two and four byte unsigned numbers "
-"respectively.  The ``\"<\"`` indicates that they are standard size and in "
-"little-endian byte order::"
+"The :mod:`struct` module provides :func:`~struct.pack` and :func:`~struct."
+"unpack` functions for working with variable length binary record formats.  "
+"The following example shows how to loop through header information in a ZIP "
+"file without using the :mod:`zipfile` module.  Pack codes ``\"H\"`` and ``\"I"
+"\"`` represent two and four byte unsigned numbers respectively.  The ``\"<"
+"\"`` indicates that they are standard size and in little-endian byte order::"
 msgstr ""
-"El módulo :mod:`struct` provee las funciones :func:`~struct.pack` y "
-":func:`~struct.unpack` para trabajar con formatos de registros binarios de "
+"El módulo :mod:`struct` provee las funciones :func:`~struct.pack` y :func:"
+"`~struct.unpack` para trabajar con formatos de registros binarios de "
 "longitud variable.  El siguiente ejemplo muestra cómo recorrer la "
-"información de encabezado en un archivo ZIP sin usar el módulo "
-":mod:`zipfile`.  Los códigos ``\"H\"`` e ``\"I\"`` representan números sin "
-"signo de dos y cuatro bytes respectivamente.  El ``\"<\"`` indica que son de"
-" tamaño estándar y los bytes tienen ordenamiento `little-endian`::"
+"información de encabezado en un archivo ZIP sin usar el módulo :mod:"
+"`zipfile`.  Los códigos ``\"H\"`` e ``\"I\"`` representan números sin signo "
+"de dos y cuatro bytes respectivamente.  El ``\"<\"`` indica que son de "
+"tamaño estándar y los bytes tienen ordenamiento `little-endian`::"
 
 #: ../Doc/tutorial/stdlib2.rst:166
 msgid "Multi-threading"
@@ -196,8 +194,8 @@ msgid ""
 "module provides a number of synchronization primitives including locks, "
 "events, condition variables, and semaphores."
 msgstr ""
-"El desafío principal de las aplicaciones multi-hilo es la coordinación entre"
-" los hilos que comparten datos u otros recursos.  A ese fin, el módulo "
+"El desafío principal de las aplicaciones multi-hilo es la coordinación entre "
+"los hilos que comparten datos u otros recursos.  A ese fin, el módulo "
 "threading provee una serie de primitivas de sincronización que incluyen "
 "locks, eventos, variables de condición, y semáforos."
 
@@ -212,12 +210,12 @@ msgid ""
 "and more reliable."
 msgstr ""
 "Aún cuando esas herramientas son poderosas, pequeños errores de diseño "
-"pueden resultar en problemas difíciles de reproducir.  La forma preferida de"
-" coordinar tareas es concentrar todos los accesos a un recurso en un único "
+"pueden resultar en problemas difíciles de reproducir.  La forma preferida de "
+"coordinar tareas es concentrar todos los accesos a un recurso en un único "
 "hilo y después usar el módulo :mod:`queue` para alimentar dicho hilo con "
-"pedidos desde otros hilos.  Las aplicaciones que usan objetos "
-":class:`~queue.Queue` para comunicación y coordinación entre hilos son más "
-"fáciles de diseñar, más legibles, y más confiables."
+"pedidos desde otros hilos.  Las aplicaciones que usan objetos :class:`~queue."
+"Queue` para comunicación y coordinación entre hilos son más fáciles de "
+"diseñar, más legibles, y más confiables."
 
 #: ../Doc/tutorial/stdlib2.rst:213
 msgid "Logging"
@@ -226,8 +224,8 @@ msgstr "Registrando"
 #: ../Doc/tutorial/stdlib2.rst:215
 msgid ""
 "The :mod:`logging` module offers a full featured and flexible logging "
-"system. At its simplest, log messages are sent to a file or to "
-"``sys.stderr``::"
+"system. At its simplest, log messages are sent to a file or to ``sys."
+"stderr``::"
 msgstr ""
 "El módulo :mod:`logging` ofrece un sistema de registros (logs) completo y "
 "flexible.  En su forma más simple, los mensajes de registro se envían a un "
@@ -242,17 +240,17 @@ msgid ""
 "By default, informational and debugging messages are suppressed and the "
 "output is sent to standard error.  Other output options include routing "
 "messages through email, datagrams, sockets, or to an HTTP Server.  New "
-"filters can select different routing based on message priority: "
-":const:`~logging.DEBUG`, :const:`~logging.INFO`, :const:`~logging.WARNING`, "
-":const:`~logging.ERROR`, and :const:`~logging.CRITICAL`."
+"filters can select different routing based on message priority: :const:"
+"`~logging.DEBUG`, :const:`~logging.INFO`, :const:`~logging.WARNING`, :const:"
+"`~logging.ERROR`, and :const:`~logging.CRITICAL`."
 msgstr ""
 "De forma predeterminada, los mensajes de depuración e informativos se "
 "suprimen, y la salida se envía al error estándar.  Otras opciones de salida "
 "incluyen mensajes de ruteo a través de correo electrónico, datagramas, "
 "sockets, o un servidor HTTP.  Nuevos filtros pueden seleccionar diferentes "
-"rutas basadas en la prioridad del mensaje: :const:`~logging.DEBUG`, "
-":const:`~logging.INFO`, :const:`~logging.WARNING`, :const:`~logging.ERROR`, "
-"and :const:`~logging.CRITICAL` (Depuración, Informativo, Atención, Error y "
+"rutas basadas en la prioridad del mensaje: :const:`~logging.DEBUG`, :const:"
+"`~logging.INFO`, :const:`~logging.WARNING`, :const:`~logging.ERROR`, and :"
+"const:`~logging.CRITICAL` (Depuración, Informativo, Atención, Error y "
 "Crítico respectivamente)"
 
 #: ../Doc/tutorial/stdlib2.rst:240
@@ -309,16 +307,16 @@ msgstr ""
 #: ../Doc/tutorial/stdlib2.rst:295
 msgid ""
 "The :mod:`array` module provides an :class:`~array.array()` object that is "
-"like a list that stores only homogeneous data and stores it more compactly."
-"  The following example shows an array of numbers stored as two byte "
-"unsigned binary numbers (typecode ``\"H\"``) rather than the usual 16 bytes "
-"per entry for regular lists of Python int objects::"
+"like a list that stores only homogeneous data and stores it more compactly.  "
+"The following example shows an array of numbers stored as two byte unsigned "
+"binary numbers (typecode ``\"H\"``) rather than the usual 16 bytes per entry "
+"for regular lists of Python int objects::"
 msgstr ""
-"El módulo :mod:`array` provee un objeto :class:`~array.array()` (vector) que"
-" es como una lista que almacena sólo datos homogéneos y de una manera más "
+"El módulo :mod:`array` provee un objeto :class:`~array.array()` (vector) que "
+"es como una lista que almacena sólo datos homogéneos y de una manera más "
 "compacta.  Los ejemplos a continuación muestran un vector de números "
-"guardados como dos números binarios sin signo de dos bytes (código de tipo "
-"``\"H\"``) en lugar de los 16 bytes por elemento habituales en listas de "
+"guardados como dos números binarios sin signo de dos bytes (código de tipo ``"
+"\"H\"``) en lugar de los 16 bytes por elemento habituales en listas de "
 "objetos int de Python::"
 
 #: ../Doc/tutorial/stdlib2.rst:308
@@ -329,26 +327,26 @@ msgid ""
 "implementing queues and breadth first tree searches::"
 msgstr ""
 "El módulo :mod:`collections` provee un objeto :class:`~collections.deque()` "
-"que es como una lista más rápida para agregar y quitar elementos por el lado"
-" izquierdo pero con búsquedas más lentas por el medio.  Estos objetos son "
+"que es como una lista más rápida para agregar y quitar elementos por el lado "
+"izquierdo pero con búsquedas más lentas por el medio.  Estos objetos son "
 "adecuados para implementar colas y árboles de búsqueda a lo ancho::"
 
 #: ../Doc/tutorial/stdlib2.rst:329
 msgid ""
 "In addition to alternative list implementations, the library also offers "
-"other tools such as the :mod:`bisect` module with functions for manipulating"
-" sorted lists::"
+"other tools such as the :mod:`bisect` module with functions for manipulating "
+"sorted lists::"
 msgstr ""
 "Además de las implementaciones alternativas de listas, la biblioteca ofrece "
-"otras herramientas como el módulo :mod:`bisect` con funciones para manipular"
-" listas ordenadas::"
+"otras herramientas como el módulo :mod:`bisect` con funciones para manipular "
+"listas ordenadas::"
 
 #: ../Doc/tutorial/stdlib2.rst:339
 msgid ""
 "The :mod:`heapq` module provides functions for implementing heaps based on "
 "regular lists.  The lowest valued entry is always kept at position zero.  "
-"This is useful for applications which repeatedly access the smallest element"
-" but do not want to run a full list sort::"
+"This is useful for applications which repeatedly access the smallest element "
+"but do not want to run a full list sort::"
 msgstr ""
 "El módulo :mod:`heapq` provee funciones para implementar heaps basados en "
 "listas comunes.  El menor valor ingresado se mantiene en la posición cero. "
@@ -366,9 +364,9 @@ msgid ""
 "implementation of binary floating point, the class is especially helpful for"
 msgstr ""
 "El módulo :mod:`decimal` provee un tipo de dato :class:`~decimal.Decimal` "
-"para soportar aritmética de punto flotante decimal.  Comparado con "
-":class:`float`, la implementación de punto flotante binario incluida, la "
-"clase es muy útil especialmente para:"
+"para soportar aritmética de punto flotante decimal.  Comparado con :class:"
+"`float`, la implementación de punto flotante binario incluida, la clase es "
+"muy útil especialmente para:"
 
 #: ../Doc/tutorial/stdlib2.rst:361
 msgid ""
@@ -401,8 +399,8 @@ msgid ""
 "becomes significant if the results are rounded to the nearest cent::"
 msgstr ""
 "Por ejemplo, calcular un impuesto del 5% de una tarifa telefónica de 70 "
-"centavos da resultados distintos con punto flotante decimal y punto flotante"
-" binario. La diferencia se vuelve significativa si los resultados se "
+"centavos da resultados distintos con punto flotante decimal y punto flotante "
+"binario. La diferencia se vuelve significativa si los resultados se "
 "redondean al centavo más próximo::"
 
 #: ../Doc/tutorial/stdlib2.rst:379
@@ -417,8 +415,8 @@ msgstr ""
 "calculando automáticamente cuatro cifras significativas a partir de los "
 "multiplicandos con dos cifras significativas.  Decimal reproduce la "
 "matemática como se la hace a mano, y evita problemas que pueden surgir "
-"cuando el punto flotante binario no puede representar exactamente cantidades"
-" decimales."
+"cuando el punto flotante binario no puede representar exactamente cantidades "
+"decimales."
 
 #: ../Doc/tutorial/stdlib2.rst:385
 msgid ""
diff --git a/tutorial/venv.po b/tutorial/venv.po
index 5330b6153e..f96d00d34f 100644
--- a/tutorial/venv.po
+++ b/tutorial/venv.po
@@ -32,18 +32,18 @@ msgid ""
 "bug has been fixed or the application may be written using an obsolete "
 "version of the library's interface."
 msgstr ""
-"Las aplicaciones en Python usualmente hacen uso de paquetes y módulos que no"
-" forman parte de la librería estándar. Las aplicaciones a veces necesitan "
-"una versión específica de una librería, debido a que dicha aplicación "
-"requiere que un bug particular haya sido solucionado o bien la aplicación ha"
-" sido escrita usando una versión obsoleta de la interface de la librería."
+"Las aplicaciones en Python usualmente hacen uso de paquetes y módulos que no "
+"forman parte de la librería estándar. Las aplicaciones a veces necesitan una "
+"versión específica de una librería, debido a que dicha aplicación requiere "
+"que un bug particular haya sido solucionado o bien la aplicación ha sido "
+"escrita usando una versión obsoleta de la interface de la librería."
 
 #: ../Doc/tutorial/venv.rst:17
 msgid ""
 "This means it may not be possible for one Python installation to meet the "
 "requirements of every application.  If application A needs version 1.0 of a "
-"particular module but application B needs version 2.0, then the requirements"
-" are in conflict and installing either version 1.0 or 2.0 will leave one "
+"particular module but application B needs version 2.0, then the requirements "
+"are in conflict and installing either version 1.0 or 2.0 will leave one "
 "application unable to run."
 msgstr ""
 "Esto significa que tal vez no sea posible para una instalación de Python "
@@ -71,8 +71,8 @@ msgid ""
 "application B requires a library be upgraded to version 3.0, this will not "
 "affect application A's environment."
 msgstr ""
-"Diferentes aplicaciones pueden entonces usar entornos virtuales diferentes."
-"  Para resolver el ejemplo de requerimientos en conflicto citado "
+"Diferentes aplicaciones pueden entonces usar entornos virtuales diferentes.  "
+"Para resolver el ejemplo de requerimientos en conflicto citado "
 "anteriormente, la aplicación A puede tener su propio entorno virtual con la "
 "versión 1.0 instalada mientras que la aplicación B tiene otro entorno "
 "virtual con la versión 2.0.  Si la aplicación B requiere que actualizar la "
@@ -85,17 +85,17 @@ msgstr "Creando Entornos Virtuales"
 
 #: ../Doc/tutorial/venv.rst:38
 msgid ""
-"The module used to create and manage virtual environments is called "
-":mod:`venv`.  :mod:`venv` will usually install the most recent version of "
-"Python that you have available. If you have multiple versions of Python on "
-"your system, you can select a specific Python version by running ``python3``"
-" or whichever version you want."
-msgstr ""
-"El script usado para crear y manejar entornos virtuales es "
-":program:`pyvenv`.  :program:`pyvenv` normalmente instalará la versión mas "
-"reciente de Python que tengas disponible; el script también es instalado con"
-" un número de versión, con lo que si tienes múltiples versiones de Python en"
-" tu sistema puedes seleccionar una versión de Python específica ejecutando "
+"The module used to create and manage virtual environments is called :mod:"
+"`venv`.  :mod:`venv` will usually install the most recent version of Python "
+"that you have available. If you have multiple versions of Python on your "
+"system, you can select a specific Python version by running ``python3`` or "
+"whichever version you want."
+msgstr ""
+"El script usado para crear y manejar entornos virtuales es :program:"
+"`pyvenv`.  :program:`pyvenv` normalmente instalará la versión mas reciente "
+"de Python que tengas disponible; el script también es instalado con un "
+"número de versión, con lo que si tienes múltiples versiones de Python en tu "
+"sistema puedes seleccionar una versión de Python específica ejecutando "
 "``python3`` o la versión que desees."
 
 #: ../Doc/tutorial/venv.rst:44
@@ -104,8 +104,8 @@ msgid ""
 "place it, and run the :mod:`venv` module as a script with the directory "
 "path::"
 msgstr ""
-"Para crear un virtualenv, decide en que carpeta quieres crearlo y ejecuta el"
-" módulo :mod:`venv` como script con la ruta a la carpeta::"
+"Para crear un virtualenv, decide en que carpeta quieres crearlo y ejecuta el "
+"módulo :mod:`venv` como script con la ruta a la carpeta::"
 
 #: ../Doc/tutorial/venv.rst:49
 msgid ""
@@ -114,8 +114,8 @@ msgid ""
 "interpreter, the standard library, and various supporting files."
 msgstr ""
 "Esto creará la carpeta ``tutorial-env`` si no existe, y también creará las "
-"subcarpetas conteniendo la copia del intérprete Python, la librería estándar"
-" y los archivos de soporte."
+"subcarpetas conteniendo la copia del intérprete Python, la librería estándar "
+"y los archivos de soporte."
 
 #: ../Doc/tutorial/venv.rst:53
 msgid "Once you've created a virtual environment, you may activate it."
@@ -135,9 +135,9 @@ msgid ""
 "or :program:`fish` shells, there are alternate ``activate.csh`` and "
 "``activate.fish`` scripts you should use instead.)"
 msgstr ""
-"(Este script está escrito para la consola bash. Si usas las consolas "
-":program:`csh` or :program:`fish`, hay scripts alternativos ``activate.csh``"
-" y ``activate.fish`` que deberá usar en su lugar)."
+"(Este script está escrito para la consola bash. Si usas las consolas :"
+"program:`csh` or :program:`fish`, hay scripts alternativos ``activate.csh`` "
+"y ``activate.fish`` que deberá usar en su lugar)."
 
 #: ../Doc/tutorial/venv.rst:68
 msgid ""
@@ -146,8 +146,8 @@ msgid ""
 "running ``python`` will get you that particular version and installation of "
 "Python. For example:"
 msgstr ""
-"Activar el entorno virtual cambiará el prompt de tu consola para mostrar que"
-" entorno virtual está usando, y modificará el entorno para que al ejecutar "
+"Activar el entorno virtual cambiará el prompt de tu consola para mostrar que "
+"entorno virtual está usando, y modificará el entorno para que al ejecutar "
 "``python`` sea con esa versión e instalación en particular.  Por ejemplo:"
 
 #: ../Doc/tutorial/venv.rst:87
@@ -156,8 +156,8 @@ msgstr "Manejando paquetes con pip"
 
 #: ../Doc/tutorial/venv.rst:89
 msgid ""
-"You can install, upgrade, and remove packages using a program called "
-":program:`pip`.  By default ``pip`` will install packages from the Python "
+"You can install, upgrade, and remove packages using a program called :"
+"program:`pip`.  By default ``pip`` will install packages from the Python "
 "Package Index, <https://pypi.org>.  You can browse the Python Package Index "
 "by going to it in your web browser, or you can use ``pip``'s limited search "
 "feature:"
@@ -165,8 +165,8 @@ msgstr ""
 
 #: ../Doc/tutorial/venv.rst:105
 msgid ""
-"``pip`` has a number of subcommands: \"search\", \"install\", \"uninstall\","
-" \"freeze\", etc.  (Consult the :ref:`installing-index` guide for complete "
+"``pip`` has a number of subcommands: \"search\", \"install\", \"uninstall\", "
+"\"freeze\", etc.  (Consult the :ref:`installing-index` guide for complete "
 "documentation for ``pip``.)"
 msgstr ""
 "``pip`` tiene varios subcomandos: \"search\", \"install\", \"uninstall\", "
@@ -186,8 +186,8 @@ msgid ""
 "You can also install a specific version of a package by giving the package "
 "name  followed by ``==`` and the version number:"
 msgstr ""
-"También se puede instalar una verisón específica de un paquete ingresando el"
-" nombre del paquete seguido de ``==`` y el número de versión:"
+"También se puede instalar una verisón específica de un paquete ingresando el "
+"nombre del paquete seguido de ``==`` y el número de versión:"
 
 #: ../Doc/tutorial/venv.rst:131
 msgid ""
@@ -223,27 +223,27 @@ msgstr ""
 #: ../Doc/tutorial/venv.rst:178
 msgid ""
 "``pip freeze`` will produce a similar list of the installed packages, but "
-"the output uses the format that ``pip install`` expects. A common convention"
-" is to put this list in a ``requirements.txt`` file:"
+"the output uses the format that ``pip install`` expects. A common convention "
+"is to put this list in a ``requirements.txt`` file:"
 msgstr ""
 "``pip freeze`` devuelve una lista de paquetes instalados similar, pero el "
-"formato de salida es el requerido por ``pip install``.  Una convención común"
-" es poner esta lista en un archivo ``requirements.txt``:"
+"formato de salida es el requerido por ``pip install``.  Una convención común "
+"es poner esta lista en un archivo ``requirements.txt``:"
 
 #: ../Doc/tutorial/venv.rst:190
 msgid ""
 "The ``requirements.txt`` can then be committed to version control and "
-"shipped as part of an application.  Users can then install all the necessary"
-" packages with ``install -r``:"
+"shipped as part of an application.  Users can then install all the necessary "
+"packages with ``install -r``:"
 msgstr ""
 "El archivo ``requirements.txt`` entonces puede ser agregado a nuestro "
-"control de versiones y distribuído como parte de la aplicación. Los usuarios"
-" pueden entonces instalar todos los paquetes necesarios con ``install -r``:"
+"control de versiones y distribuído como parte de la aplicación. Los usuarios "
+"pueden entonces instalar todos los paquetes necesarios con ``install -r``:"
 
 #: ../Doc/tutorial/venv.rst:207
 msgid ""
 "``pip`` has many more options.  Consult the :ref:`installing-index` guide "
 "for complete documentation for ``pip``.  When you've written a package and "
-"want to make it available on the Python Package Index, consult the "
-":ref:`distributing-index` guide."
+"want to make it available on the Python Package Index, consult the :ref:"
+"`distributing-index` guide."
 msgstr ""
diff --git a/tutorial/whatnow.po b/tutorial/whatnow.po
index 25fecaa6b6..9025d210ab 100644
--- a/tutorial/whatnow.po
+++ b/tutorial/whatnow.po
@@ -23,8 +23,8 @@ msgstr "¿Y ahora qué?"
 #: ../Doc/tutorial/whatnow.rst:7
 msgid ""
 "Reading this tutorial has probably reinforced your interest in using Python "
-"--- you should be eager to apply Python to solving your real-world problems."
-" Where should you go to learn more?"
+"--- you should be eager to apply Python to solving your real-world problems. "
+"Where should you go to learn more?"
 msgstr ""
 "Leer este tutorial probablemente reforzó tu interés por usar Python, "
 "deberías estar ansioso por aplicar Python a la resolución de tus problemas "
@@ -108,26 +108,26 @@ msgstr ""
 #: ../Doc/tutorial/whatnow.rst:54
 msgid ""
 "https://scipy.org: The Scientific Python project includes modules for fast "
-"array computations and manipulations plus a host of packages for such things"
-" as linear algebra, Fourier transforms, non-linear solvers, random number "
+"array computations and manipulations plus a host of packages for such things "
+"as linear algebra, Fourier transforms, non-linear solvers, random number "
 "distributions, statistical analysis and the like."
 msgstr ""
 
 #: ../Doc/tutorial/whatnow.rst:59
 msgid ""
 "For Python-related questions and problem reports, you can post to the "
-"newsgroup :newsgroup:`comp.lang.python`, or send them to the mailing list at"
-" python-list@python.org.  The newsgroup and mailing list are gatewayed, so "
+"newsgroup :newsgroup:`comp.lang.python`, or send them to the mailing list at "
+"python-list@python.org.  The newsgroup and mailing list are gatewayed, so "
 "messages posted to one will automatically be forwarded to the other.  There "
-"are hundreds of postings a day, asking (and answering) questions, suggesting"
-" new features, and announcing new modules. Mailing list archives are "
+"are hundreds of postings a day, asking (and answering) questions, suggesting "
+"new features, and announcing new modules. Mailing list archives are "
 "available at https://mail.python.org/pipermail/."
 msgstr ""
 "Para preguntas relacionadas con Python y reportes de problemas puedes "
 "escribir al grupo de noticias :newsgroup:`comp.lang.python`, o enviarlas a "
-"la lista de correo que hay en python-list@python.org. El grupo de noticias y"
-" la lista de correo están interconectadas, por lo que los mensajes enviados "
-"a uno serán retransmitidos al otro.  Hay alrededor de cientos de mensajes "
+"la lista de correo que hay en python-list@python.org. El grupo de noticias y "
+"la lista de correo están interconectadas, por lo que los mensajes enviados a "
+"uno serán retransmitidos al otro.  Hay alrededor de cientos de mensajes "
 "diarios (con picos de hasta varios cientos), haciendo (y respondiendo) "
 "preguntas, sugiriendo nuevas características, y anunciando nuevos módulos.  "
 "Antes de escribir, asegúrate de haber revisado la lista de `Preguntas "
@@ -139,6 +139,6 @@ msgstr ""
 msgid ""
 "Before posting, be sure to check the list of :ref:`Frequently Asked "
 "Questions <faq-index>` (also called the FAQ).  The FAQ answers many of the "
-"questions that come up again and again, and may already contain the solution"
-" for your problem."
+"questions that come up again and again, and may already contain the solution "
+"for your problem."
 msgstr ""