diff --git a/.travis.yml b/.travis.yml
index f2ab464307..54f95b8bfc 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -11,4 +11,4 @@ install:
script:
- powrap --check --quiet **/*.po
- pospell -p dict -l es_ES **/*.po
- - make CPYTHON_CLONE=/tmp/cpython/ COMMIT=796698adf
+ - make CPYTHON_CLONE=/tmp/cpython/ COMMIT=15e7d2432294ec46f1ad84ce958fdeb9d4ca78b1
diff --git a/README.rst b/README.rst
index 260dacc9e4..f838de53f6 100644
--- a/README.rst
+++ b/README.rst
@@ -37,8 +37,7 @@ How to Contribute
You can contribute using:
- Github
-- `transifex `_
-- Or just by opening `an issue on github `_
+- Or just by opening `an issue on github `_
Contributing using Github
@@ -56,7 +55,7 @@ Prerequisites:
Let's start:
You'll need to fork the `python-docs-es
-`_ clicking its ``Fork``
+`_ clicking its ``Fork``
button. This creates a copy of the whole project on your github
account: a place where you have the rights to do modifications.
@@ -64,14 +63,14 @@ Step by step:
.. code-block:: bash
- # Git clone your github fork using ssh (replace JulienPalard):
- git clone git@github.com:JulienPalard/python-docs-es.git
+ # Git clone your github fork using ssh (replace raulcd):
+ git clone git@github.com:raulcd/python-docs-es.git
# Go to the cloned directory:
cd python-docs-es/
# Add the upstream (the public repository) using HTTPS (won't ask for password):
- git remote add upstream https://github.com/python/python-docs-es.git
+ git remote add upstream https://github.com/raulcd/python-docs-es.git
All the translations must be made on the latest release.
We never translate on an oldest version, by example, the latest python release
@@ -106,7 +105,7 @@ Now you're ready to start a work session, each time you'll start a new task, sta
# The previous command will print you a link to open a PR on github.
# If you missed it, just go to
- # https://github.com/python/python-docs-es/ and a nice "Compare & pull request"
+ # https://github.com/raulcd/python-docs-es/ and a nice "Compare & pull request"
# button should appear after a few seconds telling you can ask for a pull request.
# Now someone is reviewing your modifications, and you'll want to fix their
diff --git a/dict b/dict
index 027f9cbbc9..3ae6a65baf 100644
--- a/dict
+++ b/dict
@@ -1,32 +1,60 @@
argv
+ASCII
backspace
batch
C
+comilla
command
+default
+docstring
+docstrings
+else
+if
import
+imprimible
indentación
+indentada
+inicializar
interactivamente
+intermezzo
+iterador
m
multilínea
+multi
option
Python
python
portable
+posicional
+posicionales
prompt
+prompts
readline
recompilar
ref
+referenciada
+referenciadas
+referenciado
+referenciados
reordenar
s
+seguirle
+self
script
scripting
scripts
+seguirle
+semánticamente
+sintácticamente
shell
+situ
sockets
+subíndices
sys
tipado
tty
+tupla
tutorial
Tutorial
X
-x
\ No newline at end of file
+x
diff --git a/tutorial/controlflow.po b/tutorial/controlflow.po
index 6f605a6a6d..22e5cbf6ab 100644
--- a/tutorial/controlflow.po
+++ b/tutorial/controlflow.po
@@ -3,38 +3,44 @@
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR , YEAR.
#
-#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2019-05-06 11:59-0400\n"
-"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
-"Last-Translator: FULL NAME \n"
-"Language-Team: LANGUAGE \n"
+"PO-Revision-Date: 2019-05-22 12:21+0200\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"Last-Translator: \n"
+"Language-Team: es\n"
+"Language: es_ES\n"
+"X-Generator: Poedit 2.2.1\n"
#: ../Doc/tutorial/controlflow.rst:5
msgid "More Control Flow Tools"
-msgstr ""
+msgstr "Más herramientas para control de flujo"
#: ../Doc/tutorial/controlflow.rst:7
msgid ""
"Besides the :keyword:`while` statement just introduced, Python knows the "
"usual control flow statements known from other languages, with some twists."
msgstr ""
+"Además de la sentencia :keyword:`while` que acabamos de introducir, Python "
+"soporta las sentencias de control de flujo que podemos encontrar en otros "
+"lenguajes, con algunos cambios."
#: ../Doc/tutorial/controlflow.rst:14
msgid ":keyword:`!if` Statements"
-msgstr ""
+msgstr "La sentencia :keyword:`!if`"
#: ../Doc/tutorial/controlflow.rst:16
msgid ""
"Perhaps the most well-known statement type is the :keyword:`if` statement. "
"For example::"
msgstr ""
+"Tal vez el tipo más conocido de sentencia sea el :keyword:`if`. Por ejemplo::"
#: ../Doc/tutorial/controlflow.rst:33
msgid ""
@@ -44,10 +50,15 @@ msgid ""
"keyword:`!elif` ... :keyword:`!elif` ... sequence is a substitute for the "
"``switch`` or ``case`` statements found in other languages."
msgstr ""
+"Puede haber cero o más bloques :keyword:`elif`, y el bloque :keyword:`else` "
+"es opcional. La palabra reservada ':keyword:`!elif`'es una abreviación de "
+"'else if', y es útil para evitar un sangrado excesivo. Una secuencia :"
+"keyword:`!if` ... :keyword:`!elif` ... :keyword:`!elif` ... sustituye las "
+"sentencias ``switch`` o ``case`` encontradas en otros lenguajes."
#: ../Doc/tutorial/controlflow.rst:43
msgid ":keyword:`!for` Statements"
-msgstr ""
+msgstr "La sentencia :keyword:`!for`"
#: ../Doc/tutorial/controlflow.rst:48
msgid ""
@@ -59,6 +70,13 @@ msgid ""
"a string), in the order that they appear in the sequence. For example (no "
"pun intended):"
msgstr ""
+"La sentencia :keyword:`for` en Python difiere un poco de lo que uno puede "
+"estar acostumbrado en lenguajes como C o Pascal. En lugar de siempre iterar "
+"sobre una progresión aritmética de números (como en Pascal) o darle al "
+"usuario la posibilidad de definir tanto el paso de la iteración como la "
+"condición de fin (como en C), la sentencia :keyword:`!for` de Python itera "
+"sobre los ítems de cualquier secuencia (una lista o una cadena de texto), en "
+"el orden que aparecen en la secuencia. Por ejemplo::"
#: ../Doc/tutorial/controlflow.rst:69
msgid ""
@@ -67,22 +85,31 @@ msgid ""
"first make a copy. Iterating over a sequence does not implicitly make a "
"copy. The slice notation makes this especially convenient::"
msgstr ""
+"Si necesitas modificar la secuencia sobre la que estás iterando mientras "
+"estás adentro del ciclo (por ejemplo para borrar algunos ítems), se "
+"recomienda que hagas primero una copia. Iterar sobre una secuencia no hace "
+"implícitamente una copia. La notación de rebanada es especialmente "
+"conveniente para esto::"
#: ../Doc/tutorial/controlflow.rst:81
msgid ""
"With ``for w in words:``, the example would attempt to create an infinite "
"list, inserting ``defenestrate`` over and over again."
msgstr ""
+"Con ``for w in words:``, el ejemplo intentaría crear una lista infinita, "
+"insertando ``defenestrate`` una y otra vez."
#: ../Doc/tutorial/controlflow.rst:88
msgid "The :func:`range` Function"
-msgstr ""
+msgstr "La función :func:`range`"
#: ../Doc/tutorial/controlflow.rst:90
msgid ""
"If you do need to iterate over a sequence of numbers, the built-in function :"
"func:`range` comes in handy. It generates arithmetic progressions::"
msgstr ""
+"Si se necesita iterar sobre una secuencia de números, es apropiado utilizar "
+"la función integrada :func:`range`, la cual genera progresiones aritméticas::"
#: ../Doc/tutorial/controlflow.rst:102
msgid ""
@@ -91,22 +118,31 @@ msgid ""
"10. It is possible to let the range start at another number, or to specify "
"a different increment (even negative; sometimes this is called the 'step')::"
msgstr ""
+"El valor final dado nunca es parte de la secuencia; ``range(10)`` genera 10 "
+"valores, los índices correspondientes para los ítems de una secuencia de "
+"longitud 10. Es posible hacer que el rango empiece con otro número, o "
+"especificar un incremento diferente (incluso negativo; algunas veces se lo "
+"llama 'paso')::"
#: ../Doc/tutorial/controlflow.rst:116
msgid ""
"To iterate over the indices of a sequence, you can combine :func:`range` "
"and :func:`len` as follows::"
msgstr ""
+"Para iterar sobre los índices de una secuencia, puedes combinar :func:"
+"`range` y :func:`len` así::"
#: ../Doc/tutorial/controlflow.rst:129
msgid ""
"In most such cases, however, it is convenient to use the :func:`enumerate` "
"function, see :ref:`tut-loopidioms`."
msgstr ""
+"En la mayoría de los casos, sin embargo, conviene usar la función :func:"
+"`enumerate`, mira :ref:`tut-loopidioms`."
#: ../Doc/tutorial/controlflow.rst:132
msgid "A strange thing happens if you just print a range::"
-msgstr ""
+msgstr "Algo extraño sucede si muestras un `\t`range``::"
#: ../Doc/tutorial/controlflow.rst:137
msgid ""
@@ -115,6 +151,10 @@ msgid ""
"items of the desired sequence when you iterate over it, but it doesn't "
"really make the list, thus saving space."
msgstr ""
+"De muchas maneras el objeto devuelto por :func:`range` se comporta como si "
+"fuera una lista, pero no lo es. Es un objeto que devuelve los ítems "
+"sucesivos de la secuencia deseada cuando iteras sobre él, pero realmente no "
+"construye la lista, ahorrando entonces espacio."
#: ../Doc/tutorial/controlflow.rst:142
msgid ""
@@ -124,24 +164,35 @@ msgid ""
"keyword:`for` statement is such an *iterator*. The function :func:`list` is "
"another; it creates lists from iterables::"
msgstr ""
+"Decimos que tal objeto es *iterable*; esto es, que se lo puede usar en "
+"funciones y construcciones que esperan algo de lo cual obtener ítems "
+"sucesivos hasta que se termine. Hemos visto que la declaración :keyword:"
+"`for` es un iterador en ese sentido. La función :func:`list` es otra; crea "
+"listas a partir de iterables::"
#: ../Doc/tutorial/controlflow.rst:152
msgid ""
"Later we will see more functions that return iterables and take iterables as "
"argument."
msgstr ""
+"Más tarde veremos más funciones que devuelven iterables y que toman "
+"iterables como entrada."
#: ../Doc/tutorial/controlflow.rst:158
msgid ""
":keyword:`!break` and :keyword:`!continue` Statements, and :keyword:`!else` "
"Clauses on Loops"
msgstr ""
+"Las sentencias :keyword:`break`, :keyword:`continue`, y :keyword:`else` en "
+"lazos"
#: ../Doc/tutorial/controlflow.rst:160
msgid ""
"The :keyword:`break` statement, like in C, breaks out of the innermost "
"enclosing :keyword:`for` or :keyword:`while` loop."
msgstr ""
+"La sentencia :keyword:`break`, como en C, termina el lazo :keyword:`for` o :"
+"keyword:`while` más anidado."
#: ../Doc/tutorial/controlflow.rst:163
msgid ""
@@ -151,12 +202,19 @@ msgid ""
"is terminated by a :keyword:`break` statement. This is exemplified by the "
"following loop, which searches for prime numbers::"
msgstr ""
+"Las sentencias de lazo pueden tener una cláusula`!else` que es ejecutada "
+"cuando el lazo termina, luego de agotar la lista (con :keyword:`for`) o "
+"cuando la condición se hace falsa (con :keyword:`while`), pero no cuando el "
+"lazo es terminado con la sentencia :keyword:`break`. Se ejemplifica en el "
+"siguiente lazo, que busca números primos::"
#: ../Doc/tutorial/controlflow.rst:187
msgid ""
"(Yes, this is the correct code. Look closely: the ``else`` clause belongs "
"to the :keyword:`for` loop, **not** the :keyword:`if` statement.)"
msgstr ""
+"(Sí, este es el código correcto. Fíjate bien: el ``else`` pertenece al "
+"ciclo :keyword:`for`, no al :keyword:`if`.)"
#: ../Doc/tutorial/controlflow.rst:190
msgid ""
@@ -167,26 +225,37 @@ msgid ""
"occurs. For more on the :keyword:`!try` statement and exceptions, see :ref:"
"`tut-handling`."
msgstr ""
+"Cuando se usa con un ciclo, el ``else`` tiene más en común con el ``else`` "
+"de una declaración :keyword:`try` que con el de un :keyword:`if`: el "
+"``else`` de un :keyword:`!try` se ejecuta cuando no se genera ninguna "
+"excepción, y el ``else`` de un ciclo se ejecuta cuando no hay ningún "
+"``break``. Para más sobre la declaración :keyword:`!try` y excepciones, "
+"mira :ref:`tut-handling`."
#: ../Doc/tutorial/controlflow.rst:197
msgid ""
"The :keyword:`continue` statement, also borrowed from C, continues with the "
"next iteration of the loop::"
msgstr ""
+"La declaración :keyword:`continue`, también tomada de C, continua con la "
+"siguiente iteración del ciclo::"
#: ../Doc/tutorial/controlflow.rst:217
msgid ":keyword:`!pass` Statements"
-msgstr ""
+msgstr "La sentencia :keyword:`pass`"
#: ../Doc/tutorial/controlflow.rst:219
msgid ""
"The :keyword:`pass` statement does nothing. It can be used when a statement "
"is required syntactically but the program requires no action. For example::"
msgstr ""
+"La sentencia :keyword:`pass` no hace nada. Se puede usar cuando una "
+"sentencia es requerida por la sintaxis pero el programa no requiere ninguna "
+"acción. Por ejemplo::"
#: ../Doc/tutorial/controlflow.rst:226
msgid "This is commonly used for creating minimal classes::"
-msgstr ""
+msgstr "Se usa normalmente para crear clases en su mínima expresión::"
#: ../Doc/tutorial/controlflow.rst:232
msgid ""
@@ -195,16 +264,22 @@ msgid ""
"to keep thinking at a more abstract level. The :keyword:`!pass` is silently "
"ignored::"
msgstr ""
+"Otro lugar donde se puede usar :keyword:`pass` es como una marca de lugar "
+"para una función o un cuerpo condicional cuando estás trabajando en código "
+"nuevo, lo cual te permite pensar a un nivel de abstracción mayor. El :"
+"keyword:`!pass` se ignora silenciosamente::"
#: ../Doc/tutorial/controlflow.rst:243
msgid "Defining Functions"
-msgstr ""
+msgstr "Definiendo funciones"
#: ../Doc/tutorial/controlflow.rst:245
msgid ""
"We can create a function that writes the Fibonacci series to an arbitrary "
"boundary::"
msgstr ""
+"Podemos crear una función que escriba la serie de Fibonacci hasta un límite "
+"determinado::"
#: ../Doc/tutorial/controlflow.rst:265
msgid ""
@@ -213,6 +288,10 @@ msgid ""
"parameters. The statements that form the body of the function start at the "
"next line, and must be indented."
msgstr ""
+"La palabra reservada :keyword:`def` se usa para definir funciones. Debe "
+"seguirle el nombre de la función y la lista de parámetros formales entre "
+"paréntesis. Las sentencias que forman el cuerpo de la función empiezan en la "
+"línea siguiente, y deben estar con sangría."
#: ../Doc/tutorial/controlflow.rst:270
msgid ""
@@ -224,6 +303,14 @@ msgid ""
"through code; it's good practice to include docstrings in code that you "
"write, so make a habit of it."
msgstr ""
+"La primera sentencia del cuerpo de la función puede ser opcionalmente una "
+"cadena de texto literal; esta es la cadena de texto de documentación de la "
+"función, o :dfn:`docstring`. (Podés encontrar más acerca de docstrings en la "
+"sección :ref:`tut-docstrings`.). Existen herramientas que usan las "
+"``docstrings`` para producir documentación imprimible o disponible en línea, "
+"o para dejar que los usuarios busquen interactivamente a través del código; "
+"es una buena práctica incluir ``docstrings`` en el código que escribes, y "
+"hacerlo un buen hábito."
#: ../Doc/tutorial/controlflow.rst:277
msgid ""
@@ -236,6 +323,15 @@ msgid ""
"assigned a value within a function (unless named in a :keyword:`global` "
"statement), although they may be referenced."
msgstr ""
+"La *ejecución* de una función introduce una nueva tabla de símbolos usada "
+"para las variables locales de la función. Más precisamente, todas las "
+"asignaciones de variables en la función almacenan el valor en la tabla de "
+"símbolos local; así mismo la referencia a variables primero mira la tabla de "
+"símbolos local, luego en la tabla de símbolos local de las funciones "
+"externas, luego la tabla de símbolos global, y finalmente la tabla de "
+"nombres predefinidos. Así, no se les puede asignar directamente un valor a "
+"las variables globales dentro de una función (a menos se las nombre en la "
+"sentencia :keyword:`global`), aunque si pueden ser referenciadas."
#: ../Doc/tutorial/controlflow.rst:286
msgid ""
@@ -245,6 +341,11 @@ msgid ""
"*reference*, not the value of the object). [#]_ When a function calls "
"another function, a new local symbol table is created for that call."
msgstr ""
+"Los parámetros reales (argumentos) de una función se introducen en la tabla "
+"de símbolos local de la función llamada cuando esta es ejecutada; así, los "
+"argumentos son pasados por valor (dónde el valor es siempre una referencia a "
+"un objeto, no el valor del objeto). [#]_ Cuando una función llama a otra "
+"función, una nueva tabla de símbolos local es creada para esa llamada."
#: ../Doc/tutorial/controlflow.rst:292
msgid ""
@@ -254,6 +355,11 @@ msgid ""
"another name which can then also be used as a function. This serves as a "
"general renaming mechanism::"
msgstr ""
+"La definición de una función introduce el nombre de la función en la tabla "
+"de símbolos actual. El valor del nombre de la función tiene un tipo que es "
+"reconocido por el interprete como una función definida por el usuario. Este "
+"valor puede ser asignado a otro nombre que luego puede ser usado como una "
+"función. Esto sirve como un mecanismo general para renombrar::"
#: ../Doc/tutorial/controlflow.rst:304
msgid ""
@@ -265,16 +371,27 @@ msgid ""
"the only value written. You can see it if you really want to using :func:"
"`print`::"
msgstr ""
+"Viniendo de otros lenguajes, puedes objetar que ``fib`` no es una función, "
+"sino un procedimiento, porque no devuelve un valor. De hecho, técnicamente "
+"hablando, los procedimientos sin :keyword:`return` sí retornan un valor, "
+"aunque uno aburrido. Este valor se llama ``None`` (es un nombre "
+"predefinido). El intérprete por lo general no escribe el valor ``None`` si "
+"va a ser el único valor escrito. Si realmente se quiere, se puede verlo "
+"usando la función :func:`print` ::"
#: ../Doc/tutorial/controlflow.rst:315
msgid ""
"It is simple to write a function that returns a list of the numbers of the "
"Fibonacci series, instead of printing it::"
msgstr ""
+"Es simple escribir una función que retorne una lista con los números de la "
+"serie de Fibonacci en lugar de imprimirlos::"
#: ../Doc/tutorial/controlflow.rst:331
msgid "This example, as usual, demonstrates some new Python features:"
msgstr ""
+"Este ejemplo, como es usual, demuestra algunas características más de "
+"Python::"
#: ../Doc/tutorial/controlflow.rst:333
msgid ""
@@ -282,6 +399,9 @@ msgid ""
"keyword:`!return` without an expression argument returns ``None``. Falling "
"off the end of a function also returns ``None``."
msgstr ""
+"La sentencia :keyword:`return` devuelve un valor en una función. :keyword:`!"
+"return` sin una expresión como argumento retorna ``None``. Si se alcanza el "
+"final de una función, también se retorna ``None``."
#: ../Doc/tutorial/controlflow.rst:337
msgid ""
@@ -296,20 +416,32 @@ msgid ""
"for list objects; it adds a new element at the end of the list. In this "
"example it is equivalent to ``result = result + [a]``, but more efficient."
msgstr ""
+"La sentencia ``result.append(a)`` llama a un método del objeto lista "
+"``result``. Un método es una función que 'pertenece' a un objeto y se nombra "
+"``obj.methodname``, dónde ``obj`` es algún objeto (puede ser una expresión), "
+"y ``methodname`` es el nombre del método que está definido por el tipo del "
+"objeto. Distintos tipos definen distintos métodos. Métodos de diferentes "
+"tipos pueden tener el mismo nombre sin causar ambigüedad. (Es posible "
+"definir tipos de objetos propios, y métodos, usando clases, mira :ref:`tut-"
+"classes`). El método :meth:`append` mostrado en el ejemplo está definido "
+"para objetos lista; añade un nuevo elemento al final de la lista. En este "
+"ejemplo es equivalente a ``result = result + [a]``, pero más eficiente."
#: ../Doc/tutorial/controlflow.rst:352
msgid "More on Defining Functions"
-msgstr ""
+msgstr "Más sobre definición de funciones"
#: ../Doc/tutorial/controlflow.rst:354
msgid ""
"It is also possible to define functions with a variable number of arguments. "
"There are three forms, which can be combined."
msgstr ""
+"También es posible definir funciones con un número variable de argumentos. "
+"Hay tres formas que pueden ser combinadas."
#: ../Doc/tutorial/controlflow.rst:361
msgid "Default Argument Values"
-msgstr ""
+msgstr "Argumentos con valores por omisión"
#: ../Doc/tutorial/controlflow.rst:363
msgid ""
@@ -317,43 +449,56 @@ msgid ""
"arguments. This creates a function that can be called with fewer arguments "
"than it is defined to allow. For example::"
msgstr ""
+"La forma más útil es especificar un valor por omisión para uno o más "
+"argumentos. Esto crea una función que puede ser llamada con menos argumentos "
+"que los que permite. Por ejemplo::"
#: ../Doc/tutorial/controlflow.rst:379
msgid "This function can be called in several ways:"
-msgstr ""
+msgstr "Esta función puede ser llamada de distintas maneras::"
#: ../Doc/tutorial/controlflow.rst:381
msgid ""
"giving only the mandatory argument: ``ask_ok('Do you really want to quit?')``"
msgstr ""
+"pasando sólo el argumento obligatorio: ``ask_ok('Do you really want to "
+"quit?')``"
#: ../Doc/tutorial/controlflow.rst:383
msgid ""
"giving one of the optional arguments: ``ask_ok('OK to overwrite the file?', "
"2)``"
msgstr ""
+"pasando uno de los argumentos opcionales: ``ask_ok('OK to overwrite the "
+"file?', 2)``"
#: ../Doc/tutorial/controlflow.rst:385
msgid ""
"or even giving all arguments: ``ask_ok('OK to overwrite the file?', 2, 'Come "
"on, only yes or no!')``"
msgstr ""
+"o pasando todos los argumentos: ``ask_ok('OK to overwrite the file?', 2, "
+"'Come on, only yes or no!')``"
#: ../Doc/tutorial/controlflow.rst:388
msgid ""
"This example also introduces the :keyword:`in` keyword. This tests whether "
"or not a sequence contains a certain value."
msgstr ""
+"Este ejemplo también introduce la palabra reservada :keyword:`in`, la cual "
+"prueba si una secuencia contiene o no un determinado valor."
#: ../Doc/tutorial/controlflow.rst:391
msgid ""
"The default values are evaluated at the point of function definition in the "
"*defining* scope, so that ::"
msgstr ""
+"Los valores por omisión son evaluados en el momento de la definición de la "
+"función, en el ámbito de la definición, entonces::"
#: ../Doc/tutorial/controlflow.rst:402
msgid "will print ``5``."
-msgstr ""
+msgstr "...imprimirá ```5``."
#: ../Doc/tutorial/controlflow.rst:404
msgid ""
@@ -362,20 +507,27 @@ msgid ""
"dictionary, or instances of most classes. For example, the following "
"function accumulates the arguments passed to it on subsequent calls::"
msgstr ""
+"**Advertencia importante:** El valor por omisión es evaluado solo una vez. "
+"Existe una diferencia cuando el valor por omisión es un objeto mutable como "
+"una lista, diccionario, o instancia de la mayoría de las clases. Por "
+"ejemplo, la siguiente función acumula los argumentos que se le pasan en "
+"subsiguientes llamadas::"
#: ../Doc/tutorial/controlflow.rst:417
msgid "This will print ::"
-msgstr ""
+msgstr "Imprimirá ::"
#: ../Doc/tutorial/controlflow.rst:423
msgid ""
"If you don't want the default to be shared between subsequent calls, you can "
"write the function like this instead::"
msgstr ""
+"Si no se quiere que el valor por omisión sea compartido entre subsiguientes "
+"llamadas, se pueden escribir la función así::"
#: ../Doc/tutorial/controlflow.rst:436
msgid "Keyword Arguments"
-msgstr ""
+msgstr "Palabras claves como argumentos"
#: ../Doc/tutorial/controlflow.rst:438
msgid ""
@@ -383,6 +535,9 @@ msgid ""
"argument>` of the form ``kwarg=value``. For instance, the following "
"function::"
msgstr ""
+"Las funciones también puede ser llamadas usando :term:`argumentos de "
+"palabras clave ` (o argumentos nombrados) de la forma "
+"``kwarg=value``. Por ejemplo, la siguiente función::"
#: ../Doc/tutorial/controlflow.rst:447
msgid ""
@@ -390,10 +545,13 @@ msgid ""
"(``state``, ``action``, and ``type``). This function can be called in any "
"of the following ways::"
msgstr ""
+"...acepta un argumento obligatorio (``voltage``)) y tres argumentos "
+"opcionales (``state``, ``action``, y ``type``). Esta función puede llamarse "
+"de cualquiera de las siguientes maneras::"
#: ../Doc/tutorial/controlflow.rst:458
msgid "but all the following calls would be invalid::"
-msgstr ""
+msgstr "...pero estas otras llamadas serían todas inválidas::"
#: ../Doc/tutorial/controlflow.rst:465
msgid ""
@@ -405,6 +563,14 @@ msgid ""
"may receive a value more than once. Here's an example that fails due to this "
"restriction::"
msgstr ""
+"En una llamada a una función, los argumentos nombrados deben seguir a los "
+"argumentos posicionales. Cada uno de los argumentos nombrados pasados deben "
+"coincidir con un argumento aceptado por la función (por ejemplo, ``actor`` "
+"no es un argumento válido para la función ``parrot``), y el orden de los "
+"mismos no es importante. Esto también se aplica a los argumentos "
+"obligatorios (por ejemplo, ``parrot(voltage=1000)`` también es válido). "
+"Ningún argumento puede recibir más de un valor al mismo tiempo. Aquí hay un "
+"ejemplo que falla debido a esta restricción::"
#: ../Doc/tutorial/controlflow.rst:481
msgid ""
@@ -416,24 +582,35 @@ msgid ""
"beyond the formal parameter list. (``*name`` must occur before ``**name``.) "
"For example, if we define a function like this::"
msgstr ""
+"Cuando un parámetro formal de la forma ``**nombre`` está presente al final, "
+"recibe un diccionario (ver :ref:`typesmapping`) conteniendo todos los "
+"argumentos nombrados excepto aquellos correspondientes a un parámetro "
+"formal. Esto puede ser combinado con un parámetro formal de la forma "
+"``*nombre`` (descrito en la siguiente sección) que recibe una tupla "
+"conteniendo los argumentos posicionales además de la lista de parámetros "
+"formales. (``*nombre`` debe ocurrir antes de ``**nombre``). Por ejemplo, si "
+"definimos una función así::"
#: ../Doc/tutorial/controlflow.rst:498
msgid "It could be called like this::"
-msgstr ""
+msgstr "Puede ser llamada así::"
#: ../Doc/tutorial/controlflow.rst:506
msgid "and of course it would print:"
-msgstr ""
+msgstr "...y por supuesto imprimirá::"
#: ../Doc/tutorial/controlflow.rst:519
msgid ""
"Note that the order in which the keyword arguments are printed is guaranteed "
"to match the order in which they were provided in the function call."
msgstr ""
+"Se debe notar que el orden en el cual los argumentos nombrados son impresos "
+"está garantizado para coincidir con el orden en el cual fueron provistos en "
+"la llamada a la función."
#: ../Doc/tutorial/controlflow.rst:526
msgid "Arbitrary Argument Lists"
-msgstr ""
+msgstr "Listas de argumentos arbitrarios"
#: ../Doc/tutorial/controlflow.rst:531
msgid ""
@@ -442,6 +619,11 @@ msgid ""
"wrapped up in a tuple (see :ref:`tut-tuples`). Before the variable number "
"of arguments, zero or more normal arguments may occur. ::"
msgstr ""
+"Finalmente, la opción menos frecuentemente usada es especificar que una "
+"función puede ser llamada con un número arbitrario de argumentos. Estos "
+"argumentos serán organizados en una tupla (mira :ref:`tut-tuples`). Antes "
+"del número variable de argumentos, cero o más argumentos normales pueden "
+"estar presentes.::"
#: ../Doc/tutorial/controlflow.rst:540
msgid ""
@@ -451,10 +633,15 @@ msgid ""
"``*args`` parameter are 'keyword-only' arguments, meaning that they can only "
"be used as keywords rather than positional arguments. ::"
msgstr ""
+"Normalmente estos argumentos de cantidad variables son los últimos en la "
+"lista de parámetros formales, porque toman todo el remanente de argumentos "
+"que se pasan a la función. Cualquier parámetro que suceda luego del "
+"``*args`` será 'sólo nombrado', o sea que sólo se pueden usar como "
+"argumentos nombrados y no como posicionales.::"
#: ../Doc/tutorial/controlflow.rst:557
msgid "Unpacking Argument Lists"
-msgstr ""
+msgstr "Desempaquetando una lista de argumentos"
#: ../Doc/tutorial/controlflow.rst:559
msgid ""
@@ -465,16 +652,25 @@ msgid ""
"separately, write the function call with the ``*`` operator to unpack the "
"arguments out of a list or tuple::"
msgstr ""
+"La situación inversa ocurre cuando los argumentos ya están en una lista o "
+"tupla pero necesitan ser desempaquetados para llamar a una función que "
+"requiere argumentos posicionales separados. Por ejemplo, la función "
+"predefinida :func:`range` espera los argumentos inicio y fin. Si no están "
+"disponibles en forma separada, se puede escribir la llamada a la función con "
+"el operador ``*`` para desempaquetar argumentos desde una lista o una "
+"tupla ::"
#: ../Doc/tutorial/controlflow.rst:575
msgid ""
"In the same fashion, dictionaries can deliver keyword arguments with the "
"``**`` operator::"
msgstr ""
+"Del mismo modo, los diccionarios pueden entregar argumentos nombrados con el "
+"operador ``**``::"
#: ../Doc/tutorial/controlflow.rst:591
msgid "Lambda Expressions"
-msgstr ""
+msgstr "Expresiones lambda"
#: ../Doc/tutorial/controlflow.rst:593
msgid ""
@@ -486,22 +682,34 @@ msgid ""
"definitions, lambda functions can reference variables from the containing "
"scope::"
msgstr ""
+"Pequeñas funciones anónimas pueden ser creadas con la palabra reservada :"
+"keyword:`lambda`. Esta función retorna la suma de sus dos argumentos: "
+"``lambda a, b: a+b`` Las funciones Lambda pueden ser usadas en cualquier "
+"lugar donde sea requerido un objeto de tipo función. Están sintácticamente "
+"restringidas a una sola expresión. Semánticamente, son solo azúcar "
+"sintáctica para definiciones normales de funciones. Al igual que las "
+"funciones anidadas, las funciones lambda pueden hacer referencia a variables "
+"desde el ámbito que la contiene::"
#: ../Doc/tutorial/controlflow.rst:610
msgid ""
"The above example uses a lambda expression to return a function. Another "
"use is to pass a small function as an argument::"
msgstr ""
+"El ejemplo anterior muestra el uso de una expresión lambda para retornar una "
+"función. Otro uso es para pasar pequeñas funciones como argumentos ::"
#: ../Doc/tutorial/controlflow.rst:622
msgid "Documentation Strings"
-msgstr ""
+msgstr "Cadenas de texto de documentación"
#: ../Doc/tutorial/controlflow.rst:629
msgid ""
"Here are some conventions about the content and formatting of documentation "
"strings."
msgstr ""
+"Acá hay algunas convenciones sobre el contenido y formato de las cadenas de "
+"texto de documentación."
#: ../Doc/tutorial/controlflow.rst:632
msgid ""
@@ -511,6 +719,11 @@ msgid ""
"to be a verb describing a function's operation). This line should begin "
"with a capital letter and end with a period."
msgstr ""
+"La primera línea debe ser siempre un resumen corto y conciso del propósito "
+"del objeto. Para ser breve, no se debe mencionar explícitamente el nombre o "
+"tipo del objeto, ya que estos están disponibles de otros modos (excepto si "
+"el nombre es un verbo que describe el funcionamiento de la función). Esta "
+"línea debe empezar con una letra mayúscula y terminar con un punto."
#: ../Doc/tutorial/controlflow.rst:638
msgid ""
@@ -519,6 +732,10 @@ msgid ""
"The following lines should be one or more paragraphs describing the object's "
"calling conventions, its side effects, etc."
msgstr ""
+"Si hay más líneas en la cadena de texto de documentación, la segunda línea "
+"debe estar en blanco, separando visualmente el resumen del resto de la "
+"descripción. Las líneas siguientes deben ser uno o más párrafos describiendo "
+"las convenciones para llamar al objeto, efectos secundarios, etc."
#: ../Doc/tutorial/controlflow.rst:643
msgid ""
@@ -534,14 +751,27 @@ msgid ""
"all their leading whitespace should be stripped. Equivalence of whitespace "
"should be tested after expansion of tabs (to 8 spaces, normally)."
msgstr ""
+"El analizador de Python no quita el sangrado de las cadenas de texto "
+"literales multi-líneas, entonces las herramientas que procesan documentación "
+"tienen que quitarlo si así lo desean. Esto se hace mediante la siguiente "
+"convención. La primera línea que no está en blanco *siguiente* a la primer "
+"línea de la cadena determina la cantidad de sangría para toda la cadena de "
+"documentación. (No podemos usar la primer línea ya que generalmente es "
+"adyacente a las comillas de apertura de la cadena y el sangrado no se nota "
+"en la cadena de texto). Los espacios en blanco \"equivalentes\" a este "
+"sangrado son luego quitados del comienzo de cada línea en la cadena. No "
+"deberían haber líneas con una sangría menor, pero si las hay todos los "
+"espacios en blanco del comienzo deben ser quitados. La equivalencia de "
+"espacios en blanco debe ser verificada luego de la expansión de tabuladores "
+"(a 8 espacios, normalmente)."
#: ../Doc/tutorial/controlflow.rst:655
msgid "Here is an example of a multi-line docstring::"
-msgstr ""
+msgstr "Este es un ejemplo de un ``docstring`` multi-línea::"
#: ../Doc/tutorial/controlflow.rst:673
msgid "Function Annotations"
-msgstr ""
+msgstr "Anotación de funciones"
#: ../Doc/tutorial/controlflow.rst:681
msgid ""
@@ -549,6 +779,9 @@ msgid ""
"information about the types used by user-defined functions (see :pep:`3107` "
"and :pep:`484` for more information)."
msgstr ""
+"Las :ref:`anotaciones de funciones ` son información completamente "
+"opcional sobre los tipos usadas en funciones definidas por el usuario (ver "
+"PEP 484 para más información)."
#: ../Doc/tutorial/controlflow.rst:685
msgid ""
@@ -561,10 +794,19 @@ msgid ""
"denoting the end of the :keyword:`def` statement. The following example has "
"a positional argument, a keyword argument, and the return value annotated::"
msgstr ""
+"Las :term:`anotaciones ` se almacenan en el atributo :"
+"attr:`__annotations__` de la función como un diccionario y no tienen efecto "
+"en ninguna otra parte de la función. Las anotaciones de los parámetros se "
+"definen luego de dos puntos después del nombre del parámetro, seguido de una "
+"expresión que evalúa al valor de la anotación. Las anotaciones de retorno "
+"son definidas por el literal ->, seguidas de una expresión, entre la lista "
+"de parámetros y los dos puntos que marcan el final de la declaración :"
+"keyword:`def`. El siguiente ejemplo tiene un argumento posicional, uno "
+"nombrado, y el valor de retorno anotado::"
#: ../Doc/tutorial/controlflow.rst:707
msgid "Intermezzo: Coding Style"
-msgstr ""
+msgstr "Intermezzo: Estilo de codificación"
#: ../Doc/tutorial/controlflow.rst:712
msgid ""
@@ -574,6 +816,12 @@ msgid ""
"others. Making it easy for others to read your code is always a good idea, "
"and adopting a nice coding style helps tremendously for that."
msgstr ""
+"Ahora que estás a punto de escribir piezas de Python más largas y complejas, "
+"es un buen momento para hablar sobre *estilo de codificación*. La mayoría de "
+"los lenguajes pueden ser escritos (o mejor dicho, *formateados*) con "
+"diferentes estilos; algunos son mas fáciles de leer que otros. Hacer que tu "
+"código sea más fácil de leer por otros es siempre una buena idea, y adoptar "
+"un buen estilo de codificación ayuda tremendamente a lograrlo."
#: ../Doc/tutorial/controlflow.rst:718
msgid ""
@@ -582,10 +830,14 @@ msgid ""
"Python developer should read it at some point; here are the most important "
"points extracted for you:"
msgstr ""
+"Para Python, :pep:`8` se erigió como la guía de estilo a la que más "
+"proyectos adhirieron; promueve un estilo de codificación fácil de leer y "
+"visualmente agradable. Todos los desarrolladores Python deben leerlo en "
+"algún momento; aquí están extraídos los puntos más importantes::"
#: ../Doc/tutorial/controlflow.rst:723
msgid "Use 4-space indentation, and no tabs."
-msgstr ""
+msgstr "Usar sangrías de 4 espacios, no tabuladores."
#: ../Doc/tutorial/controlflow.rst:725
msgid ""
@@ -593,36 +845,45 @@ msgid ""
"nesting depth) and large indentation (easier to read). Tabs introduce "
"confusion, and are best left out."
msgstr ""
+"4 espacios son un buen compromiso entre una sangría pequeña (permite mayor "
+"nivel de sangrado)y una sangría grande (más fácil de leer). Los tabuladores "
+"introducen confusión y es mejor dejarlos de lado."
#: ../Doc/tutorial/controlflow.rst:729
msgid "Wrap lines so that they don't exceed 79 characters."
-msgstr ""
+msgstr "Recortar las líneas para que no superen los 79 caracteres."
#: ../Doc/tutorial/controlflow.rst:731
msgid ""
"This helps users with small displays and makes it possible to have several "
"code files side-by-side on larger displays."
msgstr ""
+"Esto ayuda a los usuarios con pantallas pequeñas y hace posible tener varios "
+"archivos de código abiertos, uno al lado del otro, en pantallas grandes."
#: ../Doc/tutorial/controlflow.rst:734
msgid ""
"Use blank lines to separate functions and classes, and larger blocks of code "
"inside functions."
msgstr ""
+"Usar líneas en blanco para separar funciones y clases, y bloques grandes de "
+"código dentro de funciones."
#: ../Doc/tutorial/controlflow.rst:737
msgid "When possible, put comments on a line of their own."
-msgstr ""
+msgstr "Cuando sea posible, poner comentarios en una sola línea."
#: ../Doc/tutorial/controlflow.rst:739
msgid "Use docstrings."
-msgstr ""
+msgstr "Usar ``docstrings``."
#: ../Doc/tutorial/controlflow.rst:741
msgid ""
"Use spaces around operators and after commas, but not directly inside "
"bracketing constructs: ``a = f(1, 2) + g(3, 4)``."
msgstr ""
+"Usar espacios alrededor de operadores y luego de las comas, pero no "
+"directamente dentro de paréntesis: ``a = f(1, 2) + g(3, 4)``."
#: ../Doc/tutorial/controlflow.rst:744
msgid ""
@@ -631,6 +892,11 @@ msgid ""
"and methods. Always use ``self`` as the name for the first method argument "
"(see :ref:`tut-firstclasses` for more on classes and methods)."
msgstr ""
+"Nombrar las clases y funciones consistentemente; la convención es usar "
+"``NotacionCamello`` para clases y ``minusculas_con_guiones_bajos`` para "
+"funciones y métodos. Siempre usa self como el nombre para el primer "
+"argumento en los métodos (mira :ref:`tut-firstclasses` para más información "
+"sobre clases y métodos)."
#: ../Doc/tutorial/controlflow.rst:749
msgid ""
@@ -638,6 +904,9 @@ msgid ""
"environments. Python's default, UTF-8, or even plain ASCII work best in any "
"case."
msgstr ""
+"No uses codificaciones estrafalarias si esperas usar el código en entornos "
+"internacionales. El default de Python, UTF-8, o incluso ASCII plano "
+"funcionan bien en la mayoría de los casos."
#: ../Doc/tutorial/controlflow.rst:753
msgid ""
@@ -645,10 +914,13 @@ msgid ""
"slightest chance people speaking a different language will read or maintain "
"the code."
msgstr ""
+"De la misma manera, no uses caracteres no-ASCII en los identificadores si "
+"hay incluso una pequeñísima chance de que gente que hable otro idioma tenga "
+"que leer o mantener el código."
#: ../Doc/tutorial/controlflow.rst:759
msgid "Footnotes"
-msgstr ""
+msgstr "Notas al pie"
#: ../Doc/tutorial/controlflow.rst:760
msgid ""
@@ -656,3 +928,7 @@ msgid ""
"a mutable object is passed, the caller will see any changes the callee makes "
"to it (items inserted into a list)."
msgstr ""
+"En realidad, *llamadas por referencia de objeto* sería una mejor "
+"descripción, ya que si se pasa un objeto mutable, quien realiza la llamada "
+"verá cualquier cambio que se realice sobre el mismo (por ejemplo ítems "
+"insertados en una lista)."
diff --git a/tutorial/datastructures.po b/tutorial/datastructures.po
index fe398c98bb..d1c84a632c 100644
--- a/tutorial/datastructures.po
+++ b/tutorial/datastructures.po
@@ -3,49 +3,57 @@
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR , YEAR.
#
-#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2019-05-06 11:59-0400\n"
-"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
-"Last-Translator: FULL NAME \n"
-"Language-Team: LANGUAGE \n"
+"PO-Revision-Date: 2019-05-09 16:26-0400\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"Last-Translator: \n"
+"Language-Team: es\n"
+"Language: es_ES\n"
+"X-Generator: Poedit 2.2.1\n"
#: ../Doc/tutorial/datastructures.rst:5
msgid "Data Structures"
-msgstr ""
+msgstr "Estructuras de datos"
#: ../Doc/tutorial/datastructures.rst:7
msgid ""
"This chapter describes some things you've learned about already in more "
"detail, and adds some new things as well."
msgstr ""
+"Este capítulo describe algunas cosas que ya has aprendido en más detalle y "
+"agrega algunas cosas nuevas también."
#: ../Doc/tutorial/datastructures.rst:13
msgid "More on Lists"
-msgstr ""
+msgstr "Más sobre listas"
#: ../Doc/tutorial/datastructures.rst:15
msgid ""
"The list data type has some more methods. Here are all of the methods of "
"list objects:"
msgstr ""
+"El tipo de dato lista tiene algunos métodos más. Aquí están todos los "
+"métodos de los objetos lista:"
#: ../Doc/tutorial/datastructures.rst:22
msgid ""
"Add an item to the end of the list. Equivalent to ``a[len(a):] = [x]``."
-msgstr ""
+msgstr "Agrega un ítem al final de la lista. Equivale a ``a[len(a):] = [x]``."
#: ../Doc/tutorial/datastructures.rst:28
msgid ""
"Extend the list by appending all the items from the iterable. Equivalent to "
"``a[len(a):] = iterable``."
msgstr ""
+"Extiende la lista agregándole todos los ítems del iterable. Equivale a "
+"``a[len(a):] = iterable``."
#: ../Doc/tutorial/datastructures.rst:35
msgid ""
@@ -53,12 +61,18 @@ msgid ""
"element before which to insert, so ``a.insert(0, x)`` inserts at the front "
"of the list, and ``a.insert(len(a), x)`` is equivalent to ``a.append(x)``."
msgstr ""
+"Inserta un ítem en una posición dada. El primer argumento es el índice del "
+"ítem delante del cual se insertará, por lo tanto ``a.insert(0, x)`` inserta "
+"al principio de la lista y ``a.insert(len(a), x)`` equivale a ``a."
+"append(x)``."
#: ../Doc/tutorial/datastructures.rst:43
msgid ""
"Remove the first item from the list whose value is equal to *x*. It raises "
"a :exc:`ValueError` if there is no such item."
msgstr ""
+"Quita el primer ítem de la lista cuyo valor sea *x*. Lanza un :exc:"
+"`ValueError` si no existe tal ítem."
#: ../Doc/tutorial/datastructures.rst:50
msgid ""
@@ -69,16 +83,24 @@ msgid ""
"that position. You will see this notation frequently in the Python Library "
"Reference.)"
msgstr ""
+"Quita el ítem en la posición dada de la lista y lo devuelve. Si no se "
+"especifica un índice, ``a.pop()`` quita y devuelve el último elemento de la "
+"lista. (Los corchetes que encierran a *i* en la firma del método denotan que "
+"el parámetro es opcional, no que deberías escribir corchetes en esa "
+"posición. Verás esta notación con frecuencia en la Referencia de la "
+"Biblioteca de Python.)"
#: ../Doc/tutorial/datastructures.rst:60
msgid "Remove all items from the list. Equivalent to ``del a[:]``."
-msgstr ""
+msgstr "Elimina todos los elementos de la lista. Equivalente a ``del a[:]``."
#: ../Doc/tutorial/datastructures.rst:66
msgid ""
"Return zero-based index in the list of the first item whose value is equal "
"to *x*. Raises a :exc:`ValueError` if there is no such item."
msgstr ""
+"Devuelve el índice basado en cero del primer elemento cuyo valor sea igual a "
+"*x*. Lanza una excepción :exc:`ValueError` si no existe tal elemento."
#: ../Doc/tutorial/datastructures.rst:69
msgid ""
@@ -87,28 +109,35 @@ msgid ""
"list. The returned index is computed relative to the beginning of the full "
"sequence rather than the *start* argument."
msgstr ""
+"Los argumentos opcionales *start* y *end* son interpretados como la notación "
+"de rebanadas y se usan para limitar la búsqueda a un segmento particular de "
+"la lista. El índice devuelto se calcula de manera relativa al inicio de la "
+"secuencia completa en lugar de con respecto al argumento *start*."
#: ../Doc/tutorial/datastructures.rst:78
msgid "Return the number of times *x* appears in the list."
-msgstr ""
+msgstr "Devuelve el número de veces que *x* aparece en la lista."
#: ../Doc/tutorial/datastructures.rst:84
msgid ""
"Sort the items of the list in place (the arguments can be used for sort "
"customization, see :func:`sorted` for their explanation)."
msgstr ""
+"Ordena los elementos de la lista in situ (los argumentos pueden ser usados "
+"para personalizar el orden de la lista, ver :func:`sorted` para su "
+"explicación)."
#: ../Doc/tutorial/datastructures.rst:91
msgid "Reverse the elements of the list in place."
-msgstr ""
+msgstr "Invierte los elementos de la lista in situ."
#: ../Doc/tutorial/datastructures.rst:97
msgid "Return a shallow copy of the list. Equivalent to ``a[:]``."
-msgstr ""
+msgstr "Devuelve una copia superficial de la lista. Equivalente a ``a[:]``."
#: ../Doc/tutorial/datastructures.rst:100
msgid "An example that uses most of the list methods::"
-msgstr ""
+msgstr "Un ejemplo que usa la mayoría de los métodos de la lista::"
#: ../Doc/tutorial/datastructures.rst:123
msgid ""
@@ -117,10 +146,14 @@ msgid ""
"default ``None``. [1]_ This is a design principle for all mutable data "
"structures in Python."
msgstr ""
+"Quizás hayas notado que métodos como `insert``, ``remove`` o ``sort`` que "
+"únicamente modifican la lista no tienen impreso un valor de retorno -- "
+"devuelven el valor por defecto ``None``. [1]_ Esto es un principio de diseño "
+"para todas las estructuras de datos mutables en Python."
#: ../Doc/tutorial/datastructures.rst:132
msgid "Using Lists as Stacks"
-msgstr ""
+msgstr "Usando listas como pilas"
#: ../Doc/tutorial/datastructures.rst:137
msgid ""
@@ -130,10 +163,15 @@ msgid ""
"item from the top of the stack, use :meth:`pop` without an explicit index. "
"For example::"
msgstr ""
+"Los métodos de lista hacen que resulte muy fácil usar una lista como una "
+"pila, donde el último elemento añadido es el primer elemento retirado "
+"(\"último en entrar, primero en salir\"). Para agregar un elemento a la cima "
+"de la pila, utiliza :meth:`append`. Para retirar un elemento de la cima de "
+"la pila, utiliza :meth:`pop` sin un índice explícito. Por ejemplo:"
#: ../Doc/tutorial/datastructures.rst:162
msgid "Using Lists as Queues"
-msgstr ""
+msgstr "Usando listas como colas"
#: ../Doc/tutorial/datastructures.rst:166
msgid ""
@@ -143,16 +181,24 @@ msgid ""
"are fast, doing inserts or pops from the beginning of a list is slow "
"(because all of the other elements have to be shifted by one)."
msgstr ""
+"También es posible usar una lista como una cola, donde el primer elemento "
+"añadido es el primer elemento retirado (\"primero en entrar, primero en salir"
+"\"); sin embargo, las listas no son eficientes para este propósito. Agregar "
+"y sacar del final de la lista es rápido, pero insertar o sacar del comienzo "
+"de una lista es lento (porque todos los otros elementos tienen que ser "
+"desplazados por uno)."
#: ../Doc/tutorial/datastructures.rst:172
msgid ""
"To implement a queue, use :class:`collections.deque` which was designed to "
"have fast appends and pops from both ends. For example::"
msgstr ""
+"Para implementar una cola, utiliza :class:`collections.deque` el cual fue "
+"diseñado para añadir y quitar de ambas puntas de forma rápida. Por ejemplo::"
#: ../Doc/tutorial/datastructures.rst:190
msgid "List Comprehensions"
-msgstr ""
+msgstr "Comprensión de listas"
#: ../Doc/tutorial/datastructures.rst:192
msgid ""
@@ -161,6 +207,11 @@ msgid ""
"operations applied to each member of another sequence or iterable, or to "
"create a subsequence of those elements that satisfy a certain condition."
msgstr ""
+"Las comprensiones de listas ofrecen una manera concisa de crear listas. Sus "
+"usos comunes son para hacer nuevas listas donde cada elemento es el "
+"resultado de algunas operaciones aplicadas a cada miembro de otra secuencia "
+"o iterable, o para crear un segmento de la secuencia de esos elementos para "
+"satisfacer una condición determinada."
#: ../Doc/tutorial/datastructures.rst:197
msgid "For example, assume we want to create a list of squares, like::"
diff --git a/tutorial/interpreter.po b/tutorial/interpreter.po
index 0e7b1b51c5..072c013439 100644
--- a/tutorial/interpreter.po
+++ b/tutorial/interpreter.po
@@ -8,7 +8,7 @@ msgstr ""
"Project-Id-Version: Python 3.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2019-05-06 11:59-0400\n"
-"PO-Revision-Date: 2019-05-07 15:06-0400\n"
+"PO-Revision-Date: 2019-05-09 12:05-0400\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
@@ -34,7 +34,7 @@ msgid ""
"typing the command:"
msgstr ""
"Por lo general, el intérprete de Python se instala en :file:`/usr/local/bin/"
-"python3.6` en las máquinas dónde está disponible; poner :file:`/usr/local/"
+"python3.7` en las máquinas dónde está disponible; poner :file:`/usr/local/"
"bin` en el camino de búsqueda de tu intérprete de comandos Unix hace posible "
"iniciarlo ingresando la orden:"
@@ -256,7 +256,8 @@ msgstr ""
#: ../Doc/tutorial/interpreter.rst:146
msgid "where *encoding* is one of the valid :mod:`codecs` supported by Python."
-msgstr "donde *encoding* es uno de los :mod:`codecs` soportados por Python."
+msgstr ""
+"donde *codificación* es uno de los :mod:`codecs` soportados por Python."
#: ../Doc/tutorial/interpreter.rst:148
msgid ""
diff --git a/tutorial/introduction.po b/tutorial/introduction.po
index 03f06181c4..819fe2f21b 100644
--- a/tutorial/introduction.po
+++ b/tutorial/introduction.po
@@ -3,22 +3,24 @@
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR , YEAR.
#
-#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2019-05-06 11:59-0400\n"
-"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
-"Last-Translator: FULL NAME \n"
-"Language-Team: LANGUAGE \n"
+"PO-Revision-Date: 2019-05-09 15:10-0400\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"Last-Translator: \n"
+"Language-Team: es\n"
+"Language: es_ES\n"
+"X-Generator: Poedit 2.2.1\n"
#: ../Doc/tutorial/introduction.rst:5
msgid "An Informal Introduction to Python"
-msgstr ""
+msgstr "Una introducción informal a Python"
#: ../Doc/tutorial/introduction.rst:7
msgid ""
@@ -29,6 +31,13 @@ msgid ""
"that a secondary prompt on a line by itself in an example means you must "
"type a blank line; this is used to end a multi-line command."
msgstr ""
+"En los siguientes ejemplos, la entrada y la salida se distinguen por la "
+"presencia o ausencia de prompts (:term:`>>>` y :term:`...`): para repetir el "
+"ejemplo, escribe todo después del prompt, cuando aparece; las líneas que no "
+"comienzan con un prompt son emitidas desde el intérprete. Ten en cuenta que "
+"un prompt secundario solo en una linea de ejemplo significa que debes "
+"escribir una línea en blanco. Esto se utiliza para finalizar un comando "
+"multilínea."
#: ../Doc/tutorial/introduction.rst:16
msgid ""
@@ -40,24 +49,34 @@ msgid ""
"Since comments are to clarify code and are not interpreted by Python, they "
"may be omitted when typing in examples."
msgstr ""
+"Muchos de los ejemplos de este manual, incluso aquellos ingresados en el "
+"prompt interactivo, incluyen comentarios. Los comentarios en Python "
+"comienzan con el carácter numeral, ``#``, y se extienden hasta el final "
+"visible de la línea. Un comentario quizás aparezca al comienzo de la línea o "
+"seguido de espacios en blanco o código, pero no dentro de una cadena de "
+"caracteres. Un carácter numeral dentro de una cadena de caracteres es sólo "
+"un carácter numeral. Ya que los comentarios son para aclarar código y no son "
+"interpretados por Python, pueden omitirse cuando se escriben los ejemplos."
#: ../Doc/tutorial/introduction.rst:24
msgid "Some examples::"
-msgstr ""
+msgstr "Algunos ejemplos::"
#: ../Doc/tutorial/introduction.rst:35
msgid "Using Python as a Calculator"
-msgstr ""
+msgstr "Usando Python como una calculadora"
#: ../Doc/tutorial/introduction.rst:37
msgid ""
"Let's try some simple Python commands. Start the interpreter and wait for "
"the primary prompt, ``>>>``. (It shouldn't take long.)"
msgstr ""
+"Probemos algunos comandos simples de Python. Inicia el intérprete y espere "
+"el prompt primario, ``>>>``. (No debería tardar mucho.)"
#: ../Doc/tutorial/introduction.rst:44
msgid "Numbers"
-msgstr ""
+msgstr "Números"
#: ../Doc/tutorial/introduction.rst:46
msgid ""
@@ -67,6 +86,11 @@ msgid ""
"languages (for example, Pascal or C); parentheses (``()``) can be used for "
"grouping. For example::"
msgstr ""
+"El intérprete puede utilizarse como una simple calculadora; puedes "
+"introducir una expresión y este escribirá los valores. La sintaxis es "
+"sencilla: los operadores ``+``, ``-``, ``*`` y ``/``funcionan como en la "
+"mayoría de los lenguajes (por ejemplo, Pascal o C); los paréntesis (``()``) "
+"pueden ser usados para agrupar. Por ejemplo::"
#: ../Doc/tutorial/introduction.rst:61
msgid ""
@@ -74,6 +98,10 @@ msgid ""
"ones with a fractional part (e.g. ``5.0``, ``1.6``) have type :class:"
"`float`. We will see more about numeric types later in the tutorial."
msgstr ""
+"Los números enteros (ej. ``2``, ``4``, ``20``) tienen tipo :class:`int`, los "
+"que tienen una parte fraccionaria (por ejemplo ``5.0``, ``1.6``) tiene el "
+"tipo :class:`float`. Vamos a ver más acerca de los tipos numéricos más "
+"adelante en el tutorial."
#: ../Doc/tutorial/introduction.rst:65
msgid ""
@@ -81,30 +109,41 @@ msgid ""
"get an integer result (discarding any fractional result) you can use the ``//"
"`` operator; to calculate the remainder you can use ``%``::"
msgstr ""
+"La división (``/``) siempre devuelve un punto flotante. Para hacer :term:"
+"`floor division` y obtener un resultado entero (descartando cualquier "
+"resultado fraccionario) puede usarse el operador ``//``; para calcular el "
+"resto puedes usar ``%``::"
#: ../Doc/tutorial/introduction.rst:79
msgid ""
"With Python, it is possible to use the ``**`` operator to calculate powers "
"[#]_::"
msgstr ""
+"Con Python, es posible usar el operador ``**`` para calcular potencias [#]_::"
#: ../Doc/tutorial/introduction.rst:86
msgid ""
"The equal sign (``=``) is used to assign a value to a variable. Afterwards, "
"no result is displayed before the next interactive prompt::"
msgstr ""
+"El signo igual (``=``) se usa para asignar un valor a una variable. Ningún "
+"resultado se mostrará antes del siguiente prompt interactivo::"
#: ../Doc/tutorial/introduction.rst:94
msgid ""
"If a variable is not \"defined\" (assigned a value), trying to use it will "
"give you an error::"
msgstr ""
+"Si una variable no está \"definida\" (no se le ha asignado un valor), al "
+"intentar usarla dará un error::"
#: ../Doc/tutorial/introduction.rst:102
msgid ""
"There is full support for floating point; operators with mixed type operands "
"convert the integer operand to floating point::"
msgstr ""
+"Hay soporte completo de punto flotante; operadores con operando mezclados "
+"convertirán los enteros a punto flotante::"
#: ../Doc/tutorial/introduction.rst:108
msgid ""
@@ -112,6 +151,9 @@ msgid ""
"``_``. This means that when you are using Python as a desk calculator, it "
"is somewhat easier to continue calculations, for example::"
msgstr ""
+"En el modo interactivo, la última expresión impresa se asigna a la variable "
+"``_``. Esto significa que cuando se está utilizando Python como "
+"calculadora, es más fácil seguir calculando, por ejemplo::"
#: ../Doc/tutorial/introduction.rst:121
msgid ""
@@ -119,6 +161,9 @@ msgid ""
"assign a value to it --- you would create an independent local variable with "
"the same name masking the built-in variable with its magic behavior."
msgstr ""
+"Esta variable debe ser tratada como de sólo lectura por el usuario. No le "
+"asignes explícitamente un valor; crearás una variable local independiente "
+"con el mismo nombre enmascarando la variable con el comportamiento mágico."
#: ../Doc/tutorial/introduction.rst:125
msgid ""
@@ -128,10 +173,15 @@ msgid ""
"`, and uses the ``j`` or ``J`` suffix to indicate the "
"imaginary part (e.g. ``3+5j``)."
msgstr ""
+"Además de :class:`int` y :class:`float`, Python admite otros tipos de "
+"números, como :class:`~decimal.Decimal` y :class:`~fractions.Fraction`. "
+"Python también tiene soporte incorporado para :ref:`complex numbers "
+"`, y usa el sufijo ``j`` o ``J`` para indicar la parte "
+"imaginaria (por ejemplo, ``3+5j``)."
#: ../Doc/tutorial/introduction.rst:135
msgid "Strings"
-msgstr ""
+msgstr "Cadenas de caracteres"
#: ../Doc/tutorial/introduction.rst:137
msgid ""
@@ -140,6 +190,10 @@ msgid ""
"double quotes (``\"...\"``) with the same result [#]_. ``\\`` can be used "
"to escape quotes::"
msgstr ""
+"Además de números, Python puede manipular cadenas de texto, las cuales "
+"pueden ser expresadas de distintas formas. Pueden estar encerradas en "
+"comillas simples (``'...'``) o dobles (``\"...\"``) con el mismo resultado "
+"[#]_. ``\\`` puede ser usado para escapar comillas::"
#: ../Doc/tutorial/introduction.rst:155
msgid ""
@@ -152,6 +206,14 @@ msgid ""
"readable output, by omitting the enclosing quotes and by printing escaped "
"and special characters::"
msgstr ""
+"En el intérprete interactivo, la salida de caracteres está encerrada en "
+"comillas y los caracteres especiales se escapan con barras invertidas. "
+"Aunque esto a veces se vea diferente de la entrada (las comillas que "
+"encierran pueden cambiar), las dos cadenas son equivalentes. La cadena se "
+"encierra en comillas dobles si la cadena contiene una comilla simple y "
+"ninguna doble, de lo contrario es encerrada en comillas simples. La función :"
+"func:`print` produce una salida más legible, omitiendo las comillas que la "
+"encierran e imprimiendo caracteres especiales y escapados::"
#: ../Doc/tutorial/introduction.rst:175
msgid ""
@@ -159,6 +221,9 @@ msgid ""
"characters, you can use *raw strings* by adding an ``r`` before the first "
"quote::"
msgstr ""
+"Si no quieres que los caracteres precedidos por ``\\`` se interpreten como "
+"caracteres especiales, puedes usar *cadenas sin formato* agregando una ``r`` "
+"antes de la primera comilla::"
#: ../Doc/tutorial/introduction.rst:185
msgid ""
@@ -167,39 +232,53 @@ msgid ""
"in the string, but it's possible to prevent this by adding a ``\\`` at the "
"end of the line. The following example::"
msgstr ""
+"Las cadenas de texto literales pueden contener múltiples líneas. Una forma "
+"es usar triples comillas: ``\"\"\"...\"\"\"`` o ``'''...'''``. Los fin de "
+"línea son incluidos automáticamente, pero es posible prevenir esto agregando "
+"una ``\\`` al final de la línea. Por ejemplo:"
#: ../Doc/tutorial/introduction.rst:196
msgid ""
"produces the following output (note that the initial newline is not "
"included):"
msgstr ""
+"produce la siguiente salida (tened en cuenta que la línea inicial no está "
+"incluida):"
#: ../Doc/tutorial/introduction.rst:204
msgid ""
"Strings can be concatenated (glued together) with the ``+`` operator, and "
"repeated with ``*``::"
msgstr ""
+"Las cadenas se pueden concatenar (pegar juntas) con el operador ``+`` y se "
+"pueden repetir con ``*``::"
#: ../Doc/tutorial/introduction.rst:211
msgid ""
"Two or more *string literals* (i.e. the ones enclosed between quotes) next "
"to each other are automatically concatenated. ::"
msgstr ""
+"Dos o más *cadenas literales* (es decir, las encerradas entre comillas) una "
+"al lado de la otra se concatenan automáticamente. ::"
#: ../Doc/tutorial/introduction.rst:217
msgid ""
"This feature is particularly useful when you want to break long strings::"
msgstr ""
+"Esta característica es particularmente útil cuando quieres dividir cadenas "
+"largas::"
#: ../Doc/tutorial/introduction.rst:224
msgid ""
"This only works with two literals though, not with variables or expressions::"
msgstr ""
+"Esto solo funciona con dos literales, no con variables ni expresiones::"
#: ../Doc/tutorial/introduction.rst:238
msgid ""
"If you want to concatenate variables or a variable and a literal, use ``+``::"
msgstr ""
+"Si quieres concatenar variables o una variable y un literal, usa ``+``::"
#: ../Doc/tutorial/introduction.rst:243
msgid ""
@@ -207,15 +286,21 @@ msgid ""
"index 0. There is no separate character type; a character is simply a string "
"of size one::"
msgstr ""
+"Las cadenas de texto se pueden *indexar* (subíndices), el primer carácter de "
+"la cadena tiene el índice 0. No hay un tipo de dato diferente para los "
+"caracteres; un carácter es simplemente una cadena de longitud uno::"
#: ../Doc/tutorial/introduction.rst:253
msgid ""
"Indices may also be negative numbers, to start counting from the right::"
msgstr ""
+"Los índices quizás sean números negativos, para empezar a contar desde la "
+"derecha::"
#: ../Doc/tutorial/introduction.rst:262
msgid "Note that since -0 is the same as 0, negative indices start from -1."
msgstr ""
+"Nota que -0 es lo mismo que 0, los índice negativos comienzan desde -1."
#: ../Doc/tutorial/introduction.rst:264
msgid ""
@@ -223,18 +308,26 @@ msgid ""
"used to obtain individual characters, *slicing* allows you to obtain "
"substring::"
msgstr ""
+"Además de los índices, las *rebanadas* también están soportadas. Mientras "
+"que los índices se utilizar para obtener caracteres individuales, las "
+"*rebanadas* te permiten obtener partes de las cadenas de texto::"
#: ../Doc/tutorial/introduction.rst:272
msgid ""
"Note how the start is always included, and the end always excluded. This "
"makes sure that ``s[:i] + s[i:]`` is always equal to ``s``::"
msgstr ""
+"Nota cómo el inicio siempre se incluye y el final siempre se excluye. Esto "
+"asegura que ``s[:i] + s[i:]`` siempre sea igual a ``s``::"
#: ../Doc/tutorial/introduction.rst:280
msgid ""
"Slice indices have useful defaults; an omitted first index defaults to zero, "
"an omitted second index defaults to the size of the string being sliced. ::"
msgstr ""
+"Los índices de las rebanadas tienen valores por defecto útiles; el valor por "
+"defecto para el primer índice es cero, el valor por defecto para el segundo "
+"índice es la longitud de la cadena a rebanar. ::"
#: ../Doc/tutorial/introduction.rst:290
msgid ""
@@ -243,6 +336,10 @@ msgid ""
"Then the right edge of the last character of a string of *n* characters has "
"index *n*, for example::"
msgstr ""
+"Una forma de recordar cómo funcionan las rebanadas es pensar que los índices "
+"apuntan *entre* caracteres, con el borde izquierdo del primer carácter "
+"numerado 0. Luego, el punto derecho del último carácter de una cadena de *n* "
+"caracteres tiene un índice *n*, por ejemplo ::"
#: ../Doc/tutorial/introduction.rst:301
msgid ""
@@ -251,6 +348,10 @@ msgid ""
"from *i* to *j* consists of all characters between the edges labeled *i* and "
"*j*, respectively."
msgstr ""
+"La primera fila de números da la posición de los índices 0...6 en la cadena; "
+"La segunda fila da los correspondientes indices negativos. La rebanada desde "
+"*i* hasta *j* consta de todos los caracteres entre los bordes etiquetados "
+"*i* y *j*, respectivamente."
#: ../Doc/tutorial/introduction.rst:306
msgid ""
@@ -258,80 +359,96 @@ msgid ""
"indices, if both are within bounds. For example, the length of "
"``word[1:3]`` is 2."
msgstr ""
+"Para índices no negativos, la longitud de la rebanada es la diferencia de "
+"los índices, si ambos están dentro de los límites. Por ejemplo, la longitud "
+"de ``word[1:3]`` es 2."
#: ../Doc/tutorial/introduction.rst:310
msgid "Attempting to use an index that is too large will result in an error::"
-msgstr ""
+msgstr "Intentar usar un índice que es muy grande resultará en un error::"
#: ../Doc/tutorial/introduction.rst:317
msgid ""
"However, out of range slice indexes are handled gracefully when used for "
"slicing::"
msgstr ""
+"Sin embargo, los índices de rebanadas fuera de rango se manejan "
+"satisfactoriamente cuando se usan para rebanar::"
#: ../Doc/tutorial/introduction.rst:325
msgid ""
"Python strings cannot be changed --- they are :term:`immutable`. Therefore, "
"assigning to an indexed position in the string results in an error::"
msgstr ""
+"Las cadenas de Python no se pueden modificar, son :term:`immutable`. Por "
+"eso, asignar a una posición indexada de la cadena resulta en un error:"
#: ../Doc/tutorial/introduction.rst:337
msgid "If you need a different string, you should create a new one::"
-msgstr ""
+msgstr "Si necesitas una cadena diferente, deberías crear una nueva::"
#: ../Doc/tutorial/introduction.rst:344
msgid "The built-in function :func:`len` returns the length of a string::"
msgstr ""
+"La función incorporada :func:`len` devuelve la longitud de una cadena::"
#: ../Doc/tutorial/introduction.rst:355
msgid ":ref:`textseq`"
-msgstr ""
+msgstr ":ref:`textseq`"
#: ../Doc/tutorial/introduction.rst:354
msgid ""
"Strings are examples of *sequence types*, and support the common operations "
"supported by such types."
msgstr ""
+"Las cadenas de texto son ejemplos de *tipos secuencias* y soportan las "
+"operaciones comunes para esos tipos."
#: ../Doc/tutorial/introduction.rst:359
msgid ":ref:`string-methods`"
-msgstr ""
+msgstr ":ref:`string-methods`"
#: ../Doc/tutorial/introduction.rst:358
msgid ""
"Strings support a large number of methods for basic transformations and "
"searching."
msgstr ""
+"Las cadenas de texto soportan una gran cantidad de métodos para "
+"transformaciones básicas y búsqueda."
#: ../Doc/tutorial/introduction.rst:362
msgid ":ref:`f-strings`"
-msgstr ""
+msgstr ":ref:`f-strings`"
#: ../Doc/tutorial/introduction.rst:362
msgid "String literals that have embedded expressions."
-msgstr ""
+msgstr "Literales de cadena que tienen expresiones embebidas."
#: ../Doc/tutorial/introduction.rst:365
msgid ":ref:`formatstrings`"
-msgstr ""
+msgstr ":ref:`formatstrings`"
#: ../Doc/tutorial/introduction.rst:365
msgid "Information about string formatting with :meth:`str.format`."
msgstr ""
+"Aquí se da información sobre formateo de cadenas de texto con :meth:`str."
+"format`."
#: ../Doc/tutorial/introduction.rst:368
msgid ":ref:`old-string-formatting`"
-msgstr ""
+msgstr ":ref:`old-string-formatting`"
#: ../Doc/tutorial/introduction.rst:368
msgid ""
"The old formatting operations invoked when strings are the left operand of "
"the ``%`` operator are described in more detail here."
msgstr ""
+"Aquí se describen con más detalle las antiguas operaciones para formateo "
+"utilizadas cuando una cadena de texto está a la izquierda del operador ``%``."
#: ../Doc/tutorial/introduction.rst:375
msgid "Lists"
-msgstr ""
+msgstr "Listas"
#: ../Doc/tutorial/introduction.rst:377
msgid ""
@@ -340,12 +457,19 @@ msgid ""
"comma-separated values (items) between square brackets. Lists might contain "
"items of different types, but usually the items all have the same type. ::"
msgstr ""
+"Python tiene varios tipos de datos *compuestos*, utilizados para agrupar "
+"otros valores. El más versátil es la *lista*, la cual puede ser escrita como "
+"una lista de valores separados por coma (ítems) entre corchetes. Las listas "
+"pueden contener ítems de diferentes tipos, pero usualmente los ítems son del "
+"mismo tipo. ::"
#: ../Doc/tutorial/introduction.rst:386
msgid ""
"Like strings (and all other built-in :term:`sequence` types), lists can be "
"indexed and sliced::"
msgstr ""
+"Al igual que las cadenas (y todas las demás tipos integrados :term:"
+"`sequence`), las listas se pueden indexar y segmentar:"
#: ../Doc/tutorial/introduction.rst:396
msgid ""
@@ -353,42 +477,53 @@ msgid ""
"This means that the following slice returns a new (shallow) copy of the "
"list::"
msgstr ""
+"Todas las operaciones de rebanado devuelven una nueva lista que contiene los "
+"elementos pedidos. Esto significa que la siguiente rebanada devuelve una "
+"copia nueva (superficial) de la lista::"
#: ../Doc/tutorial/introduction.rst:402
msgid "Lists also support operations like concatenation::"
-msgstr ""
+msgstr "Las listas también admiten operaciones como concatenación::"
#: ../Doc/tutorial/introduction.rst:407
msgid ""
"Unlike strings, which are :term:`immutable`, lists are a :term:`mutable` "
"type, i.e. it is possible to change their content::"
msgstr ""
+"A diferencia de las cadenas, que son :term:`immutable`, las listas son de "
+"tipo :term:`mutable`, es decir, es posible cambiar su contenido::"
#: ../Doc/tutorial/introduction.rst:417
msgid ""
"You can also add new items at the end of the list, by using the :meth:`~list."
"append` *method* (we will see more about methods later)::"
msgstr ""
+"También puede agregar nuevos elementos al final de la lista, utilizando el "
+"*método* :meth:`~list.append` (vamos a ver más sobre los métodos luego)::"
#: ../Doc/tutorial/introduction.rst:425
msgid ""
"Assignment to slices is also possible, and this can even change the size of "
"the list or clear it entirely::"
msgstr ""
+"También es posible asignar a una rebanada, y esto incluso puede cambiar la "
+"longitud de la lista o vaciarla totalmente::"
#: ../Doc/tutorial/introduction.rst:444
msgid "The built-in function :func:`len` also applies to lists::"
-msgstr ""
+msgstr "La función predefinida :func:`len` también sirve para las listas ::"
#: ../Doc/tutorial/introduction.rst:450
msgid ""
"It is possible to nest lists (create lists containing other lists), for "
"example::"
msgstr ""
+"Es posible anidar listas (crear listas que contengan otras listas), por "
+"ejemplo::"
#: ../Doc/tutorial/introduction.rst:466
msgid "First Steps Towards Programming"
-msgstr ""
+msgstr "Primeros pasos hacia la programación"
#: ../Doc/tutorial/introduction.rst:468
msgid ""
@@ -397,10 +532,13 @@ msgid ""
"`Fibonacci series `_ as "
"follows::"
msgstr ""
+"Por supuesto, podemos usar Python para tareas más complicadas que sumar dos "
+"y dos. Por ejemplo, podemos escribir una parte inicial de la serie de "
+"Fibonacci `_ así::"
#: ../Doc/tutorial/introduction.rst:488
msgid "This example introduces several new features."
-msgstr ""
+msgstr "Este ejemplo introduce varias características nuevas."
#: ../Doc/tutorial/introduction.rst:490
msgid ""
@@ -410,6 +548,11 @@ msgid ""
"all evaluated first before any of the assignments take place. The right-"
"hand side expressions are evaluated from the left to the right."
msgstr ""
+"La primera línea contiene una *asignación múltiple*: las variables ``a`` y "
+"``b`` obtienen simultáneamente los nuevos valores 0 y 1. En la última línea "
+"esto se usa nuevamente, demostrando que las expresiones de la derecha son "
+"evaluadas primero antes de que se realice cualquiera de las asignaciones. "
+"Las expresiones del lado derecho se evalúan de izquierda a derecha."
#: ../Doc/tutorial/introduction.rst:496
msgid ""
@@ -422,6 +565,15 @@ msgid ""
"than), ``>`` (greater than), ``==`` (equal to), ``<=`` (less than or equal "
"to), ``>=`` (greater than or equal to) and ``!=`` (not equal to)."
msgstr ""
+"El bucle :keyword:`while` se ejecuta mientras la condición (aquí: ``a < "
+"10``) sea verdadera. En Python, como en C, cualquier valor entero que no sea "
+"cero es verdadero; cero es falso. La condición también puede ser una cadena "
+"de texto o una lista, de hecho, cualquier secuencia; cualquier cosa con una "
+"longitud distinta de cero es verdadera, las secuencias vacías son falsas. La "
+"prueba utilizada en el ejemplo es una comparación simple. Los operadores de "
+"comparación estándar se escriben igual que en C: ``<`` (menor que), ``>`` "
+"(mayor que), ``==`` (igual a), ``<=`` (menor que o igual a), ``>=`` (mayor "
+"que o igual a) y ``!=`` (distinto a)."
#: ../Doc/tutorial/introduction.rst:505
msgid ""
@@ -434,6 +586,16 @@ msgid ""
"(since the parser cannot guess when you have typed the last line). Note "
"that each line within a basic block must be indented by the same amount."
msgstr ""
+"El cuerpo del bucle está *indentado*: la indentación es la forma que usa "
+"Python para agrupar declaraciones. En el intérprete interactivo debes "
+"teclear un tabulador o espacio(s) para cada línea indentada. En la práctica "
+"vas a preparar entradas más complicadas para Python con un editor de texto; "
+"todos los editores de texto modernos tienen la facilidad de agregar la "
+"indentación automáticamente. Cuando se ingresa una instrucción compuesta de "
+"forma interactiva, se debe finalizar con una línea en blanco para indicar "
+"que está completa (ya que el analizador no puede adivinar cuando tecleaste "
+"la última línea). Nota que cada línea de un bloque básico debe estar "
+"sangrada de la misma forma."
#: ../Doc/tutorial/introduction.rst:514
msgid ""
@@ -444,16 +606,24 @@ msgid ""
"without quotes, and a space is inserted between items, so you can format "
"things nicely, like this::"
msgstr ""
+"La función :func:`print` escribe el valor de los argumentos que se le dan. "
+"Difiere de simplemente escribir la expresión que se quiere mostrar (como "
+"hicimos antes en los ejemplos de la calculadora) en la forma en que maneja "
+"múltiples argumentos, cantidades de punto flotante y cadenas. Las cadenas de "
+"texto son impresas sin comillas y un espacio en blanco se inserta entre los "
+"elementos, así puedes formatear cosas de una forma agradable::"
#: ../Doc/tutorial/introduction.rst:525
msgid ""
"The keyword argument *end* can be used to avoid the newline after the "
"output, or end the output with a different string::"
msgstr ""
+"El parámetro nombrado *end* puede usarse para evitar el salto de linea al "
+"final de la salida, o terminar la salida con una cadena diferente:"
#: ../Doc/tutorial/introduction.rst:537
msgid "Footnotes"
-msgstr ""
+msgstr "Notas al pie"
#: ../Doc/tutorial/introduction.rst:538
msgid ""
@@ -461,6 +631,9 @@ msgid ""
"as ``-(3**2)`` and thus result in ``-9``. To avoid this and get ``9``, you "
"can use ``(-3)**2``."
msgstr ""
+"Debido a que ``**`` tiene una prioridad mayor que ```-``, ``-3**2`` se "
+"interpretará como ``-(3**2)``, por lo tanto dará como resultado ``-9``. Para "
+"evitar esto y obtener ``9``, puedes usar ``(-3)**2``."
#: ../Doc/tutorial/introduction.rst:542
msgid ""
@@ -469,3 +642,8 @@ msgid ""
"only difference between the two is that within single quotes you don't need "
"to escape ``\"`` (but you have to escape ``\\'``) and vice versa."
msgstr ""
+"A diferencia de otros lenguajes, caracteres especiales como ``\\n`` tienen "
+"el mismo significado con simple(``'...'``) y dobles (``\"...\"``) comillas. "
+"La única diferencia entre las dos es que dentro de las comillas simples no "
+"existe la necesidad de escapar ``\"`` (pero tienes que escapar ``\\'``) y "
+"viceversa."
diff --git a/tutorial/modules.po b/tutorial/modules.po
index 9e8d5d02bc..f7363020b3 100644
--- a/tutorial/modules.po
+++ b/tutorial/modules.po
@@ -3,22 +3,24 @@
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR , YEAR.
#
-#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2019-05-06 11:59-0400\n"
-"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
-"Last-Translator: FULL NAME \n"
-"Language-Team: LANGUAGE \n"
+"PO-Revision-Date: 2019-05-22 14:21+0200\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"Last-Translator: \n"
+"Language-Team: es\n"
+"Language: es\n"
+"X-Generator: Poedit 2.2.1\n"
#: ../Doc/tutorial/modules.rst:5
msgid "Modules"
-msgstr ""
+msgstr "Módulos"
#: ../Doc/tutorial/modules.rst:7
msgid ""
@@ -31,6 +33,14 @@ msgid ""
"You may also want to use a handy function that you've written in several "
"programs without copying its definition into each program."
msgstr ""
+"Si sales del intérprete de Python y vuelves a entrar, las definiciones que "
+"habías hecho (funciones y variables) se pierden. Por lo tanto, si quieres "
+"escribir un programa más o menos largo, es mejor que utilices un editor de "
+"texto para preparar la entrada para el intérprete y ejecutarlo con ese "
+"archivo como entrada. Esto se conoce como crear un *script*. Si tu programa "
+"crece, quizás quieras separarlo en varios archivos para un mantenimiento más "
+"sencillo. Quizás también quieras usar una función útil que has escrito en "
+"distintos programas sin copiar su definición en cada programa."
#: ../Doc/tutorial/modules.rst:16
msgid ""
@@ -40,6 +50,12 @@ msgid ""
"modules or into the *main* module (the collection of variables that you have "
"access to in a script executed at the top level and in calculator mode)."
msgstr ""
+"Para soportar esto, Python tiene una manera de poner definiciones en un "
+"archivo y usarlos en un script o en una instancia del intérprete. Este tipo "
+"de ficheros se llama *módulo*; las definiciones de un módulo pueden ser "
+"*importadas* a otros módulos o al módulo *principal* (la colección de "
+"variables a las que tienes acceso en un script ejecutado en el nivel "
+"superior y en el modo calculadora)."
#: ../Doc/tutorial/modules.rst:22
msgid ""
@@ -50,12 +66,20 @@ msgid ""
"to create a file called :file:`fibo.py` in the current directory with the "
"following contents::"
msgstr ""
+"Un módulo es un fichero conteniendo definiciones y declaraciones de Python. "
+"El nombre de archivo es el nombre del módulo con el sufijo :file:`.py` "
+"agregado. Dentro de un módulo, el nombre del mismo módulo (como cadena) está "
+"disponible en el valor de la variable global ``__name__``. Por ejemplo, "
+"utiliza tu editor de texto favorito para crear un archivo llamado :file:"
+"`fibo.py` en el directorio actual, con el siguiente contenido:::"
#: ../Doc/tutorial/modules.rst:45
msgid ""
"Now enter the Python interpreter and import this module with the following "
"command::"
msgstr ""
+"Ahora entra en el intérprete de Python y importa este modulo con el "
+"siguiente comando::"
#: ../Doc/tutorial/modules.rst:50
msgid ""
@@ -63,15 +87,20 @@ msgid ""
"in the current symbol table; it only enters the module name ``fibo`` there. "
"Using the module name you can access the functions::"
msgstr ""
+"Esto no añade los nombres de las funciones definidas en ``fibo`` "
+"directamente en el espacio de nombres actual; sólo añade el nombre del "
+"módulo ``fibo``. Usando el nombre del módulo puedes acceder a las funciones::"
#: ../Doc/tutorial/modules.rst:61
msgid ""
"If you intend to use a function often you can assign it to a local name::"
msgstr ""
+"Si pretendes utilizar las funciones frecuentemente puedes asignarlas a un "
+"nombre local::"
#: ../Doc/tutorial/modules.rst:71
msgid "More on Modules"
-msgstr ""
+msgstr "Más sobre los módulos"
#: ../Doc/tutorial/modules.rst:73
msgid ""
@@ -80,6 +109,11 @@ msgid ""
"only the *first* time the module name is encountered in an import statement. "
"[#]_ (They are also run if the file is executed as a script.)"
msgstr ""
+"Un módulo puede contener tanto declaraciones ejecutables como definiciones "
+"de funciones. Estas declaraciones están pensadas para inicializar el módulo. "
+"Se ejecutan únicamente la *primera* vez que el módulo se encuentra en una "
+"declaración import. [#]_ (También se ejecutan si el archivo se ejecuta como "
+"script.)"
#: ../Doc/tutorial/modules.rst:78
msgid ""
@@ -90,6 +124,13 @@ msgid ""
"know what you are doing you can touch a module's global variables with the "
"same notation used to refer to its functions, ``modname.itemname``."
msgstr ""
+"Cada módulo tiene su propio espacio de nombres, el cual es usado como "
+"espacio de nombres global para todas las funciones definidas en el módulo. "
+"Por lo tanto, el autor de un módulo puede usar variables globales en el "
+"módulo sin preocuparse acerca de conflictos con una variable global del "
+"usuario. Por otro lado, si sabes lo que estás haciendo puedes acceder a las "
+"variables globales de un módulo con la misma notación usada para referirte a "
+"sus funciones, ``nombremodulo.nombreitem``."
#: ../Doc/tutorial/modules.rst:85
msgid ""
@@ -98,6 +139,10 @@ msgid ""
"for that matter). The imported module names are placed in the importing "
"module's global symbol table."
msgstr ""
+"Los módulos pueden importar otros módulos. Es costumbre pero no obligatorio "
+"ubicar todas las declaraciones :keyword:`import` al principio del módulo (o "
+"script, para el caso). Los nombres de los módulos importados se ubican en el "
+"espacio de nombres global del módulo que hace la importación."
#: ../Doc/tutorial/modules.rst:90
msgid ""
@@ -105,16 +150,24 @@ msgid ""
"from a module directly into the importing module's symbol table. For "
"example::"
msgstr ""
+"Hay una variante de la declaración :keyword:`import` que importa nos nombres "
+"de un módulo directamente al espacio de nombres del módulo que hace la "
+"importación. Por ejemplo::"
#: ../Doc/tutorial/modules.rst:97
msgid ""
"This does not introduce the module name from which the imports are taken in "
"the local symbol table (so in the example, ``fibo`` is not defined)."
msgstr ""
+"Esto no introduce en el espacio de nombres local el nombre del módulo desde "
+"el cual se está importando (por lo tanto, en el ejemplo, ``fibo`` no esta "
+"definido)."
#: ../Doc/tutorial/modules.rst:100
msgid "There is even a variant to import all names that a module defines::"
msgstr ""
+"Hay incluso una variante para importar todos los nombres que un módulo "
+"define::"
#: ../Doc/tutorial/modules.rst:106
msgid ""
@@ -123,6 +176,10 @@ msgid ""
"an unknown set of names into the interpreter, possibly hiding some things "
"you have already defined."
msgstr ""
+"Esto importa todos los nombres excepto los que inician con un guion bajo "
+"(``_``). La mayoría de las veces los programadores de Python no usan esto ya "
+"que introduce en el intérprete un conjunto de nombres desconocido, "
+"posiblemente escondiendo algunas de las definiciones previas."
#: ../Doc/tutorial/modules.rst:111
msgid ""
@@ -130,23 +187,33 @@ msgid ""
"package is frowned upon, since it often causes poorly readable code. "
"However, it is okay to use it to save typing in interactive sessions."
msgstr ""
+"Nota que en general la práctica de importar ``*`` de un módulo o paquete "
+"está muy mal vista, ya que frecuentemente genera código poco legible. Sin "
+"embargo, está bien usarlo para ahorrar tecleo en sesiones interactivas."
#: ../Doc/tutorial/modules.rst:115
msgid ""
"If the module name is followed by :keyword:`!as`, then the name following :"
"keyword:`!as` is bound directly to the imported module."
msgstr ""
+"Si el nombre del módulo es seguido por :keyword:`!as`, el nombre siguiendo :"
+"keyword:`!as` queda ligado directamente al módulo importado."
#: ../Doc/tutorial/modules.rst:124
msgid ""
"This is effectively importing the module in the same way that ``import "
"fibo`` will do, with the only difference of it being available as ``fib``."
msgstr ""
+"Esto es básicamente importar el módulo de la misma forma que se haría con "
+"``import fibo``, con la única diferencia en que se encuentra accesible como "
+"``fib``."
#: ../Doc/tutorial/modules.rst:127
msgid ""
"It can also be used when utilising :keyword:`from` with similar effects::"
msgstr ""
+"También se puede utilizar cuando se utiliza :keyword:`from` con efectos "
+"similares::"
#: ../Doc/tutorial/modules.rst:136
msgid ""