controlflow.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2019, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2019-05-06 11:59-0400\n"
"PO-Revision-Date: 2019-12-22 12:00+0100\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"Last-Translator: \n"
"Language-Team: es\n"
"Language: es_ES\n"
"X-Generator: Poedit 2.2.4\n"

#: ../Doc/tutorial/controlflow.rst:5
msgid "More Control Flow Tools"
msgstr "Más herramientas para control de flujo"

#: ../Doc/tutorial/controlflow.rst:7
msgid ""
"Besides the :keyword:`while` statement just introduced, Python knows the "
"usual control flow statements known from other languages, with some twists."
msgstr ""
"Además de la sentencia :keyword:`while` que acabamos de introducir, Python "
"soporta las sentencias de control de flujo que podemos encontrar en otros "
"lenguajes, con algunos cambios."

#: ../Doc/tutorial/controlflow.rst:14
msgid ":keyword:`!if` Statements"
msgstr "La sentencia :keyword:`!if`"

#: ../Doc/tutorial/controlflow.rst:16
msgid ""
"Perhaps the most well-known statement type is the :keyword:`if` statement.  "
"For example::"
msgstr ""
"Tal vez el tipo más conocido de sentencia sea el :keyword:`if`. Por ejemplo::"

#: ../Doc/tutorial/controlflow.rst:33
msgid ""
"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:43
msgid ":keyword:`!for` Statements"
msgstr "La sentencia :keyword:`!for`"

#: ../Doc/tutorial/controlflow.rst:48
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 "
"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):"
msgstr ""
"La sentencia :keyword:`for` en Python difiere un poco de lo que uno puede "
"estar acostumbrado en lenguajes como C o Pascal. En lugar de siempre iterar "
"sobre una progresión aritmética de números (como en Pascal) o darle al "
"usuario la posibilidad de definir tanto el paso de la iteración como la "
"condición de fin (como en C), la sentencia :keyword:`!for` de Python itera "
"sobre los ítems de cualquier secuencia (una lista o una cadena de texto), en "
"el orden que aparecen en la secuencia. Por ejemplo::"

#: ../Doc/tutorial/controlflow.rst:69
msgid ""
"If you need to modify the sequence you are iterating over while inside the "
"loop (for example to duplicate selected items), it is recommended that you "
"first make a copy.  Iterating over a sequence does not implicitly make a "
"copy.  The slice notation makes this especially convenient::"
msgstr ""
"Si necesitas modificar la secuencia sobre la que estás iterando mientras "
"estás adentro del ciclo (por ejemplo para borrar algunos ítems), se "
"recomienda que hagas primero una copia. Iterar sobre una secuencia no hace "
"implícitamente una copia. La notación de rebanada es especialmente "
"conveniente para esto::"

#: ../Doc/tutorial/controlflow.rst:81
msgid ""
"With ``for w in words:``, the example would attempt to create an infinite "
"list, inserting ``defenestrate`` over and over again."
msgstr ""
"Con ``for w in words:``, el ejemplo intentaría crear una lista infinita, "
"insertando ``defenestrate`` una y otra vez."

#: ../Doc/tutorial/controlflow.rst:88
msgid "The :func:`range` Function"
msgstr "La función :func:`range`"

#: ../Doc/tutorial/controlflow.rst:90
msgid ""
"If you do need to iterate over a sequence of numbers, the built-in function :"
"func:`range` comes in handy.  It generates arithmetic progressions::"
msgstr ""
"Si se necesita iterar sobre una secuencia de números, es apropiado utilizar "
"la función integrada :func:`range`, la cual genera progresiones aritméticas::"

#: ../Doc/tutorial/controlflow.rst:102
msgid ""
"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')::"
msgstr ""
"El valor final dado nunca es parte de la secuencia; ``range(10)`` genera 10 "
"valores, los índices correspondientes para los ítems de una secuencia de "
"longitud 10. Es posible hacer que el rango empiece con otro número, o "
"especificar un incremento diferente (incluso negativo; algunas veces se lo "
"llama 'paso')::"

#: ../Doc/tutorial/controlflow.rst:116
msgid ""
"To iterate over the indices of a sequence, you can combine :func:`range` "
"and :func:`len` as follows::"
msgstr ""
"Para iterar sobre los índices de una secuencia, puedes combinar :func:"
"`range` y :func:`len` así::"

#: ../Doc/tutorial/controlflow.rst:129
msgid ""
"In most such cases, however, it is convenient to use the :func:`enumerate` "
"function, see :ref:`tut-loopidioms`."
msgstr ""
"En la mayoría de los casos, sin embargo, conviene usar la función :func:"
"`enumerate`, mira :ref:`tut-loopidioms`."

#: ../Doc/tutorial/controlflow.rst:132
msgid "A strange thing happens if you just print a range::"
msgstr "Algo extraño sucede si muestras un `\t`range``::"

#: ../Doc/tutorial/controlflow.rst:137
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."
msgstr ""
"De muchas maneras el objeto devuelto por :func:`range` se comporta como si "
"fuera una lista, pero no lo es. Es un objeto que devuelve los ítems "
"sucesivos de la secuencia deseada cuando iteras sobre él, pero realmente no "
"construye la lista, ahorrando entonces espacio."

#: ../Doc/tutorial/controlflow.rst:142
msgid ""
"We say such an object is *iterable*, that is, suitable as a target for "
"functions and constructs that expect something from which they can obtain "
"successive items until the supply is exhausted. We have seen that the :"
"keyword:`for` statement is such an *iterator*. The function :func:`list` is "
"another; it creates lists from iterables::"
msgstr ""
"Decimos que tal objeto es *iterable*; esto es, que se lo puede usar en "
"funciones y construcciones que esperan algo de lo cual obtener ítems "
"sucesivos hasta que se termine. Hemos visto que la declaración :keyword:"
"`for` es un iterador en ese sentido. La función :func:`list` es otra; crea "
"listas a partir de iterables::"

#: ../Doc/tutorial/controlflow.rst:152
msgid ""
"Later we will see more functions that return iterables and take iterables as "
"argument."
msgstr ""
"Más tarde veremos más funciones que devuelven iterables y que toman "
"iterables como entrada."

#: ../Doc/tutorial/controlflow.rst:158
msgid ""
":keyword:`!break` and :keyword:`!continue` Statements, and :keyword:`!else` "
"Clauses on Loops"
msgstr ""
"Las sentencias :keyword:`break`, :keyword:`continue`, y :keyword:`else` en "
"lazos"

#: ../Doc/tutorial/controlflow.rst:160
msgid ""
"The :keyword:`break` statement, like in C, breaks out of the innermost "
"enclosing :keyword:`for` or :keyword:`while` loop."
msgstr ""
"La sentencia :keyword:`break`, como en C, termina el lazo :keyword:`for` o :"
"keyword:`while` más anidado."

#: ../Doc/tutorial/controlflow.rst:163
msgid ""
"Loop statements may have an :keyword:`!else` clause; it is executed when the "
"loop terminates through exhaustion of the list (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 exemplified by the "
"following loop, which searches for prime numbers::"
msgstr ""
"Las sentencias de lazo pueden tener una cláusula`!else` que es ejecutada "
"cuando el lazo termina, luego de agotar la lista (con :keyword:`for`) o "
"cuando la condición se hace falsa (con :keyword:`while`), pero no cuando el "
"lazo es terminado con la sentencia :keyword:`break`. Se ejemplifica en el "
"siguiente lazo, que busca números primos::"

#: ../Doc/tutorial/controlflow.rst:187
msgid ""
"(Yes, this is the correct code.  Look closely: the ``else`` clause belongs "
"to the :keyword:`for` loop, **not** the :keyword:`if` statement.)"
msgstr ""
"(Sí, este es el código correcto. Fíjate bien: el ``else`` pertenece al "
"ciclo :keyword:`for`, no al :keyword:`if`.)"

#: ../Doc/tutorial/controlflow.rst:190
msgid ""
"When used with a loop, the ``else`` clause has more in common with the "
"``else`` clause of a :keyword:`try` statement than it does 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`."
msgstr ""
"Cuando se usa con un ciclo, el ``else`` tiene más en común con el ``else`` "
"de una declaración :keyword:`try` que con el de un :keyword:`if`: el "
"``else`` de un :keyword:`!try` se ejecuta cuando no se genera ninguna "
"excepción, y el ``else`` de un ciclo se ejecuta cuando no hay ningún "
"``break``. Para más sobre la declaración :keyword:`!try` y excepciones, "
"mira :ref:`tut-handling`."

#: ../Doc/tutorial/controlflow.rst:197
msgid ""
"The :keyword:`continue` statement, also borrowed from C, continues with the "
"next iteration of the loop::"
msgstr ""
"La declaración :keyword:`continue`, también tomada de C, continua con la "
"siguiente iteración del ciclo::"

#: ../Doc/tutorial/controlflow.rst:217
msgid ":keyword:`!pass` Statements"
msgstr "La sentencia :keyword:`pass`"

#: ../Doc/tutorial/controlflow.rst:219
msgid ""
"The :keyword:`pass` statement does nothing. It can be used when a statement "
"is required syntactically but the program requires no action. For example::"
msgstr ""
"La sentencia :keyword:`pass` no hace nada. Se puede usar cuando una "
"sentencia es requerida por la sintaxis pero el programa no requiere ninguna "
"acción. Por ejemplo::"

#: ../Doc/tutorial/controlflow.rst:226
msgid "This is commonly used for creating minimal classes::"
msgstr "Se usa normalmente para crear clases en su mínima expresión::"

#: ../Doc/tutorial/controlflow.rst:232
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::"
msgstr ""
"Otro lugar donde se puede usar :keyword:`pass` es como una marca de lugar "
"para una función o un cuerpo condicional cuando estás trabajando en código "
"nuevo, lo cual te permite pensar a un nivel de abstracción mayor. El :"
"keyword:`!pass` se ignora silenciosamente::"

#: ../Doc/tutorial/controlflow.rst:243
msgid "Defining Functions"
msgstr "Definiendo funciones"

#: ../Doc/tutorial/controlflow.rst:245
msgid ""
"We can create a function that writes the Fibonacci series to an arbitrary "
"boundary::"
msgstr ""
"Podemos crear una función que escriba la serie de Fibonacci hasta un límite "
"determinado::"

#: ../Doc/tutorial/controlflow.rst:265
msgid ""
"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."
msgstr ""
"La palabra reservada :keyword:`def` se usa para definir funciones. Debe "
"seguirle el nombre de la función y la lista de parámetros formales entre "
"paréntesis. Las sentencias que forman el cuerpo de la función empiezan en la "
"línea siguiente, y deben estar con sangría."

#: ../Doc/tutorial/controlflow.rst:270
msgid ""
"The first statement of the function body can optionally be a string literal; "
"this string literal is the function's documentation string, or :dfn:"
"`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."
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, y "
"hacerlo un buen hábito."

#: ../Doc/tutorial/controlflow.rst:277
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 "
"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 cannot be directly "
"assigned a value within a function (unless named in a :keyword:`global` "
"statement), although they may be referenced."
msgstr ""
"La *ejecución* de una función introduce una nueva tabla de símbolos usada "
"para las variables locales de la función. Más precisamente, todas las "
"asignaciones de variables en la función almacenan el valor en la tabla de "
"símbolos local; así mismo la referencia a variables primero mira la tabla de "
"símbolos local, luego en la tabla de símbolos local de las funciones "
"externas, luego la tabla de símbolos global, y finalmente la tabla de "
"nombres predefinidos. Así, no se les puede asignar directamente un valor a "
"las variables globales dentro de una función (a menos se las nombre en la "
"sentencia :keyword:`global`), aunque si pueden ser referenciadas."

#: ../Doc/tutorial/controlflow.rst:286
msgid ""
"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, a new local symbol table is created for that call."
msgstr ""
"Los parámetros reales (argumentos) de una función se introducen en la tabla "
"de símbolos local de la función llamada cuando esta es ejecutada; así, los "
"argumentos son pasados por valor (dónde el valor es siempre una referencia a "
"un objeto, no el valor del objeto). [#]_ Cuando una función llama a otra "
"función, una nueva tabla de símbolos local es creada para esa llamada."

#: ../Doc/tutorial/controlflow.rst:292
msgid ""
"A function definition introduces the function name in the current symbol "
"table. The value of the function name has a type that is recognized by the "
"interpreter as a user-defined function.  This value can be assigned to "
"another name which can then also be used as a function.  This serves as a "
"general renaming mechanism::"
msgstr ""
"La definición de una función introduce el nombre de la función en la tabla "
"de símbolos actual. El valor del nombre de la función tiene un tipo que es "
"reconocido por el interprete como una función definida por el usuario. Este "
"valor puede ser asignado a otro nombre que luego puede ser usado como una "
"función. Esto sirve como un mecanismo general para renombrar::"

#: ../Doc/tutorial/controlflow.rst:304
msgid ""
"Coming from other languages, you might object that ``fib`` is not a function "
"but a procedure since it doesn't return a value.  In fact, even functions "
"without a :keyword:`return` statement do return a value, albeit a rather "
"boring one.  This value is called ``None`` (it's a built-in name).  Writing "
"the value ``None`` is normally suppressed by the interpreter if it would be "
"the only value written. You can see it if you really want to using :func:"
"`print`::"
msgstr ""
"Viniendo de otros lenguajes, puedes objetar que ``fib`` no es una función, "
"sino un procedimiento, porque no devuelve un valor. De hecho, técnicamente "
"hablando, los procedimientos sin :keyword:`return` sí retornan un valor, "
"aunque uno aburrido. Este valor se llama ``None`` (es un nombre "
"predefinido). El intérprete por lo general no escribe el valor ``None`` si "
"va a ser el único valor escrito. Si realmente se quiere, se puede verlo "
"usando la función :func:`print` ::"

#: ../Doc/tutorial/controlflow.rst:315
msgid ""
"It is simple to write a function that returns a list of the numbers of the "
"Fibonacci series, instead of printing it::"
msgstr ""
"Es simple escribir una función que retorne una lista con los números de la "
"serie de Fibonacci en lugar de imprimirlos::"

#: ../Doc/tutorial/controlflow.rst:331
msgid "This example, as usual, demonstrates some new Python features:"
msgstr ""
"Este ejemplo, como es usual, demuestra algunas características más de "
"Python::"

#: ../Doc/tutorial/controlflow.rst:333
msgid ""
"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` devuelve un valor en una función. :keyword:`!"
"return` sin una expresión como argumento retorna ``None``. Si se alcanza el "
"final de una función, también se retorna ``None``."

#: ../Doc/tutorial/controlflow.rst:337
msgid ""
"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 "
"``result``. Un método es una función que 'pertenece' a un objeto y se nombra "
"``obj.methodname``, dónde ``obj`` es algún objeto (puede ser una expresión), "
"y ``methodname`` es el nombre del método que está definido por el tipo del "
"objeto. Distintos tipos definen distintos métodos. Métodos de diferentes "
"tipos pueden tener el mismo nombre sin causar ambigüedad. (Es posible "
"definir tipos de objetos propios, y métodos, usando clases, mira :ref:`tut-"
"classes`). El método :meth:`append` mostrado en el ejemplo está definido "
"para objetos lista; añade un nuevo elemento al final de la lista. En este "
"ejemplo es equivalente a ``result = result + [a]``, pero más eficiente."

#: ../Doc/tutorial/controlflow.rst:352
msgid "More on Defining Functions"
msgstr "Más sobre definición de funciones"

#: ../Doc/tutorial/controlflow.rst:354
msgid ""
"It is also possible to define functions with a variable number of arguments. "
"There are three forms, which can be combined."
msgstr ""
"También es posible definir funciones con un número variable de argumentos. "
"Hay tres formas que pueden ser combinadas."

#: ../Doc/tutorial/controlflow.rst:361
msgid "Default Argument Values"
msgstr "Argumentos con valores por omisión"

#: ../Doc/tutorial/controlflow.rst:363
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::"
msgstr ""
"La forma más útil es especificar un valor por omisión para uno o más "
"argumentos. Esto crea una función que puede ser llamada con menos argumentos "
"que los que permite. Por ejemplo::"

#: ../Doc/tutorial/controlflow.rst:379
msgid "This function can be called in several ways:"
msgstr "Esta función puede ser llamada de distintas maneras::"

#: ../Doc/tutorial/controlflow.rst:381
msgid ""
"giving only the mandatory argument: ``ask_ok('Do you really want to quit?')``"
msgstr ""
"pasando sólo el argumento obligatorio: ``ask_ok('Do you really want to "
"quit?')``"

#: ../Doc/tutorial/controlflow.rst:383
msgid ""
"giving one of the optional arguments: ``ask_ok('OK to overwrite the file?', "
"2)``"
msgstr ""
"pasando uno de los argumentos opcionales: ``ask_ok('OK to overwrite the "
"file?', 2)``"

#: ../Doc/tutorial/controlflow.rst:385
msgid ""
"or even giving all arguments: ``ask_ok('OK to overwrite the file?', 2, 'Come "
"on, only yes or no!')``"
msgstr ""
"o pasando todos los argumentos: ``ask_ok('OK to overwrite the file?', 2, "
"'Come on, only yes or no!')``"

#: ../Doc/tutorial/controlflow.rst:388
msgid ""
"This example also introduces the :keyword:`in` keyword. This tests whether "
"or not a sequence contains a certain value."
msgstr ""
"Este ejemplo también introduce la palabra reservada :keyword:`in`, la cual "
"prueba si una secuencia contiene o no un determinado valor."

#: ../Doc/tutorial/controlflow.rst:391
msgid ""
"The default values are evaluated at the point of function definition in the "
"*defining* scope, so that ::"
msgstr ""
"Los valores por omisión son evaluados en el momento de la definición de la "
"función, en el ámbito de la definición, entonces::"

#: ../Doc/tutorial/controlflow.rst:402
msgid "will print ``5``."
msgstr "...imprimirá ```5``."

#: ../Doc/tutorial/controlflow.rst:404
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::"
msgstr ""
"**Advertencia importante:** El valor por omisión es evaluado solo una vez. "
"Existe una diferencia cuando el valor por omisión es un objeto mutable como "
"una lista, diccionario, o instancia de la mayoría de las clases. Por "
"ejemplo, la siguiente función acumula los argumentos que se le pasan en "
"subsiguientes llamadas::"

#: ../Doc/tutorial/controlflow.rst:417
msgid "This will print ::"
msgstr "Imprimirá ::"

#: ../Doc/tutorial/controlflow.rst:423
msgid ""
"If you don't want the default to be shared between subsequent calls, you can "
"write the function like this instead::"
msgstr ""
"Si no se quiere que el valor por omisión sea compartido entre subsiguientes "
"llamadas, se pueden escribir la función así::"

#: ../Doc/tutorial/controlflow.rst:436
msgid "Keyword Arguments"
msgstr "Palabras claves como argumentos"

#: ../Doc/tutorial/controlflow.rst:438
msgid ""
"Functions can also be called using :term:`keyword arguments <keyword "
"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 <keyword argument>` (o argumentos nombrados) de la forma "
"``kwarg=value``. Por ejemplo, la siguiente función::"

#: ../Doc/tutorial/controlflow.rst:447
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::"
msgstr ""
"...acepta un argumento obligatorio (``voltage``)) y tres argumentos "
"opcionales (``state``, ``action``, y ``type``). Esta función puede llamarse "
"de cualquiera de las siguientes maneras::"

#: ../Doc/tutorial/controlflow.rst:458
msgid "but all the following calls would be invalid::"
msgstr "...pero estas otras llamadas serían todas inválidas::"

#: ../Doc/tutorial/controlflow.rst:465
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::"
msgstr ""
"En una llamada a una función, los argumentos nombrados deben seguir a los "
"argumentos posicionales. Cada uno de los argumentos nombrados pasados deben "
"coincidir con un argumento aceptado por la función (por ejemplo, ``actor`` "
"no es un argumento válido para la función ``parrot``), y el orden de los "
"mismos no es importante. Esto también se aplica a los argumentos "
"obligatorios (por ejemplo, ``parrot(voltage=1000)`` también es válido). "
"Ningún argumento puede recibir más de un valor al mismo tiempo. Aquí hay un "
"ejemplo que falla debido a esta restricción::"

#: ../Doc/tutorial/controlflow.rst:481
msgid ""
"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 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 tupla "
"conteniendo los argumentos posicionales además de la lista de parámetros "
"formales. (``*nombre`` debe ocurrir antes de ``**nombre``). Por ejemplo, si "
"definimos una función así::"

#: ../Doc/tutorial/controlflow.rst:498
msgid "It could be called like this::"
msgstr "Puede ser llamada así::"

#: ../Doc/tutorial/controlflow.rst:506
msgid "and of course it would print:"
msgstr "...y por supuesto imprimirá::"

#: ../Doc/tutorial/controlflow.rst:519
msgid ""
"Note that the order in which the keyword arguments are printed is guaranteed "
"to match the order in which they were provided in the function call."
msgstr ""
"Se debe notar que el orden en el cual los argumentos nombrados son impresos "
"está garantizado para coincidir con el orden en el cual fueron provistos en "
"la llamada a la función."

#: ../Doc/tutorial/controlflow.rst:526
msgid "Arbitrary Argument Lists"
msgstr "Listas de argumentos arbitrarios"

#: ../Doc/tutorial/controlflow.rst:531
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. ::"
msgstr ""
"Finalmente, la opción menos frecuentemente usada es especificar que una "
"función puede ser llamada con un número arbitrario de argumentos. Estos "
"argumentos serán organizados en una tupla (mira :ref:`tut-tuples`). Antes "
"del número variable de argumentos, cero o más argumentos normales pueden "
"estar presentes.::"

#: ../Doc/tutorial/controlflow.rst:540
msgid ""
"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. ::"
msgstr ""
"Normalmente estos argumentos de cantidad variables son los últimos en la "
"lista de parámetros formales, porque toman todo el remanente de argumentos "
"que se pasan a la función. Cualquier parámetro que suceda luego del "
"``*args`` será 'sólo nombrado', o sea que sólo se pueden usar como "
"argumentos nombrados y no como posicionales.::"

#: ../Doc/tutorial/controlflow.rst:557
msgid "Unpacking Argument Lists"
msgstr "Desempaquetando una lista de argumentos"

#: ../Doc/tutorial/controlflow.rst:559
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::"
msgstr ""
"La situación inversa ocurre cuando los argumentos ya están en una lista o "
"tupla pero necesitan ser desempaquetados para llamar a una función que "
"requiere argumentos posicionales separados. Por ejemplo, la función "
"predefinida :func:`range` espera los argumentos inicio y fin. Si no están "
"disponibles en forma separada, se puede escribir la llamada a la función con "
"el operador  ``*`` para desempaquetar argumentos desde una lista o una "
"tupla ::"

#: ../Doc/tutorial/controlflow.rst:575
msgid ""
"In the same fashion, dictionaries can deliver keyword arguments with the "
"``**`` operator::"
msgstr ""
"Del mismo modo, los diccionarios pueden entregar argumentos nombrados con el "
"operador ``**``::"

#: ../Doc/tutorial/controlflow.rst:591
msgid "Lambda Expressions"
msgstr "Expresiones lambda"

#: ../Doc/tutorial/controlflow.rst:593
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 "
"definitions, lambda functions can reference variables from the containing "
"scope::"
msgstr ""
"Pequeñas funciones anónimas pueden ser creadas con la palabra reservada :"
"keyword:`lambda`. Esta función retorna la suma de sus dos argumentos: "
"``lambda a, b: a+b`` Las funciones Lambda pueden ser usadas en cualquier "
"lugar donde sea requerido un objeto de tipo función. Están sintácticamente "
"restringidas a una sola expresión. Semánticamente, son solo azúcar "
"sintáctica para definiciones normales de funciones. Al igual que las "
"funciones anidadas, las funciones lambda pueden hacer referencia a variables "
"desde el ámbito que la contiene::"

#: ../Doc/tutorial/controlflow.rst:610
msgid ""
"The above example uses a lambda expression to return a function.  Another "
"use is to pass a small function as an argument::"
msgstr ""
"El ejemplo anterior muestra el uso de una expresión lambda para retornar una "
"función. Otro uso es para pasar pequeñas funciones como argumentos ::"

#: ../Doc/tutorial/controlflow.rst:622
msgid "Documentation Strings"
msgstr "Cadenas de texto de documentación"

#: ../Doc/tutorial/controlflow.rst:629
msgid ""
"Here are some conventions about the content and formatting of documentation "
"strings."
msgstr ""
"Acá hay algunas convenciones sobre el contenido y formato de las cadenas de "
"texto de documentación."

#: ../Doc/tutorial/controlflow.rst:632
msgid ""
"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."
msgstr ""
"La primera línea debe ser siempre un resumen corto y conciso del propósito "
"del objeto. Para ser breve, no se debe mencionar explícitamente el nombre o "
"tipo del objeto, ya que estos están disponibles de otros modos (excepto si "
"el nombre es un verbo que describe el funcionamiento de la función). Esta "
"línea debe empezar con una letra mayúscula y terminar con un punto."

#: ../Doc/tutorial/controlflow.rst:638
msgid ""
"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 "
"debe estar en blanco, separando visualmente el resumen del resto de la "
"descripción. Las líneas siguientes deben ser uno o más párrafos describiendo "
"las convenciones para llamar al objeto, efectos secundarios, etc."

#: ../Doc/tutorial/controlflow.rst:643
msgid ""
"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)."

#: ../Doc/tutorial/controlflow.rst:655
msgid "Here is an example of a multi-line docstring::"
msgstr "Este es un ejemplo de un ``docstring`` multi-línea::"

#: ../Doc/tutorial/controlflow.rst:673
msgid "Function Annotations"
msgstr "Anotación de funciones"

#: ../Doc/tutorial/controlflow.rst:681
msgid ""
":ref:`Function annotations <function>` are completely optional metadata "
"information about the types used by user-defined functions (see :pep:`3107` "
"and :pep:`484` for more information)."
msgstr ""
"Las :ref:`anotaciones de funciones <function>` son información completamente "
"opcional sobre los tipos usadas en funciones definidas por el usuario (ver "
"PEP 484 para más información)."

#: ../Doc/tutorial/controlflow.rst:685
msgid ""
":term:`Annotations <function annotation>` 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 positional argument, a keyword argument, and the return value annotated::"
msgstr ""
"Las :term:`anotaciones <function annotation>` se almacenan en el atributo :"
"attr:`__annotations__` de la función como un diccionario y no tienen efecto "
"en ninguna otra parte de la función. Las anotaciones de los parámetros se "
"definen luego de dos puntos después del nombre del parámetro, seguido de una "
"expresión que evalúa al valor de la anotación. Las anotaciones de retorno "
"son definidas por el literal ->, seguidas de una expresión, entre la lista "
"de parámetros y los dos puntos que marcan el final de la declaración :"
"keyword:`def`. El siguiente ejemplo tiene un argumento posicional, uno "
"nombrado, y el valor de retorno anotado::"

#: ../Doc/tutorial/controlflow.rst:707
msgid "Intermezzo: Coding Style"
msgstr "Intermezzo: Estilo de codificación"

#: ../Doc/tutorial/controlflow.rst:712
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 "
"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."
msgstr ""
"Ahora que estás a punto de escribir piezas de Python más largas y complejas, "
"es un buen momento para hablar sobre *estilo de codificación*. La mayoría de "
"los lenguajes pueden ser escritos (o mejor dicho, *formateados*) con "
"diferentes estilos; algunos son mas fáciles de leer que otros. Hacer que tu "
"código sea más fácil de leer por otros es siempre una buena idea, y adoptar "
"un buen estilo de codificación ayuda tremendamente a lograrlo."

#: ../Doc/tutorial/controlflow.rst:718
msgid ""
"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 codificación fácil de leer y "
"visualmente agradable. Todos los desarrolladores Python deben leerlo en "
"algún momento; aquí están extraídos los puntos más importantes::"

#: ../Doc/tutorial/controlflow.rst:723
msgid "Use 4-space indentation, and no tabs."
msgstr "Usar sangrías de 4 espacios, no tabuladores."

#: ../Doc/tutorial/controlflow.rst:725
msgid ""
"4 spaces are a good compromise between small indentation (allows greater "
"nesting depth) and large indentation (easier to read).  Tabs introduce "
"confusion, and are best left out."
msgstr ""
"4 espacios son un buen compromiso entre una sangría pequeña (permite mayor "
"nivel de sangrado)y una sangría grande (más fácil de leer). Los tabuladores "
"introducen confusión y es mejor dejarlos de lado."

#: ../Doc/tutorial/controlflow.rst:729
msgid "Wrap lines so that they don't exceed 79 characters."
msgstr "Recortar las líneas para que no superen los 79 caracteres."

#: ../Doc/tutorial/controlflow.rst:731
msgid ""
"This helps users with small displays and makes it possible to have several "
"code files side-by-side on larger displays."
msgstr ""
"Esto ayuda a los usuarios con pantallas pequeñas y hace posible tener varios "
"archivos de código abiertos, uno al lado del otro, en pantallas grandes."

#: ../Doc/tutorial/controlflow.rst:734
msgid ""
"Use blank lines to separate functions and classes, and larger blocks of code "
"inside functions."
msgstr ""
"Usar líneas en blanco para separar funciones y clases, y bloques grandes de "
"código dentro de funciones."

#: ../Doc/tutorial/controlflow.rst:737
msgid "When possible, put comments on a line of their own."
msgstr "Cuando sea posible, poner comentarios en una sola línea."

#: ../Doc/tutorial/controlflow.rst:739
msgid "Use docstrings."
msgstr "Usar ``docstrings``."

#: ../Doc/tutorial/controlflow.rst:741
msgid ""
"Use spaces around operators and after commas, but not directly inside "
"bracketing constructs: ``a = f(1, 2) + g(3, 4)``."
msgstr ""
"Usar espacios alrededor de operadores y luego de las comas, pero no "
"directamente dentro de paréntesis: ``a = f(1, 2) + g(3, 4)``."

#: ../Doc/tutorial/controlflow.rst:744
msgid ""
"Name your classes and functions consistently; the convention is to use "
"``CamelCase`` for classes and ``lower_case_with_underscores`` for functions "
"and methods.  Always use ``self`` as the name for the first method argument "
"(see :ref:`tut-firstclasses` for more on classes and methods)."
msgstr ""
"Nombrar las clases y funciones consistentemente; la convención es usar "
"``NotacionCamello`` para clases y ``minusculas_con_guiones_bajos`` para "
"funciones y métodos. Siempre usa self como el nombre para el primer "
"argumento en los métodos (mira :ref:`tut-firstclasses` para más información "
"sobre clases y métodos)."

#: ../Doc/tutorial/controlflow.rst:749
msgid ""
"Don't use fancy encodings if your code is meant to be used in international "
"environments.  Python's default, UTF-8, or even plain ASCII work best in any "
"case."
msgstr ""
"No uses codificaciones estrafalarias si esperas usar el código en entornos "
"internacionales. El default de Python, UTF-8, o incluso ASCII plano "
"funcionan bien en la mayoría de los casos."

#: ../Doc/tutorial/controlflow.rst:753
msgid ""
"Likewise, don't use non-ASCII characters in identifiers if there is only the "
"slightest chance people speaking a different language will read or maintain "
"the code."
msgstr ""
"De la misma manera, no uses caracteres no-ASCII en los identificadores si "
"hay incluso una pequeñísima chance de que gente que hable otro idioma tenga "
"que leer o mantener el código."

#: ../Doc/tutorial/controlflow.rst:759
msgid "Footnotes"
msgstr "Notas al pie"

#: ../Doc/tutorial/controlflow.rst:760
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)."
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)."