# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# Maintained by the python-doc-es workteam.
# docs-es@python.org /
# https://mail.python.org/mailman3/lists/docs-es.python.org/
# Check https://github.com/PyCampES/python-docs-es/blob/3.8/TRANSLATORS to
# get the list of volunteers
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-05-05 12:54+0200\n"
"PO-Revision-Date: 2020-05-21 14:04+0200\n"
"Last-Translator: Raúl Cumplido <raulcumplido@gmail.com>\n"
"Language: es\n"
"Language-Team: python-doc-es\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.8.0\n"
"X-Generator: Poedit 2.3\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 uses the "
"usual flow control 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 ""
"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 "
"sobre una copia de la colección o crear una nueva colección::"

#: ../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 retornado por :func:`range` se comporta 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."

#: ../Doc/tutorial/controlflow.rst:142
msgid ""
"We say such an object is :term:`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 a construct, while an example of a function "
"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`::"

#: ../Doc/tutorial/controlflow.rst:151
msgid ""
"Later we will see more functions that return iterables and take iterables as "
"arguments.  Lastly, maybe you are curious about how to get a list from a "
"range. Here is the solution::"
msgstr ""
"Más tarde veremos más funciones que retornan iterables y que toman iterables "
"como entrada. Finalmente, quizás sientas curiosidad sobre como obtener una "
"lista sobre un *range*. Aquí tienes la solución::"

#: ../Doc/tutorial/controlflow.rst:158
msgid ""
"In chapter :ref:`tut-structures`, we will discuss in more detail about :func:"
"`list`."
msgstr ""
"En el capítulo :ref:`tut-structures`, discutiremos en más detalle sobre la :"
"func:`list`."

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

#: ../Doc/tutorial/controlflow.rst:166
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 bucle :keyword:`for` o :"
"keyword:`while` más anidado."

#: ../Doc/tutorial/controlflow.rst:169
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 exemplified by "
"the following loop, which searches for prime numbers::"
msgstr ""
"Las sentencias de bucle pueden tener una cláusula`!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::"

#: ../Doc/tutorial/controlflow.rst:193
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:196
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`."
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`."

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

#: ../Doc/tutorial/controlflow.rst:225
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:232
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:238
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:249
msgid "Defining Functions"
msgstr "Definiendo funciones"

#: ../Doc/tutorial/controlflow.rst:251
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:271
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:276
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:283
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 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:294
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:300
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:312
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 retorna 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:323
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:339
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:341
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` 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:345
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:360
msgid "More on Defining Functions"
msgstr "Más sobre definición de funciones"

#: ../Doc/tutorial/controlflow.rst:362
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:369
msgid "Default Argument Values"
msgstr "Argumentos con valores por omisión"

#: ../Doc/tutorial/controlflow.rst:371
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:387
msgid "This function can be called in several ways:"
msgstr "Esta función puede ser llamada de distintas maneras::"

#: ../Doc/tutorial/controlflow.rst:389
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:391
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:393
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:396
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:399
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:410
msgid "will print ``5``."
msgstr "...imprimirá ```5``."

#: ../Doc/tutorial/controlflow.rst:412
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:425
msgid "This will print ::"
msgstr "Imprimirá ::"

#: ../Doc/tutorial/controlflow.rst:431
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:444
msgid "Keyword Arguments"
msgstr "Palabras claves como argumentos"

#: ../Doc/tutorial/controlflow.rst:446
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:455
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:466
msgid "but all the following calls would be invalid::"
msgstr "...pero estas otras llamadas serían todas inválidas::"

#: ../Doc/tutorial/controlflow.rst:473
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:489
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 <tut-tuples>` 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 ``**name`` 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 "
"``*name`` (descrito en la siguiente sección) que recibe una :ref:`tuple <tut-"
"tuples>` conteniendo los argumentos posicionales además de la lista de "
"parámetros formales. (``*name`` debe ocurrir antes de ``**name``). Por "
"ejemplo, si definimos una función así::"

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

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

#: ../Doc/tutorial/controlflow.rst:527
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:531
msgid "Special parameters"
msgstr "Parámetros especiales"

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

#: ../Doc/tutorial/controlflow.rst:539
msgid "A function definition may look like:"
msgstr "La definición de una función puede ser como la siguiente:"

#: ../Doc/tutorial/controlflow.rst:550
msgid ""
"where ``/`` and ``*`` are optional. If used, these symbols indicate the kind "
"of parameter by how the arguments may be passed to the function: positional-"
"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 por como 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."

#: ../Doc/tutorial/controlflow.rst:557
msgid "Positional-or-Keyword Arguments"
msgstr "Argumentos posicionales o de palabras claves"

#: ../Doc/tutorial/controlflow.rst:559
msgid ""
"If ``/`` and ``*`` are not present in the function definition, arguments may "
"be passed to a function by position or by keyword."
msgstr ""
"Si ``/`` y ``*`` no están presentes en la definición de la función, los "
"parámetros pueden ser pasados a una función posicionalmente o por palabra "
"clave."

#: ../Doc/tutorial/controlflow.rst:564
msgid "Positional-Only Parameters"
msgstr "Parámetros únicamente posicionales"

#: ../Doc/tutorial/controlflow.rst:566
msgid ""
"Looking at this in a bit more detail, it is possible to mark certain "
"parameters as *positional-only*. If *positional-only*, the parameters' order "
"matters, and the parameters cannot be passed by keyword. Positional-only "
"parameters are placed before a ``/`` (forward-slash). The ``/`` is used to "
"logically separate the positional-only parameters from the rest of the "
"parameters. If there is no ``/`` in the function definition, there are no "
"positional-only parameters."
msgstr ""
"En 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:574
msgid ""
"Parameters following the ``/`` may be *positional-or-keyword* or *keyword-"
"only*."
msgstr ""
"Los parámetros luego de una ``/`` pueden ser *únicamente posicionales* o "
"*unicamente de palabras claves*."

#: ../Doc/tutorial/controlflow.rst:578
msgid "Keyword-Only Arguments"
msgstr "Argumentos únicamente de palabras clave"

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

#: ../Doc/tutorial/controlflow.rst:586
msgid "Function Examples"
msgstr "Ejemplos de Funciones"

#: ../Doc/tutorial/controlflow.rst:588
msgid ""
"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 ``*``::"

#: ../Doc/tutorial/controlflow.rst:604
msgid ""
"The first function definition, ``standard_arg``, the most familiar form, "
"places no restrictions on the calling convention and arguments may be passed "
"by position or keyword::"
msgstr ""
"La primer definición de función, ``standard_arg``, la forma mas familiar, no "
"indica ninguna restricción en las condiciones para llamarla y los parámetros "
"deben ser pasados por posición o utilizando palabras clave::"

#: ../Doc/tutorial/controlflow.rst:614
msgid ""
"The second function ``pos_only_arg`` is restricted to only use positional "
"parameters as there is a ``/`` in the function definition::"
msgstr ""
"La segunda función ``pos_only_arg`` está restringida a utilizar únicamente "
"parámetros posicionales ya que existe una ``/`` en la definición de la "
"función::"

#: ../Doc/tutorial/controlflow.rst:625
msgid ""
"The third function ``kwd_only_args`` only allows keyword arguments as "
"indicated by a ``*`` in the function definition::"
msgstr ""
"La tercer función ``kwd_only_args`` solo permite parámetros con palabras "
"clave, indicado por un ``*`` en la definición de la función::"

#: ../Doc/tutorial/controlflow.rst:636
msgid ""
"And the last uses all three calling conventions in the same function "
"definition::"
msgstr ""
"La última utiliza las tres convenciones en una misma definición de función::"

#: ../Doc/tutorial/controlflow.rst:656
msgid ""
"Finally, consider this function definition which has a potential collision "
"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::"

#: ../Doc/tutorial/controlflow.rst:661
msgid ""
"There is no possible call that will make it return ``True`` as the keyword "
"``'name'`` will always to bind to the first parameter. For example::"
msgstr ""
"No existe una llamada que retorne ``True`` ya que la clave ``'name'`` será "
"siempre asignada al primer parámetro. Por ejemplo::"

#: ../Doc/tutorial/controlflow.rst:670
msgid ""
"But using ``/`` (positional only arguments), it is possible since it allows "
"``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::"

#: ../Doc/tutorial/controlflow.rst:677
msgid ""
"In other words, the names of positional-only parameters can be used in "
"``**kwds`` without ambiguity."
msgstr ""
"En otras palabras, los nombres de parámetros únicamente posicionales pueden "
"ser utilizados en ``**kwds`` sin ambigüedad."

#: ../Doc/tutorial/controlflow.rst:682
msgid "Recap"
msgstr "Resumen"

#: ../Doc/tutorial/controlflow.rst:684
msgid ""
"The use case will determine which parameters to use in the function "
"definition::"
msgstr ""
"El caso de uso determinará qué parámetros utilizar en una definición de "
"función::"

#: ../Doc/tutorial/controlflow.rst:688
msgid "As guidance:"
msgstr "A modo de guía: "

#: ../Doc/tutorial/controlflow.rst:690
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."
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 "
"tiene un significado real, si se quiere imponer el orden de los parámetros "
"cuando una función es llamada o si necesita tomar algunos parámetros "
"posicionales y palabras claves arbitrarias."

#: ../Doc/tutorial/controlflow.rst:695
msgid ""
"Use keyword-only when names have meaning and the function definition is more "
"understandable by being explicit with names or you want to prevent users "
"relying on the position of the argument being passed."
msgstr ""
"Utilice parámetros únicamente de palabras clave cuando los nombres de los "
"parámetros tienen un significado y la definición de la función será más "
"entendible usando nombres explícitos o cuando desea evitar que los usuarios "
"dependan de la posición de los parámetros que se pasan."

#: ../Doc/tutorial/controlflow.rst:698
msgid ""
"For an API, use positional-only to prevent breaking API changes if the "
"parameter's name is modified in the future."
msgstr ""
"Para una API, utilice únicamente posicionales para prevenir cambios que "
"rompan con la compatibilidad de la API si el nombre del parámetro es "
"modificado en el futuro. "

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

#: ../Doc/tutorial/controlflow.rst:709
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:718
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:735
msgid "Unpacking Argument Lists"
msgstr "Desempaquetando una lista de argumentos"

#: ../Doc/tutorial/controlflow.rst:737
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 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:753
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:769
msgid "Lambda Expressions"
msgstr "Expresiones lambda"

#: ../Doc/tutorial/controlflow.rst:771
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:788
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:800
msgid "Documentation Strings"
msgstr "Cadenas de texto de documentación"

#: ../Doc/tutorial/controlflow.rst:807
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:810
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:816
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:821
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:833
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:851
msgid "Function Annotations"
msgstr "Anotación de funciones"

#: ../Doc/tutorial/controlflow.rst:859
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:863
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:885
msgid "Intermezzo: Coding Style"
msgstr "Intermezzo: Estilo de codificación"

#: ../Doc/tutorial/controlflow.rst:890
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:896
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:901
msgid "Use 4-space indentation, and no tabs."
msgstr "Usar sangrías de 4 espacios, no tabuladores."

#: ../Doc/tutorial/controlflow.rst:903
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:907
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:909
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:912
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:915
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:917
msgid "Use docstrings."
msgstr "Usar ``docstrings``."

#: ../Doc/tutorial/controlflow.rst:919
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:922
msgid ""
"Name your classes and functions consistently; the convention is to use "
"``UpperCamelCase`` for classes and ``lowercase_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 (mirar :ref:`tut-firstclasses` para más información "
"sobre clases y métodos)."

#: ../Doc/tutorial/controlflow.rst:927
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:931
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:937
msgid "Footnotes"
msgstr "Notas al pie"

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

#~ 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::"

#~ 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."