From 5a00a2472e6a84067104d31a66164c0359e7f6fa Mon Sep 17 00:00:00 2001 From: "Carlos A. Crespo" Date: Tue, 28 Nov 2023 12:03:45 -0300 Subject: [PATCH 1/2] translate tutorial/controlflow.po --- tutorial/controlflow.po | 889 ++++++++++++++++++++-------------------- 1 file changed, 437 insertions(+), 452 deletions(-) diff --git a/tutorial/controlflow.po b/tutorial/controlflow.po index 4b391f7c65..26aa44eb0d 100644 --- a/tutorial/controlflow.po +++ b/tutorial/controlflow.po @@ -11,29 +11,28 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-10-12 19:43+0200\n" -"PO-Revision-Date: 2022-11-19 23:09-0300\n" +"PO-Revision-Date: 2023-11-28 12:03-0300\n" "Last-Translator: Carlos A. Crespo \n" -"Language: es\n" "Language-Team: python-doc-es\n" -"Plural-Forms: nplurals=2; plural=(n != 1);\n" +"Language: es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" "Generated-By: Babel 2.13.0\n" +"X-Generator: Poedit 3.0.1\n" #: ../Doc/tutorial/controlflow.rst:5 msgid "More Control Flow Tools" msgstr "Más herramientas para control de flujo" #: ../Doc/tutorial/controlflow.rst:7 -#, fuzzy msgid "" "As well as the :keyword:`while` statement just introduced, Python uses a few " "more that we will encounter in this chapter." 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." +"utiliza algunas más que encontraremos en este capítulo." #: ../Doc/tutorial/controlflow.rst:14 msgid ":keyword:`!if` Statements" @@ -48,17 +47,17 @@ msgstr "" #: ../Doc/tutorial/controlflow.rst:33 msgid "" -"There can be zero or more :keyword:`elif` parts, and the :keyword:`else` " -"part is optional. The keyword ':keyword:`!elif`' is short for 'else if', " -"and is useful to avoid excessive indentation. An :keyword:`!if` ... :" -"keyword:`!elif` ... :keyword:`!elif` ... sequence is a substitute for the " -"``switch`` or ``case`` statements found in other languages." +"There can be zero or more :keyword:`elif` parts, and the :keyword:`else` part " +"is optional. The keyword ':keyword:`!elif`' is short for 'else if', and is " +"useful to avoid excessive indentation. An :keyword:`!if` ... :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." +"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:39 msgid "" @@ -67,8 +66,8 @@ msgid "" "statement useful. For more details see :ref:`tut-match`." msgstr "" "Si necesitas comparar un mismo valor con muchas constantes, o comprobar que " -"tenga un tipo o atributos específicos puede que encuentres útil la " -"sentencia :keyword:`!match`. Para más detalles véase :ref:`tut-match`." +"tenga un tipo o atributos específicos puede que encuentres útil la sentencia :" +"keyword:`!match`. Para más detalles véase :ref:`tut-match`." #: ../Doc/tutorial/controlflow.rst:46 msgid ":keyword:`!for` Statements" @@ -76,27 +75,26 @@ msgstr "La sentencia :keyword:`!for`" #: ../Doc/tutorial/controlflow.rst:51 msgid "" -"The :keyword:`for` statement in Python differs a bit from what you may be " -"used to in C or Pascal. Rather than always iterating over an arithmetic " +"The :keyword:`for` statement in Python differs a bit from what you may be used " +"to in C or Pascal. Rather than always iterating over an arithmetic " "progression of numbers (like in Pascal), or giving the user the ability to " -"define both the iteration step and halting condition (as C), Python's :" -"keyword:`!for` statement iterates over the items of any sequence (a list or " -"a string), in the order that they appear in the sequence. For example (no " -"pun intended):" +"define both the iteration step and halting condition (as C), Python's :keyword:" +"`!for` statement iterates over the items of any sequence (a list or 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::" +"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:72 msgid "" -"Code that modifies a collection while iterating over that same collection " -"can be tricky to get right. Instead, it is usually more straight-forward to " -"loop over a copy of the collection or to create a new collection::" +"Code that modifies a collection while iterating over that same collection can " +"be tricky to get right. Instead, it is usually more straight-forward to loop " +"over a copy of the collection or to create a new collection::" msgstr "" "Código que modifica una colección mientras se itera sobre la misma colección " "puede ser complejo de hacer bien. Sin embargo, suele ser más directo iterar " @@ -111,15 +109,15 @@ 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::" +"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:108 msgid "" "The given end point is never part of the generated sequence; ``range(10)`` " -"generates 10 values, the legal indices for items of a sequence of length " -"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')::" +"generates 10 values, the legal indices for items of a sequence of length 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 " @@ -129,11 +127,11 @@ msgstr "" #: ../Doc/tutorial/controlflow.rst:122 msgid "" -"To iterate over the indices of a sequence, you can combine :func:`range` " -"and :func:`len` as follows::" +"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í::" +"Para iterar sobre los índices de una secuencia, puedes combinar :func:`range` " +"y :func:`len` así::" #: ../Doc/tutorial/controlflow.rst:135 msgid "" @@ -149,15 +147,15 @@ msgstr "Algo extraño sucede si tan sólo muestras un ``range``::" #: ../Doc/tutorial/controlflow.rst:143 msgid "" -"In many ways the object returned by :func:`range` behaves as if it is a " -"list, but in fact it isn't. It is an object which returns the successive " -"items of the desired sequence when you iterate over it, but it doesn't " -"really make the list, thus saving space." +"In many ways the object returned by :func:`range` behaves as if it is a list, " +"but in fact it isn't. It is an object which returns the successive items of " +"the desired sequence when you iterate over it, but it doesn't really make the " +"list, thus saving space." msgstr "" "El objeto retornado por :func:`range` se comporta de muchas maneras como si " "fuera una lista, pero no lo es. Es un objeto que retorna los ítems sucesivos " -"de la secuencia deseada cuando iteras sobre él, pero realmente no construye " -"la lista, ahorrando entonces espacio." +"de la secuencia deseada cuando iteras sobre él, pero realmente no construye la " +"lista, ahorrando entonces espacio." #: ../Doc/tutorial/controlflow.rst:148 msgid "" @@ -168,10 +166,10 @@ msgid "" "that takes an iterable is :func:`sum`::" msgstr "" "Decimos que tal objeto es :term:`iterable`; esto es, que se 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 una de esas construcciones, mientras que un ejemplo de función que " -"toma un iterable es la función :func:`sum`::" +"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 una de " +"esas construcciones, mientras que un ejemplo de función que toma un iterable " +"es la función :func:`sum`::" #: ../Doc/tutorial/controlflow.rst:157 msgid "" @@ -180,8 +178,8 @@ msgid "" "about :func:`list`." msgstr "" "Más adelante veremos otras funciones que aceptan iterables cómo argumentos o " -"retornan iterables. En el capítulo :ref:`tut-structures`, discutiremos en " -"más detalle sobre la :func:`list`." +"retornan iterables. En el capítulo :ref:`tut-structures`, discutiremos en más " +"detalle sobre la :func:`list`." #: ../Doc/tutorial/controlflow.rst:164 msgid "" @@ -192,67 +190,76 @@ msgstr "" "bucles" #: ../Doc/tutorial/controlflow.rst:166 -#, fuzzy msgid "" -"The :keyword:`break` statement breaks out of the innermost enclosing :" -"keyword:`for` or :keyword:`while` loop." +"The :keyword:`break` statement breaks out of the innermost enclosing :keyword:" +"`for` or :keyword:`while` loop." msgstr "" -"La sentencia :keyword:`break`, como en C, termina el bucle :keyword:`for` o :" -"keyword:`while` más anidado." +"La sentencia :keyword:`break` termina el bucle :keyword:`for` o :keyword:" +"`while` más anidado." #: ../Doc/tutorial/controlflow.rst:169 msgid "" "A :keyword:`!for` or :keyword:`!while` loop can include an :keyword:`!else` " "clause." msgstr "" +"Un bucle :keyword:`!for` o :keyword:`!while` puede incluir una cláusula :" +"keyword:`!else`." #: ../Doc/tutorial/controlflow.rst:171 msgid "" "In a :keyword:`for` loop, the :keyword:`!else` clause is executed after the " "loop reaches its final iteration." msgstr "" +"En un bucle :keyword:`for`, la cláusula :keyword:`!else` se ejecuta después de " +"que el bucle alcance su iteración final." #: ../Doc/tutorial/controlflow.rst:174 msgid "" "In a :keyword:`while` loop, it's executed after the loop's condition becomes " "false." msgstr "" +"En un bucle :keyword:`while`, se ejecuta después de que la condición del bucle " +"se vuelva falsa." #: ../Doc/tutorial/controlflow.rst:176 msgid "" -"In either kind of loop, the :keyword:`!else` clause is **not** executed if " -"the loop was terminated by a :keyword:`break`." +"In either kind of loop, the :keyword:`!else` clause is **not** executed if the " +"loop was terminated by a :keyword:`break`." msgstr "" +"En cualquier tipo de bucle, la cláusula :keyword:`!else` **no** se ejecuta si " +"el bucle ha finalizado con :keyword:`break`." #: ../Doc/tutorial/controlflow.rst:179 msgid "" -"This is exemplified in the following :keyword:`!for` loop, which searches " -"for prime numbers::" +"This is exemplified in the following :keyword:`!for` loop, which searches for " +"prime numbers::" msgstr "" +"Esto se ejemplifica en el siguiente bucle :keyword:`!for`, que busca números " +"primos::" #: ../Doc/tutorial/controlflow.rst:200 msgid "" -"(Yes, this is the correct code. Look closely: the ``else`` clause belongs " -"to the :keyword:`for` loop, **not** the :keyword:`if` statement.)" +"(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`.)" +"(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:203 msgid "" "When used with a loop, the ``else`` clause has more in common with the " "``else`` clause of a :keyword:`try` statement than it does with that of :" "keyword:`if` statements: a :keyword:`try` statement's ``else`` clause runs " -"when no exception occurs, and a loop's ``else`` clause runs when no " -"``break`` occurs. For more on the :keyword:`!try` statement and exceptions, " -"see :ref:`tut-handling`." +"when no exception occurs, and a loop's ``else`` clause runs when no ``break`` " +"occurs. For more on the :keyword:`!try` statement and exceptions, see :ref:" +"`tut-handling`." msgstr "" "Cuando se usa con un bucle, la cláusula ``else`` tiene más en común con el " "``else`` de una sentencia :keyword:`try` que con el de un :keyword:`if`: en " "una sentencia :keyword:`try` la cláusula ``else`` se ejecuta cuando no se " "genera ninguna excepción, y el ``else`` de un bucle se ejecuta cuando no hay " -"ningún ``break``. Para más sobre la declaración :keyword:`!try` y " -"excepciones, mira :ref:`tut-handling`." +"ningún ``break``. Para más sobre la declaración :keyword:`!try` y excepciones, " +"mira :ref:`tut-handling`." #: ../Doc/tutorial/controlflow.rst:210 msgid "" @@ -268,12 +275,12 @@ msgstr "La sentencia :keyword:`pass`" #: ../Doc/tutorial/controlflow.rst:233 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::" +"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::" +"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:240 msgid "This is commonly used for creating minimal classes::" @@ -281,15 +288,14 @@ msgstr "Se usa normalmente para crear clases en su mínima expresión::" #: ../Doc/tutorial/controlflow.rst:246 msgid "" -"Another place :keyword:`pass` can be used is as a place-holder for a " -"function or conditional body when you are working on new code, allowing you " -"to keep thinking at a more abstract level. The :keyword:`!pass` is silently " -"ignored::" +"Another place :keyword:`pass` can be used is as a place-holder for a function " +"or conditional body when you are working on new code, allowing you 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::" +"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:258 msgid ":keyword:`!match` Statements" @@ -301,23 +307,21 @@ msgid "" "successive patterns given as one or more case blocks. This is superficially " "similar to a switch statement in C, Java or JavaScript (and many other " "languages), but it's more similar to pattern matching in languages like Rust " -"or Haskell. Only the first pattern that matches gets executed and it can " -"also extract components (sequence elements or object attributes) from the " -"value into variables." +"or Haskell. Only the first pattern that matches gets executed and it can also " +"extract components (sequence elements or object attributes) from the value " +"into variables." msgstr "" "Una sentencia :keyword:`match` recibe una expresión y compara su valor con " -"patrones sucesivos dados en uno o más bloques case. Esto es similar a " -"grandes rasgos con una sentencia switch en C, Java o JavaScript (y muchos " -"otros lenguajes) pero es más similar a la comparación de patrones en " -"lenguajes como Rust o Haskell. Sólo se ejecuta el primer patrón que coincide " -"y también es capaz de extraer componentes (elementos de una secuencia o " -"atributos de un objeto) de un valor y ponerlos en variables." +"patrones sucesivos dados en uno o más bloques case. Esto es similar a grandes " +"rasgos con una sentencia switch en C, Java o JavaScript (y muchos otros " +"lenguajes) pero es más similar a la comparación de patrones en lenguajes como " +"Rust o Haskell. Sólo se ejecuta el primer patrón que coincide y también es " +"capaz de extraer componentes (elementos de una secuencia o atributos de un " +"objeto) de un valor y ponerlos en variables." #: ../Doc/tutorial/controlflow.rst:268 -msgid "" -"The simplest form compares a subject value against one or more literals::" -msgstr "" -"La forma más simple compara un valor expuesto con uno o más literales::" +msgid "The simplest form compares a subject value against one or more literals::" +msgstr "La forma más simple compara un valor expuesto con uno o más literales::" #: ../Doc/tutorial/controlflow.rst:281 msgid "" @@ -354,68 +358,67 @@ msgstr "" "¡Observa éste caso con cuidado! El primer patrón tiene dos literales y puede " "considerarse una extensión del patrón literal que se mostró anteriormente. " "Pero los siguientes dos patrones combinan un literal y una variable, y la " -"variable *liga* uno de los elementos del sujeto (``point``). El cuarto " -"patrón captura ambos elementos, lo que lo hace conceptualmente similar a la " +"variable *liga* uno de los elementos del sujeto (``point``). El cuarto patrón " +"captura ambos elementos, lo que lo hace conceptualmente similar a la " "asignación que desempaqueta ``(x, y) = point``." #: ../Doc/tutorial/controlflow.rst:312 msgid "" "If you are using classes to structure your data you can use the class name " -"followed by an argument list resembling a constructor, but with the ability " -"to capture attributes into variables::" +"followed by an argument list resembling a constructor, but with the ability to " +"capture attributes into variables::" msgstr "" -"Si estás usando clases para estructurar tus datos, puedes usar el nombre de " -"la clase seguida de una lista de argumentos similar a la de un constructor, " -"pero con la capacidad de capturar atributos en variables::" +"Si estás usando clases para estructurar tus datos, puedes usar el nombre de la " +"clase seguida de una lista de argumentos similar a la de un constructor, pero " +"con la capacidad de capturar atributos en variables::" #: ../Doc/tutorial/controlflow.rst:334 msgid "" "You can use positional parameters with some builtin classes that provide an " "ordering for their attributes (e.g. dataclasses). You can also define a " -"specific position for attributes in patterns by setting the " -"``__match_args__`` special attribute in your classes. If it's set to (\"x\", " -"\"y\"), the following patterns are all equivalent (and all bind the ``y`` " -"attribute to the ``var`` variable)::" -msgstr "" -"Puedes usar argumentos posicionales en algunas clases incorporadas que " -"proveen un orden para sus atributos (por ej. dataclasses). También puedes " -"definir una posición especifica para los atributos de los patrones si " -"asignas en tu clase el atributo especial ``__match_args__``. Si le asignas " -"(\"x\", \"y\"), los siguientes patrones son todos equivalentes entre sí (y " -"todos ligan el atributo ``y`` a la variable ``var``)::" +"specific position for attributes in patterns by setting the ``__match_args__`` " +"special attribute in your classes. If it's set to (\"x\", \"y\"), the " +"following patterns are all equivalent (and all bind the ``y`` attribute to the " +"``var`` variable)::" +msgstr "" +"Puedes usar argumentos posicionales en algunas clases incorporadas que proveen " +"un orden para sus atributos (por ej. dataclasses). También puedes definir una " +"posición especifica para los atributos de los patrones si asignas en tu clase " +"el atributo especial ``__match_args__``. Si le asignas (\"x\", \"y\"), los " +"siguientes patrones son todos equivalentes entre sí (y todos ligan el atributo " +"``y`` a la variable ``var``)::" #: ../Doc/tutorial/controlflow.rst:345 msgid "" "A recommended way to read patterns is to look at them as an extended form of " -"what you would put on the left of an assignment, to understand which " -"variables would be set to what. Only the standalone names (like ``var`` " -"above) are assigned to by a match statement. Dotted names (like ``foo." -"bar``), attribute names (the ``x=`` and ``y=`` above) or class names " -"(recognized by the \"(...)\" next to them like ``Point`` above) are never " -"assigned to." -msgstr "" -"Una recomendación para leer patrones es verlos como una forma extendida de " -"lo que pondrías en el lado izquierdo de una asignación, para así entender " -"cuáles variables tomarían qué valores. Sólo los nombres que aparecen por si " -"solos (cómo ``var`` arriba) son asignados por una sentencia match. Nunca se " -"asigna a los nombres con puntos (como ``foo.bar``), nombres de atributos " -"(los ``x=`` e ``y=`` arriba) o nombres de clases (reconocidos por los " -"\"(...)\" junto a ellos, como ``Point`` arriba)." +"what you would put on the left of an assignment, to understand which variables " +"would be set to what. Only the standalone names (like ``var`` above) are " +"assigned to by a match statement. Dotted names (like ``foo.bar``), attribute " +"names (the ``x=`` and ``y=`` above) or class names (recognized by the " +"\"(...)\" next to them like ``Point`` above) are never assigned to." +msgstr "" +"Una recomendación para leer patrones es verlos como una forma extendida de lo " +"que pondrías en el lado izquierdo de una asignación, para así entender cuáles " +"variables tomarían qué valores. Sólo los nombres que aparecen por si solos " +"(cómo ``var`` arriba) son asignados por una sentencia match. Nunca se asigna a " +"los nombres con puntos (como ``foo.bar``), nombres de atributos (los ``x=`` e " +"``y=`` arriba) o nombres de clases (reconocidos por los \"(...)\" junto a " +"ellos, como ``Point`` arriba)." #: ../Doc/tutorial/controlflow.rst:352 -#, fuzzy msgid "" "Patterns can be arbitrarily nested. For example, if we have a short list of " "Points, with ``__match_args__`` added, we could match it like this::" msgstr "" "Los patrones pueden anidarse arbitrariamente. Por ejemplo, si tuviéramos una " -"lista corta de puntos, podríamos aplicar match así::" +"lista corta de puntos, con ``__match_args__`` añadido, podríamos aplicar match " +"así::" #: ../Doc/tutorial/controlflow.rst:373 msgid "" -"We can add an ``if`` clause to a pattern, known as a \"guard\". If the " -"guard is false, ``match`` goes on to try the next case block. Note that " -"value capture happens before the guard is evaluated::" +"We can add an ``if`` clause to a pattern, known as a \"guard\". If the guard " +"is false, ``match`` goes on to try the next case block. Note that value " +"capture happens before the guard is evaluated::" msgstr "" "Podemos añadir una clausula ``if`` a un patrón, conocida como \"guarda\". Si " "la guarda es falsa, ``match`` pasa a intentar el siguiente bloque case. " @@ -433,22 +436,22 @@ msgid "" "that they don't match iterators or strings." msgstr "" "Al igual que las asignaciones con desempaquetado, los patrones de lista o " -"tupla tienen exactamente el mismo sentido y realmente coinciden con " -"cualquier secuencia arbitraria. Una excepción importante es que no coinciden " -"ni con iteradores ni con cadenas de caracteres." +"tupla tienen exactamente el mismo sentido y realmente coinciden con cualquier " +"secuencia arbitraria. Una excepción importante es que no coinciden ni con " +"iteradores ni con cadenas de caracteres." #: ../Doc/tutorial/controlflow.rst:389 msgid "" "Sequence patterns support extended unpacking: ``[x, y, *rest]`` and ``(x, y, " -"*rest)`` work similar to unpacking assignments. The name after ``*`` may " -"also be ``_``, so ``(x, y, *_)`` matches a sequence of at least two items " -"without binding the remaining items." +"*rest)`` work similar to unpacking assignments. The name after ``*`` may also " +"be ``_``, so ``(x, y, *_)`` matches a sequence of at least two items without " +"binding the remaining items." msgstr "" "Los patrones de secuencia soportan desempaquetado extendido: ``[x, y, " -"*otros]`` y ``(x, y, *otros)`` funcionan de manera similar a las " -"asignaciones con desempaquetado. El nombre luego de ``*`` también puede ser " -"``_``, con lo cual ``(x, y, *_)`` coincide con cualquier secuencia de al " -"menos dos elementos, sin ligar ninguno de los demás elementos." +"*otros]`` y ``(x, y, *otros)`` funcionan de manera similar a las asignaciones " +"con desempaquetado. El nombre luego de ``*`` también puede ser ``_``, con lo " +"cual ``(x, y, *_)`` coincide con cualquier secuencia de al menos dos " +"elementos, sin ligar ninguno de los demás elementos." #: ../Doc/tutorial/controlflow.rst:394 msgid "" @@ -459,9 +462,9 @@ msgid "" msgstr "" "Los patrones de mapeo: ``{\"ancho_de_banda\": c, \"latencia\": l}`` capturan " "los valores ``\"ancho_de_banda\"`` y ``\"latencia\"`` de un diccionario. A " -"diferencia de los patrones de secuencia, las claves adicionales son " -"ignoradas. Puede usarse un desempaquetado como ``**otros`` . (Aunque ``**_`` " -"sería redundante, con lo cual no está permitido)" +"diferencia de los patrones de secuencia, las claves adicionales son ignoradas. " +"Puede usarse un desempaquetado como ``**otros`` . (Aunque ``**_`` sería " +"redundante, con lo cual no está permitido)" #: ../Doc/tutorial/controlflow.rst:399 msgid "Subpatterns may be captured using the ``as`` keyword::" @@ -485,8 +488,8 @@ msgstr "" #: ../Doc/tutorial/controlflow.rst:409 msgid "" -"Patterns may use named constants. These must be dotted names to prevent " -"them from being interpreted as capture variable::" +"Patterns may use named constants. These must be dotted names to prevent them " +"from being interpreted as capture variable::" msgstr "" "En un patrón pueden usarse constantes con nombres. Los nombres deben tener " "puntos para impedir que sean interpretados como variables a capturar::" @@ -496,8 +499,8 @@ msgid "" "For a more detailed explanation and additional examples, you can look into :" "pep:`636` which is written in a tutorial format." msgstr "" -"Para una explicación más detallada y más ejemplos, puede leerse :pep:`636` " -"que está escrita en un formato de tutorial." +"Para una explicación más detallada y más ejemplos, puede leerse :pep:`636` que " +"está escrita en un formato de tutorial." #: ../Doc/tutorial/controlflow.rst:434 msgid "Defining Functions" @@ -514,9 +517,9 @@ msgstr "" #: ../Doc/tutorial/controlflow.rst:456 msgid "" "The keyword :keyword:`def` introduces a function *definition*. It must be " -"followed by the function name and the parenthesized list of formal " -"parameters. The statements that form the body of the function start at the " -"next line, and must be indented." +"followed by the function name and the parenthesized list of formal 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 " @@ -530,71 +533,71 @@ msgid "" "`docstring`. (More about docstrings can be found in the section :ref:`tut-" "docstrings`.) There are tools which use docstrings to automatically produce " "online or printed documentation, or to let the user interactively browse " -"through code; it's good practice to include docstrings in code that you " -"write, so make a habit of it." +"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`. (Puedes 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, así " -"que acostúmbrate a hacerlo." +"función, o :dfn:`docstring`. (Puedes 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, así que " +"acostúmbrate a hacerlo." #: ../Doc/tutorial/controlflow.rst:468 msgid "" -"The *execution* of a function introduces a new symbol table used for the " -"local variables of the function. More precisely, all variable assignments " -"in a function store the value in the local symbol table; whereas variable " +"The *execution* of a function introduces a new symbol table used for the local " +"variables of the function. More precisely, all variable assignments in a " +"function store the value in the local symbol table; whereas variable " "references first look in the local symbol table, then in the local symbol " -"tables of enclosing functions, then in the global symbol table, and finally " -"in the table of built-in names. Thus, global variables and variables of " -"enclosing functions cannot be directly assigned a value within a function " -"(unless, for global variables, named in a :keyword:`global` statement, or, " -"for variables of enclosing functions, named in a :keyword:`nonlocal` " -"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í, a variables globales y a variables de funciones " -"que engloban a una función no se les puede asignar directamente un valor " -"dentro de una función (a menos que se las nombre en la sentencia :keyword:" -"`global`, o mediante la sentencia :keyword:`nonlocal` para variables de " -"funciones que engloban la función local), aunque si pueden ser referenciadas." +"tables of enclosing functions, then in the global symbol table, and finally in " +"the table of built-in names. Thus, global variables and variables of enclosing " +"functions cannot be directly assigned a value within a function (unless, for " +"global variables, named in a :keyword:`global` statement, or, for variables of " +"enclosing functions, named in a :keyword:`nonlocal` 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í, a " +"variables globales y a variables de funciones que engloban a una función no se " +"les puede asignar directamente un valor dentro de una función (a menos que se " +"las nombre en la sentencia :keyword:`global`, o mediante la sentencia :keyword:" +"`nonlocal` para variables de funciones que engloban la función local), aunque " +"si pueden ser referenciadas." #: ../Doc/tutorial/controlflow.rst:479 msgid "" "The actual parameters (arguments) to a function call are introduced in the " "local symbol table of the called function when it is called; thus, arguments " "are passed using *call by value* (where the *value* is always an object " -"*reference*, not the value of the object). [#]_ When a function calls " -"another function, or calls itself recursively, a new local symbol table is " -"created for that call." +"*reference*, not the value of the object). [#]_ When a function calls another " +"function, or calls itself recursively, a new local symbol table is created for " +"that call." msgstr "" "Los parámetros reales (argumentos) para una llamada de función se introducen " -"en la tabla de símbolos local de la función llamada cuando ésta se llama; " -"por lo tanto, los argumentos se pasan usando *llamada por valor* (donde el " -"*valor* es siempre una *referencia* al objeto, no el valor del objeto). [#]_ " -"Cuando una función llama a otra función, o se llama a sí misma de forma " -"recursiva, se crea una nueva tabla de símbolos locales para esa llamada." +"en la tabla de símbolos local de la función llamada cuando ésta se llama; por " +"lo tanto, los argumentos se pasan usando *llamada por valor* (donde el *valor* " +"es siempre una *referencia* al objeto, no el valor del objeto). [#]_ Cuando " +"una función llama a otra función, o se llama a sí misma de forma recursiva, se " +"crea una nueva tabla de símbolos locales para esa llamada." #: ../Doc/tutorial/controlflow.rst:486 msgid "" -"A function definition associates the function name with the function object " -"in the current symbol table. The interpreter recognizes the object pointed " -"to by that name as a user-defined function. Other names can also point to " -"that same function object and can also be used to access the function::" +"A function definition associates the function name with the function object in " +"the current symbol table. The interpreter recognizes the object pointed to by " +"that name as a user-defined function. Other names can also point to that same " +"function object and can also be used to access the function::" msgstr "" "Una definición de función asocia el nombre de la función con el objeto de " "función en la tabla de símbolos actual. El intérprete reconoce el objeto al " -"que apunta ese nombre como una función definida por el usuario. Otros " -"nombres también pueden apuntar a ese mismo objeto de función y también se " -"pueden usar para acceder a la función:" +"que apunta ese nombre como una función definida por el usuario. Otros nombres " +"también pueden apuntar a ese mismo objeto de función y también se pueden usar " +"para acceder a la función:" #: ../Doc/tutorial/controlflow.rst:497 msgid "" @@ -610,9 +613,9 @@ msgstr "" "sino un procedimiento, porque no retorna un valor. De hecho, técnicamente " "hablando, los procedimientos sin :keyword:`return` sí retornan un valor, " "aunque uno bastante 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. Puede verlo si realmente lo desea " -"utilizando :func:`print`::" +"predefinido). El intérprete por lo general no escribe el valor ``None`` si va " +"a ser el único valor escrito. Puede verlo si realmente lo desea utilizando :" +"func:`print`::" #: ../Doc/tutorial/controlflow.rst:508 msgid "" @@ -625,44 +628,41 @@ msgstr "" #: ../Doc/tutorial/controlflow.rst:524 msgid "This example, as usual, demonstrates some new Python features:" msgstr "" -"Este ejemplo, como es usual, demuestra algunas características más de " -"Python::" +"Este ejemplo, como es usual, demuestra algunas características más de Python::" #: ../Doc/tutorial/controlflow.rst:526 msgid "" -"The :keyword:`return` statement returns with a value from a function. :" -"keyword:`!return` without an expression argument returns ``None``. Falling " -"off the end of a function also returns ``None``." +"The :keyword:`return` statement returns with a value from a function. :keyword:" +"`!return` without an expression argument returns ``None``. Falling off the end " +"of a function also returns ``None``." msgstr "" "La sentencia :keyword:`return` retorna 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:530 -#, fuzzy msgid "" "The statement ``result.append(a)`` calls a *method* of the list object " "``result``. A method is a function that 'belongs' to an object and is named " -"``obj.methodname``, where ``obj`` is some object (this may be an " -"expression), and ``methodname`` is the name of a method that is defined by " -"the object's type. Different types define different methods. Methods of " -"different types may have the same name without causing ambiguity. (It is " -"possible to define your own object types and methods, using *classes*, see :" -"ref:`tut-classes`) The method :meth:`!append` shown in the example is " -"defined 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 " +"``obj.methodname``, where ``obj`` is some object (this may be an expression), " +"and ``methodname`` is the name of a method that is defined by the object's " +"type. Different types define different methods. Methods of different types " +"may have the same name without causing ambiguity. (It is possible to define " +"your own object types and methods, using *classes*, see :ref:`tut-classes`) " +"The method :meth:`!append` shown in the example is defined 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 tus propios tipos de objetos y métodos, usando clases, ver :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." +"``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 tus " +"propios tipos de objetos y métodos, usando *clases*, ver :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:545 msgid "More on Defining Functions" @@ -673,8 +673,8 @@ 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." +"También es posible definir funciones con un número variable de argumentos. Hay " +"tres formas que pueden ser combinadas." #: ../Doc/tutorial/controlflow.rst:554 msgid "Default Argument Values" @@ -682,9 +682,9 @@ msgstr "Argumentos con valores por omisión" #: ../Doc/tutorial/controlflow.rst:556 msgid "" -"The most useful form is to specify a default value for one or more " -"arguments. This creates a function that can be called with fewer arguments " -"than it is defined to allow. For example::" +"The most useful form is to specify a default value for one or more 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 " @@ -714,13 +714,13 @@ 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!')``" +"o pasando todos los argumentos: ``ask_ok('OK to overwrite the file?', 2, 'Come " +"on, only yes or no!')``" #: ../Doc/tutorial/controlflow.rst:581 msgid "" -"This example also introduces the :keyword:`in` keyword. This tests whether " -"or not a sequence contains a certain value." +"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." @@ -739,16 +739,16 @@ msgstr "imprimirá ``5``." #: ../Doc/tutorial/controlflow.rst:597 msgid "" -"**Important warning:** The default value is evaluated only once. This makes " -"a difference when the default is a mutable object such as a list, " -"dictionary, or instances of most classes. For example, the following " -"function accumulates the arguments passed to it on subsequent calls::" +"**Important warning:** The default value is evaluated only once. This makes a " +"difference when the default is a mutable object such as a list, 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::" +"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:610 msgid "This will print ::" @@ -769,22 +769,21 @@ msgstr "Palabras claves como argumentos" #: ../Doc/tutorial/controlflow.rst:631 msgid "" "Functions can also be called using :term:`keyword arguments ` of the form ``kwarg=value``. For instance, the following " -"function::" +"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 " +"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:640 msgid "" "accepts one required argument (``voltage``) and three optional arguments " -"(``state``, ``action``, and ``type``). This function can be called in any " -"of the following ways::" +"(``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::" +"...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:651 msgid "but all the following calls would be invalid::" @@ -794,39 +793,38 @@ msgstr "...pero estas otras llamadas serían todas inválidas::" msgid "" "In a function call, keyword arguments must follow positional arguments. All " "the keyword arguments passed must match one of the arguments accepted by the " -"function (e.g. ``actor`` is not a valid argument for the ``parrot`` " -"function), and their order is not important. This also includes non-" -"optional arguments (e.g. ``parrot(voltage=1000)`` is valid too). No argument " -"may receive a value more than once. Here's an example that fails due to this " -"restriction::" +"function (e.g. ``actor`` is not a valid argument for the ``parrot`` function), " +"and their order is not important. This also includes non-optional arguments " +"(e.g. ``parrot(voltage=1000)`` is valid too). No argument 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::" +"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:674 msgid "" -"When a final formal parameter of the form ``**name`` is present, it receives " -"a dictionary (see :ref:`typesmapping`) containing all keyword arguments " -"except for those corresponding to a formal parameter. This may be combined " -"with a formal parameter of the form ``*name`` (described in the next " -"subsection) which receives a :ref:`tuple ` containing the " -"positional arguments beyond the formal parameter list. (``*name`` must " -"occur before ``**name``.) For example, if we define a function like this::" +"When a final formal parameter of the form ``**name`` is present, it receives a " +"dictionary (see :ref:`typesmapping`) containing all keyword arguments except " +"for those corresponding to a formal parameter. This may be combined with a " +"formal parameter of the form ``*name`` (described in the next subsection) " +"which receives a :ref:`tuple ` containing the positional arguments " +"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 :ref:`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í::" +"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 :ref:`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:691 msgid "It could be called like this::" @@ -842,8 +840,8 @@ msgid "" "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." +"está garantizado para coincidir con el orden en el cual fueron provistos en la " +"llamada a la función." #: ../Doc/tutorial/controlflow.rst:716 msgid "Special parameters" @@ -851,18 +849,17 @@ msgstr "Parámetros especiales" #: ../Doc/tutorial/controlflow.rst:718 msgid "" -"By default, arguments may be passed to a Python function either by position " -"or explicitly by keyword. For readability and performance, it makes sense to " -"restrict the way arguments can be passed so that a developer need only look " -"at the function definition to determine if items are passed by position, by " +"By default, arguments may be passed to a Python function either by position or " +"explicitly by keyword. For readability and performance, it makes sense to " +"restrict the way arguments can be passed so that a developer need only look at " +"the function definition to determine if items are passed by position, by " "position or keyword, or by keyword." msgstr "" "Por defecto, los argumentos pueden enviarse a una función Python o bien por " "posición o explícitamente por clave. Para legibilidad y rendimiento tiene " -"sentido restringir como se pueden enviar los argumentos, así un " -"desarrollador necesitará mirar solamente la definición de la función para " -"determinar si los argumentos se deben enviar por posición, por posición o " -"clave, o por clave." +"sentido restringir como se pueden enviar los argumentos, así un desarrollador " +"necesitará mirar solamente la definición de la función para determinar si los " +"argumentos se deben enviar por posición, por posición o clave, o por clave." #: ../Doc/tutorial/controlflow.rst:724 msgid "A function definition may look like:" @@ -875,9 +872,9 @@ msgid "" "only, positional-or-keyword, and keyword-only. Keyword parameters are also " "referred to as named parameters." msgstr "" -"donde ``/`` y ``*`` son posicionales. Si se utilizan, esos símbolos indican " -"el tipo de parámetro según la forma en que los argumentos deben enviarse a " -"la función: solo por posición (*positional-only*), por posición o clave " +"donde ``/`` y ``*`` son posicionales. Si se utilizan, esos símbolos indican el " +"tipo de parámetro según la forma en que los argumentos deben enviarse a la " +"función: solo por posición (*positional-only*), por posición o clave " "(*positional-or-keyword*) y solo por clave (*keyword-only*). Parámetros por " "clave pueden también denominarse parámetros por nombre o nombrados." @@ -908,13 +905,13 @@ msgid "" "parameters. If there is no ``/`` in the function definition, there are no " "positional-only parameters." msgstr "" -"Mirando esto con un poco más de detalle, es posible señalar algunos " -"parámetros como *únicamente posicionales*. En ese caso el orden de los " -"parámetros es importante, y los parámetros no pueden ser indicados " -"utilizando palabras claves. Parámetros únicamente posicionales son ubicados " -"antes de una ``/`` (barra). La ``/`` es utilizada para separar lógicamente " -"parámetros únicamente posicionales del resto. Si no existe una ``/`` en la " -"definición de la función, no existen parámetros únicamente posicionales." +"Mirando esto con un poco más de detalle, es posible señalar algunos parámetros " +"como *únicamente posicionales*. En ese caso el orden de los parámetros es " +"importante, y los parámetros no pueden ser indicados utilizando palabras " +"claves. Parámetros únicamente posicionales son ubicados antes de una ``/`` " +"(barra). La ``/`` es utilizada para separar lógicamente parámetros únicamente " +"posicionales del resto. Si no existe una ``/`` en la definición de la función, " +"no existen parámetros únicamente posicionales." #: ../Doc/tutorial/controlflow.rst:759 msgid "" @@ -930,14 +927,13 @@ msgstr "Argumentos únicamente de palabras clave" #: ../Doc/tutorial/controlflow.rst:765 msgid "" -"To mark parameters as *keyword-only*, indicating the parameters must be " -"passed by keyword argument, place an ``*`` in the arguments list just before " -"the first *keyword-only* parameter." +"To mark parameters as *keyword-only*, indicating the parameters must be passed " +"by keyword argument, place an ``*`` in the arguments list just before the " +"first *keyword-only* parameter." msgstr "" -"Para señalar parámetros como *unicamente de palabras clave*, indicando que " -"los parámetros deben ser pasados con una palabra clave, indiqué un ``*`` en " -"la lista de argumentos antes del primer parámetro *únicamente de palabras " -"clave*." +"Para señalar parámetros como *unicamente de palabras clave*, indicando que los " +"parámetros deben ser pasados con una palabra clave, indiqué un ``*`` en la " +"lista de argumentos antes del primer parámetro *únicamente de palabras clave*." #: ../Doc/tutorial/controlflow.rst:771 msgid "Function Examples" @@ -945,11 +941,11 @@ msgstr "Ejemplos de Funciones" #: ../Doc/tutorial/controlflow.rst:773 msgid "" -"Consider the following example function definitions paying close attention " -"to the markers ``/`` and ``*``::" +"Consider the following example function definitions paying close attention to " +"the markers ``/`` and ``*``::" msgstr "" -"Considere el siguiente ejemplo de definiciones de funciones prestando " -"especial atención a los marcadores ``/`` y ``*``::" +"Considere el siguiente ejemplo de definiciones de funciones prestando especial " +"atención a los marcadores ``/`` y ``*``::" #: ../Doc/tutorial/controlflow.rst:789 msgid "" @@ -988,12 +984,12 @@ msgstr "" #: ../Doc/tutorial/controlflow.rst:841 msgid "" "Finally, consider this function definition which has a potential collision " -"between the positional argument ``name`` and ``**kwds`` which has ``name`` " -"as a key::" +"between the positional argument ``name`` and ``**kwds`` which has ``name`` as " +"a key::" msgstr "" "Finalmente, considere esta definición de función que contiene una colisión " -"potencial entre los parámetros posicionales ``name`` y ``**kwds`` que " -"incluye ``name`` como una clave::" +"potencial entre los parámetros posicionales ``name`` y ``**kwds`` que incluye " +"``name`` como una clave::" #: ../Doc/tutorial/controlflow.rst:846 msgid "" @@ -1009,9 +1005,9 @@ msgid "" "``name`` as a positional argument and ``'name'`` as a key in the keyword " "arguments::" msgstr "" -"Pero utilizando ``/`` (parámetros únicamente posicionales), es posible ya " -"que permite utilizar ``name`` como un parámetro posicional y ``name`` como " -"un parámetro de palabras clave::" +"Pero utilizando ``/`` (parámetros únicamente posicionales), es posible ya que " +"permite utilizar ``name`` como un parámetro posicional y ``name`` como un " +"parámetro de palabras clave::" #: ../Doc/tutorial/controlflow.rst:863 msgid "" @@ -1039,11 +1035,10 @@ msgstr "A modo de guía:" #: ../Doc/tutorial/controlflow.rst:876 msgid "" -"Use positional-only if you want the name of the parameters to not be " -"available to the user. This is useful when parameter names have no real " -"meaning, if you want to enforce the order of the arguments when the function " -"is called or if you need to take some positional parameters and arbitrary " -"keywords." +"Use positional-only if you want the name of the parameters to not be available " +"to the user. This is useful when parameter names have no real meaning, if you " +"want to enforce the order of the arguments when the function is called or if " +"you need to take some positional parameters and arbitrary keywords." msgstr "" "Utilice únicamente posicionales si quiere que el nombre del parámetro esté " "disponible para el usuario. Esto es útil cuando el nombre del parámetro no " @@ -1076,10 +1071,10 @@ msgstr "Listas de argumentos arbitrarios" #: ../Doc/tutorial/controlflow.rst:895 msgid "" -"Finally, the least frequently used option is to specify that a function can " -"be called with an arbitrary number of arguments. These arguments will be " -"wrapped up in a tuple (see :ref:`tut-tuples`). Before the variable number " -"of arguments, zero or more normal arguments may occur. ::" +"Finally, the least frequently used option is to specify that a function can be " +"called with an arbitrary number of arguments. These arguments will be 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 " @@ -1091,15 +1086,15 @@ msgstr "" msgid "" "Normally, these *variadic* arguments will be last in the list of formal " "parameters, because they scoop up all remaining input arguments that are " -"passed to the function. Any formal parameters which occur after the " -"``*args`` parameter are 'keyword-only' arguments, meaning that they can only " -"be used as keywords rather than positional arguments. ::" +"passed to the function. Any formal parameters which occur after the ``*args`` " +"parameter are 'keyword-only' arguments, meaning that they can only be used as " +"keywords rather than positional arguments. ::" msgstr "" "Normalmente estos argumentos *variádicos* serán 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 de palabra clave', o sea que sólo se pueden usar como argumentos " -"nombrados y no como posicionales. ::" +"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 de " +"palabra clave', o sea que sólo se pueden usar como argumentos nombrados y no " +"como posicionales. ::" #: ../Doc/tutorial/controlflow.rst:921 msgid "Unpacking Argument Lists" @@ -1107,20 +1102,20 @@ msgstr "Desempaquetando una lista de argumentos" #: ../Doc/tutorial/controlflow.rst:923 msgid "" -"The reverse situation occurs when the arguments are already in a list or " -"tuple but need to be unpacked for a function call requiring separate " -"positional arguments. For instance, the built-in :func:`range` function " -"expects separate *start* and *stop* arguments. If they are not available " -"separately, write the function call with the ``*``\\ -operator to unpack " -"the arguments out of a list or tuple::" +"The reverse situation occurs when the arguments are already in a list or tuple " +"but need to be unpacked for a function call requiring separate positional " +"arguments. For instance, the built-in :func:`range` function expects separate " +"*start* and *stop* arguments. If they are not available 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 parámetros *inicio* y *fin*. Si estos " -"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::" +"predefinida :func:`range` espera los parámetros *inicio* y *fin*. Si estos 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:939 msgid "" @@ -1138,25 +1133,25 @@ msgstr "Expresiones lambda" msgid "" "Small anonymous functions can be created with the :keyword:`lambda` keyword. " "This function returns the sum of its two arguments: ``lambda a, b: a+b``. " -"Lambda functions can be used wherever function objects are required. They " -"are syntactically restricted to a single expression. Semantically, they are " -"just syntactic sugar for a normal function definition. Like nested function " +"Lambda functions can be used wherever function objects are required. They are " +"syntactically restricted to a single expression. Semantically, they are just " +"syntactic sugar for a normal function definition. Like nested function " "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::" +"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:974 msgid "" -"The above example uses a lambda expression to return a function. Another " -"use is to pass a small function as an argument::" +"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 ::" @@ -1177,21 +1172,21 @@ msgstr "" msgid "" "The first line should always be a short, concise summary of the object's " "purpose. For brevity, it should not explicitly state the object's name or " -"type, since these are available by other means (except if the name happens " -"to be a verb describing a function's operation). This line should begin " -"with a capital letter and end with a period." +"type, since these are available by other means (except if the name happens 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." +"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:1002 msgid "" -"If there are more lines in the documentation string, the second line should " -"be blank, visually separating the summary from the rest of the description. " -"The following lines should be one or more paragraphs describing the object's " +"If there are more lines in the documentation string, the second line should be " +"blank, visually separating the summary from the rest of the description. 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 " @@ -1204,28 +1199,27 @@ msgid "" "The Python parser does not strip indentation from multi-line string literals " "in Python, so tools that process documentation have to strip indentation if " "desired. This is done using the following convention. The first non-blank " -"line *after* the first line of the string determines the amount of " -"indentation for the entire documentation string. (We can't use the first " -"line since it is generally adjacent to the string's opening quotes so its " -"indentation is not apparent in the string literal.) Whitespace " -"\"equivalent\" to this indentation is then stripped from the start of all " -"lines of the string. Lines that are indented less should not occur, but if " -"they occur 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)." +"line *after* the first line of the string determines the amount of indentation " +"for the entire documentation string. (We can't use the first line since it is " +"generally adjacent to the string's opening quotes so its indentation is not " +"apparent in the string literal.) Whitespace \"equivalent\" to this " +"indentation is then stripped from the start of all lines of the string. Lines " +"that are indented less should not occur, but if they occur 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:1019 msgid "Here is an example of a multi-line docstring::" @@ -1246,26 +1240,25 @@ msgstr "" "pep:`3107` y :pep:`484` para más información)." #: ../Doc/tutorial/controlflow.rst:1049 -#, fuzzy msgid "" ":term:`Annotations ` are stored in the :attr:`!" -"__annotations__` attribute of the function as a dictionary and have no " -"effect on any other part of the function. Parameter annotations are defined " -"by a colon after the parameter name, followed by an expression evaluating to " -"the value of the annotation. Return annotations are defined by a literal ``-" -">``, followed by an expression, between the parameter list and the colon " -"denoting the end of the :keyword:`def` statement. The following example has " -"a required argument, an optional argument, and the return value annotated::" +"__annotations__` attribute of the function as a dictionary and have no effect " +"on any other part of the function. Parameter annotations are defined by a " +"colon after the parameter name, followed by an expression evaluating to the " +"value of the annotation. Return annotations are defined by a literal ``->``, " +"followed by an expression, between the parameter list and the colon denoting " +"the end of the :keyword:`def` statement. The following example has a required " +"argument, an optional 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 " +"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::" +"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:1071 msgid "Intermezzo: Coding Style" @@ -1273,30 +1266,30 @@ msgstr "Intermezzo: Estilo de programación" #: ../Doc/tutorial/controlflow.rst:1076 msgid "" -"Now that you are about to write longer, more complex pieces of Python, it is " -"a good time to talk about *coding style*. Most languages can be written (or " +"Now that you are about to write longer, more complex pieces of Python, it is a " +"good time to talk about *coding style*. Most languages can be written (or " "more concise, *formatted*) in different styles; some are more readable than " -"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." +"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 programació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 programación ayuda tremendamente a lograrlo." +"código sea más fácil de leer por otros es siempre una buena idea, y adoptar un " +"buen estilo de programación ayuda tremendamente a lograrlo." #: ../Doc/tutorial/controlflow.rst:1082 msgid "" -"For Python, :pep:`8` has emerged as the style guide that most projects " -"adhere to; it promotes a very readable and eye-pleasing coding style. Every " -"Python developer should read it at some point; here are the most important " -"points extracted for you:" +"For Python, :pep:`8` has emerged as the style guide that most projects adhere " +"to; it promotes a very readable and eye-pleasing coding style. Every 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 programació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::" +"Para Python, :pep:`8` se erigió como la guía de estilo a la que más proyectos " +"adhirieron; promueve un estilo de programació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:1087 msgid "Use 4-space indentation, and no tabs." @@ -1368,8 +1361,8 @@ msgid "" "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." +"internacionales. El default de Python, UTF-8, o incluso ASCII plano funcionan " +"bien en la mayoría de los casos." #: ../Doc/tutorial/controlflow.rst:1117 msgid "" @@ -1377,9 +1370,9 @@ 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." +"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:1123 msgid "Footnotes" @@ -1387,92 +1380,84 @@ msgstr "Notas al pie" #: ../Doc/tutorial/controlflow.rst:1124 msgid "" -"Actually, *call by object reference* would be a better description, since if " -"a mutable object is passed, the caller will see any changes the callee makes " -"to it (items inserted into a list)." +"Actually, *call by object reference* would be a better description, since if 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)." +"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)." #: ../Doc/tutorial/controlflow.rst:48 msgid "statement" -msgstr "" +msgstr "statement" #: ../Doc/tutorial/controlflow.rst:48 msgid "for" -msgstr "" +msgstr "for" #: ../Doc/tutorial/controlflow.rst:451 ../Doc/tutorial/controlflow.rst:988 -#, fuzzy msgid "documentation strings" -msgstr "Cadenas de texto de documentación" +msgstr "documentation strings" #: ../Doc/tutorial/controlflow.rst:451 ../Doc/tutorial/controlflow.rst:988 -#, fuzzy msgid "docstrings" -msgstr "Usar ``docstrings``." +msgstr "docstrings" #: ../Doc/tutorial/controlflow.rst:451 ../Doc/tutorial/controlflow.rst:988 -#, fuzzy msgid "strings, documentation" -msgstr "Cadenas de texto de documentación" +msgstr "strings, documentation" #: ../Doc/tutorial/controlflow.rst:892 msgid "* (asterisk)" -msgstr "" +msgstr "* (asterisco)" #: ../Doc/tutorial/controlflow.rst:892 ../Doc/tutorial/controlflow.rst:936 -#, fuzzy msgid "in function calls" -msgstr "Ejemplos de Funciones" +msgstr "in function calls" #: ../Doc/tutorial/controlflow.rst:936 msgid "**" -msgstr "" +msgstr "**" #: ../Doc/tutorial/controlflow.rst:1040 -#, fuzzy msgid "function" -msgstr "Ejemplos de Funciones" +msgstr "function" #: ../Doc/tutorial/controlflow.rst:1040 -#, fuzzy msgid "annotations" -msgstr "Anotación de funciones" +msgstr "annotations" #: ../Doc/tutorial/controlflow.rst:1040 msgid "->" -msgstr "" +msgstr "->" #: ../Doc/tutorial/controlflow.rst:1040 -#, fuzzy msgid "function annotations" -msgstr "Anotación de funciones" +msgstr "function annotations" #: ../Doc/tutorial/controlflow.rst:1040 msgid ": (colon)" -msgstr "" +msgstr ": (dos puntos)" #: ../Doc/tutorial/controlflow.rst:1074 msgid "coding" -msgstr "" +msgstr "coding" #: ../Doc/tutorial/controlflow.rst:1074 msgid "style" -msgstr "" +msgstr "style" #~ msgid "" #~ "Loop statements may have an :keyword:`!else` clause; it is executed when " #~ "the loop terminates through exhaustion of the iterable (with :keyword:" -#~ "`for`) or when the condition becomes false (with :keyword:`while`), but " -#~ "not when the loop is terminated by a :keyword:`break` statement. This is " +#~ "`for`) or when the condition becomes false (with :keyword:`while`), but not " +#~ "when the loop is terminated by a :keyword:`break` statement. This is " #~ "exemplified by the following loop, which searches for prime numbers::" #~ msgstr "" #~ "Las sentencias de bucle pueden tener una cláusula :keyword:`!else` que es " #~ "ejecutada cuando el bucle termina, después de agotar el iterable (con :" -#~ "keyword:`for`) o cuando la condición se hace falsa (con :keyword:" -#~ "`while`), pero no cuando el bucle se termina con la sentencia :keyword:" -#~ "`break`. Se puede ver el ejemplo en el siguiente bucle, que busca números " -#~ "primos::" +#~ "keyword:`for`) o cuando la condición se hace falsa (con :keyword:`while`), " +#~ "pero no cuando el bucle se termina con la sentencia :keyword:`break`. Se " +#~ "puede ver el ejemplo en el siguiente bucle, que busca números primos::" From 4bace4a9b22fbe50196634acbf56e3b2542792c8 Mon Sep 17 00:00:00 2001 From: "Carlos A. Crespo" Date: Tue, 28 Nov 2023 12:07:09 -0300 Subject: [PATCH 2/2] powrap --- tutorial/controlflow.po | 833 ++++++++++++++++++++-------------------- 1 file changed, 424 insertions(+), 409 deletions(-) diff --git a/tutorial/controlflow.po b/tutorial/controlflow.po index 26aa44eb0d..fcb1b859f3 100644 --- a/tutorial/controlflow.po +++ b/tutorial/controlflow.po @@ -47,17 +47,17 @@ msgstr "" #: ../Doc/tutorial/controlflow.rst:33 msgid "" -"There can be zero or more :keyword:`elif` parts, and the :keyword:`else` part " -"is optional. The keyword ':keyword:`!elif`' is short for 'else if', and is " -"useful to avoid excessive indentation. An :keyword:`!if` ... :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." +"There can be zero or more :keyword:`elif` parts, and the :keyword:`else` " +"part is optional. The keyword ':keyword:`!elif`' is short for 'else if', " +"and is useful to avoid excessive indentation. An :keyword:`!if` ... :" +"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:39 msgid "" @@ -66,8 +66,8 @@ msgid "" "statement useful. For more details see :ref:`tut-match`." msgstr "" "Si necesitas comparar un mismo valor con muchas constantes, o comprobar que " -"tenga un tipo o atributos específicos puede que encuentres útil la sentencia :" -"keyword:`!match`. Para más detalles véase :ref:`tut-match`." +"tenga un tipo o atributos específicos puede que encuentres útil la " +"sentencia :keyword:`!match`. Para más detalles véase :ref:`tut-match`." #: ../Doc/tutorial/controlflow.rst:46 msgid ":keyword:`!for` Statements" @@ -75,26 +75,27 @@ msgstr "La sentencia :keyword:`!for`" #: ../Doc/tutorial/controlflow.rst:51 msgid "" -"The :keyword:`for` statement in Python differs a bit from what you may be used " -"to in C or Pascal. Rather than always iterating over an arithmetic " +"The :keyword:`for` statement in Python differs a bit from what you may be " +"used to in C or Pascal. Rather than always iterating over an arithmetic " "progression of numbers (like in Pascal), or giving the user the ability to " -"define both the iteration step and halting condition (as C), Python's :keyword:" -"`!for` statement iterates over the items of any sequence (a list or a string), " -"in the order that they appear in the sequence. For example (no pun intended):" +"define both the iteration step and halting condition (as C), Python's :" +"keyword:`!for` statement iterates over the items of any sequence (a list or " +"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::" +"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:72 msgid "" -"Code that modifies a collection while iterating over that same collection can " -"be tricky to get right. Instead, it is usually more straight-forward to loop " -"over a copy of the collection or to create a new collection::" +"Code that modifies a collection while iterating over that same collection " +"can be tricky to get right. Instead, it is usually more straight-forward to " +"loop over a copy of the collection or to create a new collection::" msgstr "" "Código que modifica una colección mientras se itera sobre la misma colección " "puede ser complejo de hacer bien. Sin embargo, suele ser más directo iterar " @@ -109,15 +110,15 @@ 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::" +"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:108 msgid "" "The given end point is never part of the generated sequence; ``range(10)`` " -"generates 10 values, the legal indices for items of a sequence of length 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')::" +"generates 10 values, the legal indices for items of a sequence of length " +"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 " @@ -127,11 +128,11 @@ msgstr "" #: ../Doc/tutorial/controlflow.rst:122 msgid "" -"To iterate over the indices of a sequence, you can combine :func:`range` and :" -"func:`len` as follows::" +"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í::" +"Para iterar sobre los índices de una secuencia, puedes combinar :func:" +"`range` y :func:`len` así::" #: ../Doc/tutorial/controlflow.rst:135 msgid "" @@ -147,15 +148,15 @@ msgstr "Algo extraño sucede si tan sólo muestras un ``range``::" #: ../Doc/tutorial/controlflow.rst:143 msgid "" -"In many ways the object returned by :func:`range` behaves as if it is a list, " -"but in fact it isn't. It is an object which returns the successive items of " -"the desired sequence when you iterate over it, but it doesn't really make the " -"list, thus saving space." +"In many ways the object returned by :func:`range` behaves as if it is a " +"list, but in fact it isn't. It is an object which returns the successive " +"items of the desired sequence when you iterate over it, but it doesn't " +"really make the list, thus saving space." msgstr "" "El objeto retornado por :func:`range` se comporta de muchas maneras como si " "fuera una lista, pero no lo es. Es un objeto que retorna los ítems sucesivos " -"de la secuencia deseada cuando iteras sobre él, pero realmente no construye la " -"lista, ahorrando entonces espacio." +"de la secuencia deseada cuando iteras sobre él, pero realmente no construye " +"la lista, ahorrando entonces espacio." #: ../Doc/tutorial/controlflow.rst:148 msgid "" @@ -166,10 +167,10 @@ msgid "" "that takes an iterable is :func:`sum`::" msgstr "" "Decimos que tal objeto es :term:`iterable`; esto es, que se 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 una de " -"esas construcciones, mientras que un ejemplo de función que toma un iterable " -"es la función :func:`sum`::" +"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 una de esas construcciones, mientras que un ejemplo de función que " +"toma un iterable es la función :func:`sum`::" #: ../Doc/tutorial/controlflow.rst:157 msgid "" @@ -178,8 +179,8 @@ msgid "" "about :func:`list`." msgstr "" "Más adelante veremos otras funciones que aceptan iterables cómo argumentos o " -"retornan iterables. En el capítulo :ref:`tut-structures`, discutiremos en más " -"detalle sobre la :func:`list`." +"retornan iterables. En el capítulo :ref:`tut-structures`, discutiremos en " +"más detalle sobre la :func:`list`." #: ../Doc/tutorial/controlflow.rst:164 msgid "" @@ -191,8 +192,8 @@ msgstr "" #: ../Doc/tutorial/controlflow.rst:166 msgid "" -"The :keyword:`break` statement breaks out of the innermost enclosing :keyword:" -"`for` or :keyword:`while` loop." +"The :keyword:`break` statement breaks out of the innermost enclosing :" +"keyword:`for` or :keyword:`while` loop." msgstr "" "La sentencia :keyword:`break` termina el bucle :keyword:`for` o :keyword:" "`while` más anidado." @@ -210,56 +211,56 @@ msgid "" "In a :keyword:`for` loop, the :keyword:`!else` clause is executed after the " "loop reaches its final iteration." msgstr "" -"En un bucle :keyword:`for`, la cláusula :keyword:`!else` se ejecuta después de " -"que el bucle alcance su iteración final." +"En un bucle :keyword:`for`, la cláusula :keyword:`!else` se ejecuta después " +"de que el bucle alcance su iteración final." #: ../Doc/tutorial/controlflow.rst:174 msgid "" "In a :keyword:`while` loop, it's executed after the loop's condition becomes " "false." msgstr "" -"En un bucle :keyword:`while`, se ejecuta después de que la condición del bucle " -"se vuelva falsa." +"En un bucle :keyword:`while`, se ejecuta después de que la condición del " +"bucle se vuelva falsa." #: ../Doc/tutorial/controlflow.rst:176 msgid "" -"In either kind of loop, the :keyword:`!else` clause is **not** executed if the " -"loop was terminated by a :keyword:`break`." +"In either kind of loop, the :keyword:`!else` clause is **not** executed if " +"the loop was terminated by a :keyword:`break`." msgstr "" -"En cualquier tipo de bucle, la cláusula :keyword:`!else` **no** se ejecuta si " -"el bucle ha finalizado con :keyword:`break`." +"En cualquier tipo de bucle, la cláusula :keyword:`!else` **no** se ejecuta " +"si el bucle ha finalizado con :keyword:`break`." #: ../Doc/tutorial/controlflow.rst:179 msgid "" -"This is exemplified in the following :keyword:`!for` loop, which searches for " -"prime numbers::" +"This is exemplified in the following :keyword:`!for` loop, which searches " +"for prime numbers::" msgstr "" "Esto se ejemplifica en el siguiente bucle :keyword:`!for`, que busca números " "primos::" #: ../Doc/tutorial/controlflow.rst:200 msgid "" -"(Yes, this is the correct code. Look closely: the ``else`` clause belongs to " -"the :keyword:`for` loop, **not** the :keyword:`if` statement.)" +"(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`.)" +"(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:203 msgid "" "When used with a loop, the ``else`` clause has more in common with the " "``else`` clause of a :keyword:`try` statement than it does with that of :" "keyword:`if` statements: a :keyword:`try` statement's ``else`` clause runs " -"when no exception occurs, and a loop's ``else`` clause runs when no ``break`` " -"occurs. For more on the :keyword:`!try` statement and exceptions, see :ref:" -"`tut-handling`." +"when no exception occurs, and a loop's ``else`` clause runs when no " +"``break`` occurs. For more on the :keyword:`!try` statement and exceptions, " +"see :ref:`tut-handling`." msgstr "" "Cuando se usa con un bucle, la cláusula ``else`` tiene más en común con el " "``else`` de una sentencia :keyword:`try` que con el de un :keyword:`if`: en " "una sentencia :keyword:`try` la cláusula ``else`` se ejecuta cuando no se " "genera ninguna excepción, y el ``else`` de un bucle se ejecuta cuando no hay " -"ningún ``break``. Para más sobre la declaración :keyword:`!try` y excepciones, " -"mira :ref:`tut-handling`." +"ningún ``break``. Para más sobre la declaración :keyword:`!try` y " +"excepciones, mira :ref:`tut-handling`." #: ../Doc/tutorial/controlflow.rst:210 msgid "" @@ -275,12 +276,12 @@ msgstr "La sentencia :keyword:`pass`" #: ../Doc/tutorial/controlflow.rst:233 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::" +"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::" +"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:240 msgid "This is commonly used for creating minimal classes::" @@ -288,14 +289,15 @@ msgstr "Se usa normalmente para crear clases en su mínima expresión::" #: ../Doc/tutorial/controlflow.rst:246 msgid "" -"Another place :keyword:`pass` can be used is as a place-holder for a function " -"or conditional body when you are working on new code, allowing you to keep " -"thinking at a more abstract level. The :keyword:`!pass` is silently ignored::" +"Another place :keyword:`pass` can be used is as a place-holder for a " +"function or conditional body when you are working on new code, allowing you " +"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::" +"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:258 msgid ":keyword:`!match` Statements" @@ -307,21 +309,23 @@ msgid "" "successive patterns given as one or more case blocks. This is superficially " "similar to a switch statement in C, Java or JavaScript (and many other " "languages), but it's more similar to pattern matching in languages like Rust " -"or Haskell. Only the first pattern that matches gets executed and it can also " -"extract components (sequence elements or object attributes) from the value " -"into variables." +"or Haskell. Only the first pattern that matches gets executed and it can " +"also extract components (sequence elements or object attributes) from the " +"value into variables." msgstr "" "Una sentencia :keyword:`match` recibe una expresión y compara su valor con " -"patrones sucesivos dados en uno o más bloques case. Esto es similar a grandes " -"rasgos con una sentencia switch en C, Java o JavaScript (y muchos otros " -"lenguajes) pero es más similar a la comparación de patrones en lenguajes como " -"Rust o Haskell. Sólo se ejecuta el primer patrón que coincide y también es " -"capaz de extraer componentes (elementos de una secuencia o atributos de un " -"objeto) de un valor y ponerlos en variables." +"patrones sucesivos dados en uno o más bloques case. Esto es similar a " +"grandes rasgos con una sentencia switch en C, Java o JavaScript (y muchos " +"otros lenguajes) pero es más similar a la comparación de patrones en " +"lenguajes como Rust o Haskell. Sólo se ejecuta el primer patrón que coincide " +"y también es capaz de extraer componentes (elementos de una secuencia o " +"atributos de un objeto) de un valor y ponerlos en variables." #: ../Doc/tutorial/controlflow.rst:268 -msgid "The simplest form compares a subject value against one or more literals::" -msgstr "La forma más simple compara un valor expuesto con uno o más literales::" +msgid "" +"The simplest form compares a subject value against one or more literals::" +msgstr "" +"La forma más simple compara un valor expuesto con uno o más literales::" #: ../Doc/tutorial/controlflow.rst:281 msgid "" @@ -358,52 +362,53 @@ msgstr "" "¡Observa éste caso con cuidado! El primer patrón tiene dos literales y puede " "considerarse una extensión del patrón literal que se mostró anteriormente. " "Pero los siguientes dos patrones combinan un literal y una variable, y la " -"variable *liga* uno de los elementos del sujeto (``point``). El cuarto patrón " -"captura ambos elementos, lo que lo hace conceptualmente similar a la " +"variable *liga* uno de los elementos del sujeto (``point``). El cuarto " +"patrón captura ambos elementos, lo que lo hace conceptualmente similar a la " "asignación que desempaqueta ``(x, y) = point``." #: ../Doc/tutorial/controlflow.rst:312 msgid "" "If you are using classes to structure your data you can use the class name " -"followed by an argument list resembling a constructor, but with the ability to " -"capture attributes into variables::" +"followed by an argument list resembling a constructor, but with the ability " +"to capture attributes into variables::" msgstr "" -"Si estás usando clases para estructurar tus datos, puedes usar el nombre de la " -"clase seguida de una lista de argumentos similar a la de un constructor, pero " -"con la capacidad de capturar atributos en variables::" +"Si estás usando clases para estructurar tus datos, puedes usar el nombre de " +"la clase seguida de una lista de argumentos similar a la de un constructor, " +"pero con la capacidad de capturar atributos en variables::" #: ../Doc/tutorial/controlflow.rst:334 msgid "" "You can use positional parameters with some builtin classes that provide an " "ordering for their attributes (e.g. dataclasses). You can also define a " -"specific position for attributes in patterns by setting the ``__match_args__`` " -"special attribute in your classes. If it's set to (\"x\", \"y\"), the " -"following patterns are all equivalent (and all bind the ``y`` attribute to the " -"``var`` variable)::" -msgstr "" -"Puedes usar argumentos posicionales en algunas clases incorporadas que proveen " -"un orden para sus atributos (por ej. dataclasses). También puedes definir una " -"posición especifica para los atributos de los patrones si asignas en tu clase " -"el atributo especial ``__match_args__``. Si le asignas (\"x\", \"y\"), los " -"siguientes patrones son todos equivalentes entre sí (y todos ligan el atributo " -"``y`` a la variable ``var``)::" +"specific position for attributes in patterns by setting the " +"``__match_args__`` special attribute in your classes. If it's set to (\"x\", " +"\"y\"), the following patterns are all equivalent (and all bind the ``y`` " +"attribute to the ``var`` variable)::" +msgstr "" +"Puedes usar argumentos posicionales en algunas clases incorporadas que " +"proveen un orden para sus atributos (por ej. dataclasses). También puedes " +"definir una posición especifica para los atributos de los patrones si " +"asignas en tu clase el atributo especial ``__match_args__``. Si le asignas " +"(\"x\", \"y\"), los siguientes patrones son todos equivalentes entre sí (y " +"todos ligan el atributo ``y`` a la variable ``var``)::" #: ../Doc/tutorial/controlflow.rst:345 msgid "" "A recommended way to read patterns is to look at them as an extended form of " -"what you would put on the left of an assignment, to understand which variables " -"would be set to what. Only the standalone names (like ``var`` above) are " -"assigned to by a match statement. Dotted names (like ``foo.bar``), attribute " -"names (the ``x=`` and ``y=`` above) or class names (recognized by the " -"\"(...)\" next to them like ``Point`` above) are never assigned to." -msgstr "" -"Una recomendación para leer patrones es verlos como una forma extendida de lo " -"que pondrías en el lado izquierdo de una asignación, para así entender cuáles " -"variables tomarían qué valores. Sólo los nombres que aparecen por si solos " -"(cómo ``var`` arriba) son asignados por una sentencia match. Nunca se asigna a " -"los nombres con puntos (como ``foo.bar``), nombres de atributos (los ``x=`` e " -"``y=`` arriba) o nombres de clases (reconocidos por los \"(...)\" junto a " -"ellos, como ``Point`` arriba)." +"what you would put on the left of an assignment, to understand which " +"variables would be set to what. Only the standalone names (like ``var`` " +"above) are assigned to by a match statement. Dotted names (like ``foo." +"bar``), attribute names (the ``x=`` and ``y=`` above) or class names " +"(recognized by the \"(...)\" next to them like ``Point`` above) are never " +"assigned to." +msgstr "" +"Una recomendación para leer patrones es verlos como una forma extendida de " +"lo que pondrías en el lado izquierdo de una asignación, para así entender " +"cuáles variables tomarían qué valores. Sólo los nombres que aparecen por si " +"solos (cómo ``var`` arriba) son asignados por una sentencia match. Nunca se " +"asigna a los nombres con puntos (como ``foo.bar``), nombres de atributos " +"(los ``x=`` e ``y=`` arriba) o nombres de clases (reconocidos por los " +"\"(...)\" junto a ellos, como ``Point`` arriba)." #: ../Doc/tutorial/controlflow.rst:352 msgid "" @@ -411,14 +416,14 @@ msgid "" "Points, with ``__match_args__`` added, we could match it like this::" msgstr "" "Los patrones pueden anidarse arbitrariamente. Por ejemplo, si tuviéramos una " -"lista corta de puntos, con ``__match_args__`` añadido, podríamos aplicar match " -"así::" +"lista corta de puntos, con ``__match_args__`` añadido, podríamos aplicar " +"match así::" #: ../Doc/tutorial/controlflow.rst:373 msgid "" -"We can add an ``if`` clause to a pattern, known as a \"guard\". If the guard " -"is false, ``match`` goes on to try the next case block. Note that value " -"capture happens before the guard is evaluated::" +"We can add an ``if`` clause to a pattern, known as a \"guard\". If the " +"guard is false, ``match`` goes on to try the next case block. Note that " +"value capture happens before the guard is evaluated::" msgstr "" "Podemos añadir una clausula ``if`` a un patrón, conocida como \"guarda\". Si " "la guarda es falsa, ``match`` pasa a intentar el siguiente bloque case. " @@ -436,22 +441,22 @@ msgid "" "that they don't match iterators or strings." msgstr "" "Al igual que las asignaciones con desempaquetado, los patrones de lista o " -"tupla tienen exactamente el mismo sentido y realmente coinciden con cualquier " -"secuencia arbitraria. Una excepción importante es que no coinciden ni con " -"iteradores ni con cadenas de caracteres." +"tupla tienen exactamente el mismo sentido y realmente coinciden con " +"cualquier secuencia arbitraria. Una excepción importante es que no coinciden " +"ni con iteradores ni con cadenas de caracteres." #: ../Doc/tutorial/controlflow.rst:389 msgid "" "Sequence patterns support extended unpacking: ``[x, y, *rest]`` and ``(x, y, " -"*rest)`` work similar to unpacking assignments. The name after ``*`` may also " -"be ``_``, so ``(x, y, *_)`` matches a sequence of at least two items without " -"binding the remaining items." +"*rest)`` work similar to unpacking assignments. The name after ``*`` may " +"also be ``_``, so ``(x, y, *_)`` matches a sequence of at least two items " +"without binding the remaining items." msgstr "" "Los patrones de secuencia soportan desempaquetado extendido: ``[x, y, " -"*otros]`` y ``(x, y, *otros)`` funcionan de manera similar a las asignaciones " -"con desempaquetado. El nombre luego de ``*`` también puede ser ``_``, con lo " -"cual ``(x, y, *_)`` coincide con cualquier secuencia de al menos dos " -"elementos, sin ligar ninguno de los demás elementos." +"*otros]`` y ``(x, y, *otros)`` funcionan de manera similar a las " +"asignaciones con desempaquetado. El nombre luego de ``*`` también puede ser " +"``_``, con lo cual ``(x, y, *_)`` coincide con cualquier secuencia de al " +"menos dos elementos, sin ligar ninguno de los demás elementos." #: ../Doc/tutorial/controlflow.rst:394 msgid "" @@ -462,9 +467,9 @@ msgid "" msgstr "" "Los patrones de mapeo: ``{\"ancho_de_banda\": c, \"latencia\": l}`` capturan " "los valores ``\"ancho_de_banda\"`` y ``\"latencia\"`` de un diccionario. A " -"diferencia de los patrones de secuencia, las claves adicionales son ignoradas. " -"Puede usarse un desempaquetado como ``**otros`` . (Aunque ``**_`` sería " -"redundante, con lo cual no está permitido)" +"diferencia de los patrones de secuencia, las claves adicionales son " +"ignoradas. Puede usarse un desempaquetado como ``**otros`` . (Aunque ``**_`` " +"sería redundante, con lo cual no está permitido)" #: ../Doc/tutorial/controlflow.rst:399 msgid "Subpatterns may be captured using the ``as`` keyword::" @@ -488,8 +493,8 @@ msgstr "" #: ../Doc/tutorial/controlflow.rst:409 msgid "" -"Patterns may use named constants. These must be dotted names to prevent them " -"from being interpreted as capture variable::" +"Patterns may use named constants. These must be dotted names to prevent " +"them from being interpreted as capture variable::" msgstr "" "En un patrón pueden usarse constantes con nombres. Los nombres deben tener " "puntos para impedir que sean interpretados como variables a capturar::" @@ -499,8 +504,8 @@ msgid "" "For a more detailed explanation and additional examples, you can look into :" "pep:`636` which is written in a tutorial format." msgstr "" -"Para una explicación más detallada y más ejemplos, puede leerse :pep:`636` que " -"está escrita en un formato de tutorial." +"Para una explicación más detallada y más ejemplos, puede leerse :pep:`636` " +"que está escrita en un formato de tutorial." #: ../Doc/tutorial/controlflow.rst:434 msgid "Defining Functions" @@ -517,9 +522,9 @@ msgstr "" #: ../Doc/tutorial/controlflow.rst:456 msgid "" "The keyword :keyword:`def` introduces a function *definition*. It must be " -"followed by the function name and the parenthesized list of formal parameters. " -"The statements that form the body of the function start at the next line, and " -"must be indented." +"followed by the function name and the parenthesized list of formal " +"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 " @@ -533,71 +538,71 @@ msgid "" "`docstring`. (More about docstrings can be found in the section :ref:`tut-" "docstrings`.) There are tools which use docstrings to automatically produce " "online or printed documentation, or to let the user interactively browse " -"through code; it's good practice to include docstrings in code that you write, " -"so make a habit of it." +"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`. (Puedes 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, así que " -"acostúmbrate a hacerlo." +"función, o :dfn:`docstring`. (Puedes 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, así " +"que acostúmbrate a hacerlo." #: ../Doc/tutorial/controlflow.rst:468 msgid "" -"The *execution* of a function introduces a new symbol table used for the local " -"variables of the function. More precisely, all variable assignments in a " -"function store the value in the local symbol table; whereas variable " +"The *execution* of a function introduces a new symbol table used for the " +"local variables of the function. More precisely, all variable assignments " +"in a function store the value in the local symbol table; whereas variable " "references first look in the local symbol table, then in the local symbol " -"tables of enclosing functions, then in the global symbol table, and finally in " -"the table of built-in names. Thus, global variables and variables of enclosing " -"functions cannot be directly assigned a value within a function (unless, for " -"global variables, named in a :keyword:`global` statement, or, for variables of " -"enclosing functions, named in a :keyword:`nonlocal` 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í, a " -"variables globales y a variables de funciones que engloban a una función no se " -"les puede asignar directamente un valor dentro de una función (a menos que se " -"las nombre en la sentencia :keyword:`global`, o mediante la sentencia :keyword:" -"`nonlocal` para variables de funciones que engloban la función local), aunque " -"si pueden ser referenciadas." +"tables of enclosing functions, then in the global symbol table, and finally " +"in the table of built-in names. Thus, global variables and variables of " +"enclosing functions cannot be directly assigned a value within a function " +"(unless, for global variables, named in a :keyword:`global` statement, or, " +"for variables of enclosing functions, named in a :keyword:`nonlocal` " +"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í, a variables globales y a variables de funciones " +"que engloban a una función no se les puede asignar directamente un valor " +"dentro de una función (a menos que se las nombre en la sentencia :keyword:" +"`global`, o mediante la sentencia :keyword:`nonlocal` para variables de " +"funciones que engloban la función local), aunque si pueden ser referenciadas." #: ../Doc/tutorial/controlflow.rst:479 msgid "" "The actual parameters (arguments) to a function call are introduced in the " "local symbol table of the called function when it is called; thus, arguments " "are passed using *call by value* (where the *value* is always an object " -"*reference*, not the value of the object). [#]_ When a function calls another " -"function, or calls itself recursively, a new local symbol table is created for " -"that call." +"*reference*, not the value of the object). [#]_ When a function calls " +"another function, or calls itself recursively, a new local symbol table is " +"created for that call." msgstr "" "Los parámetros reales (argumentos) para una llamada de función se introducen " -"en la tabla de símbolos local de la función llamada cuando ésta se llama; por " -"lo tanto, los argumentos se pasan usando *llamada por valor* (donde el *valor* " -"es siempre una *referencia* al objeto, no el valor del objeto). [#]_ Cuando " -"una función llama a otra función, o se llama a sí misma de forma recursiva, se " -"crea una nueva tabla de símbolos locales para esa llamada." +"en la tabla de símbolos local de la función llamada cuando ésta se llama; " +"por lo tanto, los argumentos se pasan usando *llamada por valor* (donde el " +"*valor* es siempre una *referencia* al objeto, no el valor del objeto). [#]_ " +"Cuando una función llama a otra función, o se llama a sí misma de forma " +"recursiva, se crea una nueva tabla de símbolos locales para esa llamada." #: ../Doc/tutorial/controlflow.rst:486 msgid "" -"A function definition associates the function name with the function object in " -"the current symbol table. The interpreter recognizes the object pointed to by " -"that name as a user-defined function. Other names can also point to that same " -"function object and can also be used to access the function::" +"A function definition associates the function name with the function object " +"in the current symbol table. The interpreter recognizes the object pointed " +"to by that name as a user-defined function. Other names can also point to " +"that same function object and can also be used to access the function::" msgstr "" "Una definición de función asocia el nombre de la función con el objeto de " "función en la tabla de símbolos actual. El intérprete reconoce el objeto al " -"que apunta ese nombre como una función definida por el usuario. Otros nombres " -"también pueden apuntar a ese mismo objeto de función y también se pueden usar " -"para acceder a la función:" +"que apunta ese nombre como una función definida por el usuario. Otros " +"nombres también pueden apuntar a ese mismo objeto de función y también se " +"pueden usar para acceder a la función:" #: ../Doc/tutorial/controlflow.rst:497 msgid "" @@ -613,9 +618,9 @@ msgstr "" "sino un procedimiento, porque no retorna un valor. De hecho, técnicamente " "hablando, los procedimientos sin :keyword:`return` sí retornan un valor, " "aunque uno bastante 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. Puede verlo si realmente lo desea utilizando :" -"func:`print`::" +"predefinido). El intérprete por lo general no escribe el valor ``None`` si " +"va a ser el único valor escrito. Puede verlo si realmente lo desea " +"utilizando :func:`print`::" #: ../Doc/tutorial/controlflow.rst:508 msgid "" @@ -628,13 +633,14 @@ msgstr "" #: ../Doc/tutorial/controlflow.rst:524 msgid "This example, as usual, demonstrates some new Python features:" msgstr "" -"Este ejemplo, como es usual, demuestra algunas características más de Python::" +"Este ejemplo, como es usual, demuestra algunas características más de " +"Python::" #: ../Doc/tutorial/controlflow.rst:526 msgid "" -"The :keyword:`return` statement returns with a value from a function. :keyword:" -"`!return` without an expression argument returns ``None``. Falling off the end " -"of a function also returns ``None``." +"The :keyword:`return` statement returns with a value from a function. :" +"keyword:`!return` without an expression argument returns ``None``. Falling " +"off the end of a function also returns ``None``." msgstr "" "La sentencia :keyword:`return` retorna un valor en una función. :keyword:`!" "return` sin una expresión como argumento retorna ``None``. Si se alcanza el " @@ -644,25 +650,27 @@ msgstr "" msgid "" "The statement ``result.append(a)`` calls a *method* of the list object " "``result``. A method is a function that 'belongs' to an object and is named " -"``obj.methodname``, where ``obj`` is some object (this may be an expression), " -"and ``methodname`` is the name of a method that is defined by the object's " -"type. Different types define different methods. Methods of different types " -"may have the same name without causing ambiguity. (It is possible to define " -"your own object types and methods, using *classes*, see :ref:`tut-classes`) " -"The method :meth:`!append` shown in the example is defined 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." +"``obj.methodname``, where ``obj`` is some object (this may be an " +"expression), and ``methodname`` is the name of a method that is defined by " +"the object's type. Different types define different methods. Methods of " +"different types may have the same name without causing ambiguity. (It is " +"possible to define your own object types and methods, using *classes*, see :" +"ref:`tut-classes`) The method :meth:`!append` shown in the example is " +"defined 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 tus " -"propios tipos de objetos y métodos, usando *clases*, ver :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." +"``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 tus propios tipos de objetos y métodos, usando *clases*, ver :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:545 msgid "More on Defining Functions" @@ -673,8 +681,8 @@ 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." +"También es posible definir funciones con un número variable de argumentos. " +"Hay tres formas que pueden ser combinadas." #: ../Doc/tutorial/controlflow.rst:554 msgid "Default Argument Values" @@ -682,9 +690,9 @@ msgstr "Argumentos con valores por omisión" #: ../Doc/tutorial/controlflow.rst:556 msgid "" -"The most useful form is to specify a default value for one or more arguments. " -"This creates a function that can be called with fewer arguments than it is " -"defined to allow. For example::" +"The most useful form is to specify a default value for one or more " +"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 " @@ -714,13 +722,13 @@ 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!')``" +"o pasando todos los argumentos: ``ask_ok('OK to overwrite the file?', 2, " +"'Come on, only yes or no!')``" #: ../Doc/tutorial/controlflow.rst:581 msgid "" -"This example also introduces the :keyword:`in` keyword. This tests whether or " -"not a sequence contains a certain value." +"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." @@ -739,16 +747,16 @@ msgstr "imprimirá ``5``." #: ../Doc/tutorial/controlflow.rst:597 msgid "" -"**Important warning:** The default value is evaluated only once. This makes a " -"difference when the default is a mutable object such as a list, dictionary, or " -"instances of most classes. For example, the following function accumulates " -"the arguments passed to it on subsequent calls::" +"**Important warning:** The default value is evaluated only once. This makes " +"a difference when the default is a mutable object such as a list, " +"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::" +"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:610 msgid "This will print ::" @@ -769,21 +777,22 @@ msgstr "Palabras claves como argumentos" #: ../Doc/tutorial/controlflow.rst:631 msgid "" "Functions can also be called using :term:`keyword arguments ` of the form ``kwarg=value``. For instance, the following function::" +"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 " +"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:640 msgid "" "accepts one required argument (``voltage``) and three optional arguments " -"(``state``, ``action``, and ``type``). This function can be called in any of " -"the following ways::" +"(``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::" +"...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:651 msgid "but all the following calls would be invalid::" @@ -793,38 +802,39 @@ msgstr "...pero estas otras llamadas serían todas inválidas::" msgid "" "In a function call, keyword arguments must follow positional arguments. All " "the keyword arguments passed must match one of the arguments accepted by the " -"function (e.g. ``actor`` is not a valid argument for the ``parrot`` function), " -"and their order is not important. This also includes non-optional arguments " -"(e.g. ``parrot(voltage=1000)`` is valid too). No argument may receive a value " -"more than once. Here's an example that fails due to this restriction::" +"function (e.g. ``actor`` is not a valid argument for the ``parrot`` " +"function), and their order is not important. This also includes non-" +"optional arguments (e.g. ``parrot(voltage=1000)`` is valid too). No argument " +"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::" +"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:674 msgid "" -"When a final formal parameter of the form ``**name`` is present, it receives a " -"dictionary (see :ref:`typesmapping`) containing all keyword arguments except " -"for those corresponding to a formal parameter. This may be combined with a " -"formal parameter of the form ``*name`` (described in the next subsection) " -"which receives a :ref:`tuple ` containing the positional arguments " -"beyond the formal parameter list. (``*name`` must occur before ``**name``.) " -"For example, if we define a function like this::" +"When a final formal parameter of the form ``**name`` is present, it receives " +"a dictionary (see :ref:`typesmapping`) containing all keyword arguments " +"except for those corresponding to a formal parameter. This may be combined " +"with a formal parameter of the form ``*name`` (described in the next " +"subsection) which receives a :ref:`tuple ` containing the " +"positional arguments 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 :ref:`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í::" +"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 :ref:`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:691 msgid "It could be called like this::" @@ -840,8 +850,8 @@ msgid "" "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." +"está garantizado para coincidir con el orden en el cual fueron provistos en " +"la llamada a la función." #: ../Doc/tutorial/controlflow.rst:716 msgid "Special parameters" @@ -849,17 +859,18 @@ msgstr "Parámetros especiales" #: ../Doc/tutorial/controlflow.rst:718 msgid "" -"By default, arguments may be passed to a Python function either by position or " -"explicitly by keyword. For readability and performance, it makes sense to " -"restrict the way arguments can be passed so that a developer need only look at " -"the function definition to determine if items are passed by position, by " +"By default, arguments may be passed to a Python function either by position " +"or explicitly by keyword. For readability and performance, it makes sense to " +"restrict the way arguments can be passed so that a developer need only look " +"at the function definition to determine if items are passed by position, by " "position or keyword, or by keyword." msgstr "" "Por defecto, los argumentos pueden enviarse a una función Python o bien por " "posición o explícitamente por clave. Para legibilidad y rendimiento tiene " -"sentido restringir como se pueden enviar los argumentos, así un desarrollador " -"necesitará mirar solamente la definición de la función para determinar si los " -"argumentos se deben enviar por posición, por posición o clave, o por clave." +"sentido restringir como se pueden enviar los argumentos, así un " +"desarrollador necesitará mirar solamente la definición de la función para " +"determinar si los argumentos se deben enviar por posición, por posición o " +"clave, o por clave." #: ../Doc/tutorial/controlflow.rst:724 msgid "A function definition may look like:" @@ -872,9 +883,9 @@ msgid "" "only, positional-or-keyword, and keyword-only. Keyword parameters are also " "referred to as named parameters." msgstr "" -"donde ``/`` y ``*`` son posicionales. Si se utilizan, esos símbolos indican el " -"tipo de parámetro según la forma en que los argumentos deben enviarse a la " -"función: solo por posición (*positional-only*), por posición o clave " +"donde ``/`` y ``*`` son posicionales. Si se utilizan, esos símbolos indican " +"el tipo de parámetro según la forma en que los argumentos deben enviarse a " +"la función: solo por posición (*positional-only*), por posición o clave " "(*positional-or-keyword*) y solo por clave (*keyword-only*). Parámetros por " "clave pueden también denominarse parámetros por nombre o nombrados." @@ -905,13 +916,13 @@ msgid "" "parameters. If there is no ``/`` in the function definition, there are no " "positional-only parameters." msgstr "" -"Mirando esto con un poco más de detalle, es posible señalar algunos parámetros " -"como *únicamente posicionales*. En ese caso el orden de los parámetros es " -"importante, y los parámetros no pueden ser indicados utilizando palabras " -"claves. Parámetros únicamente posicionales son ubicados antes de una ``/`` " -"(barra). La ``/`` es utilizada para separar lógicamente parámetros únicamente " -"posicionales del resto. Si no existe una ``/`` en la definición de la función, " -"no existen parámetros únicamente posicionales." +"Mirando esto con un poco más de detalle, es posible señalar algunos " +"parámetros como *únicamente posicionales*. En ese caso el orden de los " +"parámetros es importante, y los parámetros no pueden ser indicados " +"utilizando palabras claves. Parámetros únicamente posicionales son ubicados " +"antes de una ``/`` (barra). La ``/`` es utilizada para separar lógicamente " +"parámetros únicamente posicionales del resto. Si no existe una ``/`` en la " +"definición de la función, no existen parámetros únicamente posicionales." #: ../Doc/tutorial/controlflow.rst:759 msgid "" @@ -927,13 +938,14 @@ msgstr "Argumentos únicamente de palabras clave" #: ../Doc/tutorial/controlflow.rst:765 msgid "" -"To mark parameters as *keyword-only*, indicating the parameters must be passed " -"by keyword argument, place an ``*`` in the arguments list just before the " -"first *keyword-only* parameter." +"To mark parameters as *keyword-only*, indicating the parameters must be " +"passed by keyword argument, place an ``*`` in the arguments list just before " +"the first *keyword-only* parameter." msgstr "" -"Para señalar parámetros como *unicamente de palabras clave*, indicando que los " -"parámetros deben ser pasados con una palabra clave, indiqué un ``*`` en la " -"lista de argumentos antes del primer parámetro *únicamente de palabras clave*." +"Para señalar parámetros como *unicamente de palabras clave*, indicando que " +"los parámetros deben ser pasados con una palabra clave, indiqué un ``*`` en " +"la lista de argumentos antes del primer parámetro *únicamente de palabras " +"clave*." #: ../Doc/tutorial/controlflow.rst:771 msgid "Function Examples" @@ -941,11 +953,11 @@ msgstr "Ejemplos de Funciones" #: ../Doc/tutorial/controlflow.rst:773 msgid "" -"Consider the following example function definitions paying close attention to " -"the markers ``/`` and ``*``::" +"Consider the following example function definitions paying close attention " +"to the markers ``/`` and ``*``::" msgstr "" -"Considere el siguiente ejemplo de definiciones de funciones prestando especial " -"atención a los marcadores ``/`` y ``*``::" +"Considere el siguiente ejemplo de definiciones de funciones prestando " +"especial atención a los marcadores ``/`` y ``*``::" #: ../Doc/tutorial/controlflow.rst:789 msgid "" @@ -984,12 +996,12 @@ msgstr "" #: ../Doc/tutorial/controlflow.rst:841 msgid "" "Finally, consider this function definition which has a potential collision " -"between the positional argument ``name`` and ``**kwds`` which has ``name`` as " -"a key::" +"between the positional argument ``name`` and ``**kwds`` which has ``name`` " +"as a key::" msgstr "" "Finalmente, considere esta definición de función que contiene una colisión " -"potencial entre los parámetros posicionales ``name`` y ``**kwds`` que incluye " -"``name`` como una clave::" +"potencial entre los parámetros posicionales ``name`` y ``**kwds`` que " +"incluye ``name`` como una clave::" #: ../Doc/tutorial/controlflow.rst:846 msgid "" @@ -1005,9 +1017,9 @@ msgid "" "``name`` as a positional argument and ``'name'`` as a key in the keyword " "arguments::" msgstr "" -"Pero utilizando ``/`` (parámetros únicamente posicionales), es posible ya que " -"permite utilizar ``name`` como un parámetro posicional y ``name`` como un " -"parámetro de palabras clave::" +"Pero utilizando ``/`` (parámetros únicamente posicionales), es posible ya " +"que permite utilizar ``name`` como un parámetro posicional y ``name`` como " +"un parámetro de palabras clave::" #: ../Doc/tutorial/controlflow.rst:863 msgid "" @@ -1035,10 +1047,11 @@ msgstr "A modo de guía:" #: ../Doc/tutorial/controlflow.rst:876 msgid "" -"Use positional-only if you want the name of the parameters to not be available " -"to the user. This is useful when parameter names have no real meaning, if you " -"want to enforce the order of the arguments when the function is called or if " -"you need to take some positional parameters and arbitrary keywords." +"Use positional-only if you want the name of the parameters to not be " +"available to the user. This is useful when parameter names have no real " +"meaning, if you want to enforce the order of the arguments when the function " +"is called or if you need to take some positional parameters and arbitrary " +"keywords." msgstr "" "Utilice únicamente posicionales si quiere que el nombre del parámetro esté " "disponible para el usuario. Esto es útil cuando el nombre del parámetro no " @@ -1071,10 +1084,10 @@ msgstr "Listas de argumentos arbitrarios" #: ../Doc/tutorial/controlflow.rst:895 msgid "" -"Finally, the least frequently used option is to specify that a function can be " -"called with an arbitrary number of arguments. These arguments will be wrapped " -"up in a tuple (see :ref:`tut-tuples`). Before the variable number of " -"arguments, zero or more normal arguments may occur. ::" +"Finally, the least frequently used option is to specify that a function can " +"be called with an arbitrary number of arguments. These arguments will be " +"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 " @@ -1086,15 +1099,15 @@ msgstr "" msgid "" "Normally, these *variadic* arguments will be last in the list of formal " "parameters, because they scoop up all remaining input arguments that are " -"passed to the function. Any formal parameters which occur after the ``*args`` " -"parameter are 'keyword-only' arguments, meaning that they can only be used as " -"keywords rather than positional arguments. ::" +"passed to the function. Any formal parameters which occur after the " +"``*args`` parameter are 'keyword-only' arguments, meaning that they can only " +"be used as keywords rather than positional arguments. ::" msgstr "" "Normalmente estos argumentos *variádicos* serán 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 de " -"palabra clave', o sea que sólo se pueden usar como argumentos nombrados y no " -"como posicionales. ::" +"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 de palabra clave', o sea que sólo se pueden usar como argumentos " +"nombrados y no como posicionales. ::" #: ../Doc/tutorial/controlflow.rst:921 msgid "Unpacking Argument Lists" @@ -1102,20 +1115,20 @@ msgstr "Desempaquetando una lista de argumentos" #: ../Doc/tutorial/controlflow.rst:923 msgid "" -"The reverse situation occurs when the arguments are already in a list or tuple " -"but need to be unpacked for a function call requiring separate positional " -"arguments. For instance, the built-in :func:`range` function expects separate " -"*start* and *stop* arguments. If they are not available separately, write the " -"function call with the ``*``\\ -operator to unpack the arguments out of a " -"list or tuple::" +"The reverse situation occurs when the arguments are already in a list or " +"tuple but need to be unpacked for a function call requiring separate " +"positional arguments. For instance, the built-in :func:`range` function " +"expects separate *start* and *stop* arguments. If they are not available " +"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 parámetros *inicio* y *fin*. Si estos 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::" +"predefinida :func:`range` espera los parámetros *inicio* y *fin*. Si estos " +"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:939 msgid "" @@ -1133,25 +1146,25 @@ msgstr "Expresiones lambda" msgid "" "Small anonymous functions can be created with the :keyword:`lambda` keyword. " "This function returns the sum of its two arguments: ``lambda a, b: a+b``. " -"Lambda functions can be used wherever function objects are required. They are " -"syntactically restricted to a single expression. Semantically, they are just " -"syntactic sugar for a normal function definition. Like nested function " +"Lambda functions can be used wherever function objects are required. They " +"are syntactically restricted to a single expression. Semantically, they are " +"just syntactic sugar for a normal function definition. Like nested function " "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::" +"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:974 msgid "" -"The above example uses a lambda expression to return a function. Another use " -"is to pass a small function as an argument::" +"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 ::" @@ -1172,21 +1185,21 @@ msgstr "" msgid "" "The first line should always be a short, concise summary of the object's " "purpose. For brevity, it should not explicitly state the object's name or " -"type, since these are available by other means (except if the name happens to " -"be a verb describing a function's operation). This line should begin with a " -"capital letter and end with a period." +"type, since these are available by other means (except if the name happens " +"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." +"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:1002 msgid "" -"If there are more lines in the documentation string, the second line should be " -"blank, visually separating the summary from the rest of the description. The " -"following lines should be one or more paragraphs describing the object's " +"If there are more lines in the documentation string, the second line should " +"be blank, visually separating the summary from the rest of the description. " +"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 " @@ -1199,27 +1212,28 @@ msgid "" "The Python parser does not strip indentation from multi-line string literals " "in Python, so tools that process documentation have to strip indentation if " "desired. This is done using the following convention. The first non-blank " -"line *after* the first line of the string determines the amount of indentation " -"for the entire documentation string. (We can't use the first line since it is " -"generally adjacent to the string's opening quotes so its indentation is not " -"apparent in the string literal.) Whitespace \"equivalent\" to this " -"indentation is then stripped from the start of all lines of the string. Lines " -"that are indented less should not occur, but if they occur 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)." +"line *after* the first line of the string determines the amount of " +"indentation for the entire documentation string. (We can't use the first " +"line since it is generally adjacent to the string's opening quotes so its " +"indentation is not apparent in the string literal.) Whitespace " +"\"equivalent\" to this indentation is then stripped from the start of all " +"lines of the string. Lines that are indented less should not occur, but if " +"they occur 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:1019 msgid "Here is an example of a multi-line docstring::" @@ -1242,23 +1256,23 @@ msgstr "" #: ../Doc/tutorial/controlflow.rst:1049 msgid "" ":term:`Annotations ` are stored in the :attr:`!" -"__annotations__` attribute of the function as a dictionary and have no effect " -"on any other part of the function. Parameter annotations are defined by a " -"colon after the parameter name, followed by an expression evaluating to the " -"value of the annotation. Return annotations are defined by a literal ``->``, " -"followed by an expression, between the parameter list and the colon denoting " -"the end of the :keyword:`def` statement. The following example has a required " -"argument, an optional argument, and the return value annotated::" +"__annotations__` attribute of the function as a dictionary and have no " +"effect on any other part of the function. Parameter annotations are defined " +"by a colon after the parameter name, followed by an expression evaluating to " +"the value of the annotation. Return annotations are defined by a literal ``-" +">``, followed by an expression, between the parameter list and the colon " +"denoting the end of the :keyword:`def` statement. The following example has " +"a required argument, an optional 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::" +"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:1071 msgid "Intermezzo: Coding Style" @@ -1266,30 +1280,30 @@ msgstr "Intermezzo: Estilo de programación" #: ../Doc/tutorial/controlflow.rst:1076 msgid "" -"Now that you are about to write longer, more complex pieces of Python, it is a " -"good time to talk about *coding style*. Most languages can be written (or " +"Now that you are about to write longer, more complex pieces of Python, it is " +"a good time to talk about *coding style*. Most languages can be written (or " "more concise, *formatted*) in different styles; some are more readable than " -"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." +"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 programació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 programación ayuda tremendamente a lograrlo." +"código sea más fácil de leer por otros es siempre una buena idea, y adoptar " +"un buen estilo de programación ayuda tremendamente a lograrlo." #: ../Doc/tutorial/controlflow.rst:1082 msgid "" -"For Python, :pep:`8` has emerged as the style guide that most projects adhere " -"to; it promotes a very readable and eye-pleasing coding style. Every Python " -"developer should read it at some point; here are the most important points " -"extracted for you:" +"For Python, :pep:`8` has emerged as the style guide that most projects " +"adhere to; it promotes a very readable and eye-pleasing coding style. Every " +"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 programació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::" +"Para Python, :pep:`8` se erigió como la guía de estilo a la que más " +"proyectos adhirieron; promueve un estilo de programació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:1087 msgid "Use 4-space indentation, and no tabs." @@ -1361,8 +1375,8 @@ msgid "" "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." +"internacionales. El default de Python, UTF-8, o incluso ASCII plano " +"funcionan bien en la mayoría de los casos." #: ../Doc/tutorial/controlflow.rst:1117 msgid "" @@ -1370,9 +1384,9 @@ 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." +"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:1123 msgid "Footnotes" @@ -1380,14 +1394,14 @@ msgstr "Notas al pie" #: ../Doc/tutorial/controlflow.rst:1124 msgid "" -"Actually, *call by object reference* would be a better description, since if a " -"mutable object is passed, the caller will see any changes the callee makes to " -"it (items inserted into a list)." +"Actually, *call by object reference* would be a better description, since if " +"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)." +"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)." #: ../Doc/tutorial/controlflow.rst:48 msgid "statement" @@ -1452,12 +1466,13 @@ msgstr "style" #~ msgid "" #~ "Loop statements may have an :keyword:`!else` clause; it is executed when " #~ "the loop terminates through exhaustion of the iterable (with :keyword:" -#~ "`for`) or when the condition becomes false (with :keyword:`while`), but not " -#~ "when the loop is terminated by a :keyword:`break` statement. This is " +#~ "`for`) or when the condition becomes false (with :keyword:`while`), but " +#~ "not when the loop is terminated by a :keyword:`break` statement. This is " #~ "exemplified by the following loop, which searches for prime numbers::" #~ msgstr "" #~ "Las sentencias de bucle pueden tener una cláusula :keyword:`!else` que es " #~ "ejecutada cuando el bucle termina, después de agotar el iterable (con :" -#~ "keyword:`for`) o cuando la condición se hace falsa (con :keyword:`while`), " -#~ "pero no cuando el bucle se termina con la sentencia :keyword:`break`. Se " -#~ "puede ver el ejemplo en el siguiente bucle, que busca números primos::" +#~ "keyword:`for`) o cuando la condición se hace falsa (con :keyword:" +#~ "`while`), pero no cuando el bucle se termina con la sentencia :keyword:" +#~ "`break`. Se puede ver el ejemplo en el siguiente bucle, que busca números " +#~ "primos::"