# 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/python/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: 2022-10-25 19:47+0200\n"

"PO-Revision-Date: 2021-12-08 23:12+0100\n"

"Last-Translator: Cristián Maureira-Fredes <cmaureirafredes@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.10.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:39

msgid ""

"If you're comparing the same value to several constants, or checking for "

"specific types or attributes, you may also find the :keyword:`!match` "

"statement useful. For more details see :ref:`tut-match`."

msgstr ""

"Si necesitas comparar un mismo valor con muchas constantes, o comprobar que "

"tenga un tipo o atributos específicos puede que encuentres útil la sentencia "

"keyword:`!match`. Para más detalles véase :ref:`tut-match`."

#: ../Doc/tutorial/controlflow.rst:46

msgid ":keyword:`!for` Statements"

msgstr "La sentencia :keyword:`!for`"

#: ../Doc/tutorial/controlflow.rst:51

msgid ""

"The :keyword:`for` statement in Python differs a bit from what you may be "

"used to in C or Pascal. Rather than always iterating over an arithmetic "

"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:72

msgid ""

"Code that modifies a collection while iterating over that same collection "

"can be tricky to get right. Instead, it is usually more straight-forward to "

"loop over a copy of the collection or to create a new collection::"

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:94

msgid "The :func:`range` Function"

msgstr "La función :func:`range`"

#: ../Doc/tutorial/controlflow.rst:96

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:108

msgid ""

"The given end point is never part of the generated sequence; ``range(10)`` "

"generates 10 values, the legal indices for items of a sequence of length "

"10. It is possible to let the range start at another number, or to specify "

"a different increment (even negative; sometimes this is called the 'step')::"

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:122

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:135

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:138

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:143

msgid ""

"In many ways the object returned by :func:`range` behaves as if it is a "

"list, but in fact it isn't. It is an object which returns the successive "

"items of the desired sequence when you iterate over it, but it doesn't "

"really make the list, thus saving space."

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:148

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:157

msgid ""

"Later we will see more functions that return iterables and take iterables as "

"arguments. In chapter :ref:`tut-structures`, we will discuss in more detail "

"about :func:`list`."

msgstr ""

"Más adelante veremos otras funciones que aceptan iterables cómo argumentos o "

"retornan iterables. En el capítulo :ref:`tut-structures`, discutiremos en "

"más detalle sobre la :func:`list`."

#: ../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:224

msgid ":keyword:`!pass` Statements"

msgstr "La sentencia :keyword:`pass`"

#: ../Doc/tutorial/controlflow.rst:226

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:233

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:239

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:251

msgid ":keyword:`!match` Statements"

msgstr "La sentencia :keyword:`!match`"

#: ../Doc/tutorial/controlflow.rst:253

#, fuzzy

msgid ""

"A :keyword:`match` statement takes an expression and compares its value to "

"successive patterns given as one or more case blocks. This is superficially "

"similar to a switch statement in C, Java or JavaScript (and many other "

"languages), but it's more similar to pattern matching in languages like Rust "

"or Haskell. Only the first pattern that matches gets executed and it can "

"also extract components (sequence elements or object attributes) from the "

"value into variables."

msgstr ""

"Una sentencia match recibe una expresión y compara su valor a patrones "

"sucesivos que aparecen en uno o más bloques case. Esto es similar a grandes "

"rasgos con una sentencia switch en C, Java o JavaScript (y muchos otros "

"lenguajes), pero también es capaz de extraer componentes (elementos de una "

"secuencia o atributos de un objeto) de un valor y ponerlos en variables."

#: ../Doc/tutorial/controlflow.rst:261

msgid ""

"The simplest form compares a subject value against one or more literals::"

msgstr ""

"La forma más simple compara un valor, el \"sujeto\", con uno o más "

"literales::"

#: ../Doc/tutorial/controlflow.rst:274

msgid ""

"Note the last block: the \"variable name\" ``_`` acts as a *wildcard* and "

"never fails to match. If no case matches, none of the branches is executed."

msgstr ""

"Observa el último bloque: el \"nombre de variable\" ``_`` funciona como un "

"*comodín* y nunca fracasa la coincidencia. Si ninguno de los casos ``case`` "

"coincide, ninguna de las ramas es ejecutada."

#: ../Doc/tutorial/controlflow.rst:277

msgid ""

"You can combine several literals in a single pattern using ``|`` (\"or\")::"

msgstr ""

"Se pueden combinar varios literales en un solo patrón usando ``|`` (\"ó\")::"

#: ../Doc/tutorial/controlflow.rst:282

msgid ""

"Patterns can look like unpacking assignments, and can be used to bind "

"variables::"

msgstr ""

"Los patrones pueden también verse como asignaciones que desempaquetan, y "

"pueden usarse para ligar variables::"

#: ../Doc/tutorial/controlflow.rst:298

msgid ""

"Study that one carefully! The first pattern has two literals, and can be "

"thought of as an extension of the literal pattern shown above. But the next "

"two patterns combine a literal and a variable, and the variable *binds* a "

"value from the subject (``point``). The fourth pattern captures two values, "

"which makes it conceptually similar to the unpacking assignment ``(x, y) = "

"point``."

msgstr ""

"¡Observa éste con cuidado! El primer patrón tiene dos literales y puede "

"considerarse una extensión del patrón literal que se mostró anteriormente. "

"Pero los siguientes dos patrones combinan un literal y una variable, y la "

"variable *liga* uno de los elementos del sujeto (``point``). El cuarto "

"patrón captura ambos elementos, lo que lo hace conceptualmente similar a la "

"asignación que desempaqueta ``(x, y) = point``."

#: ../Doc/tutorial/controlflow.rst:305

msgid ""

"If you are using classes to structure your data you can use the class name "

"followed by an argument list resembling a constructor, but with the ability "

"to capture attributes into variables::"

msgstr ""

"Si estás usando clases para estructurar tus datos, puedes usar el nombre de "

"la clase seguida de una lista de argumentos similar a la de un constructor, "

"pero con la capacidad de capturar atributos en variables::"

#: ../Doc/tutorial/controlflow.rst:326

msgid ""

"You can use positional parameters with some builtin classes that provide an "

"ordering for their attributes (e.g. dataclasses). You can also define a "

"specific position for attributes in patterns by setting the "

"``__match_args__`` special attribute in your classes. If it's set to (\"x\", "

"\"y\"), the following patterns are all equivalent (and all bind the ``y`` "

"attribute to the ``var`` variable)::"

msgstr ""

"Puedes usar argumentos posicionales en algunas clases incorporadas que "

"proveen un orden para sus atributos (por ej. dataclasses). También puedes "

"definir una posición especifica para los atributos de los patrones si "

"asignas en tu clase el atributo especial ``__match_args__``. Si le asignas "

"(\"x\", \"y\"), los siguientes patrones son todos equivalentes entre sí (y "

"todos ligan el atributo ``y`` a la variable ``var``)::"

#: ../Doc/tutorial/controlflow.rst:337

msgid ""

"A recommended way to read patterns is to look at them as an extended form of "

"what you would put on the left of an assignment, to understand which "

"variables would be set to what. Only the standalone names (like ``var`` "

"above) are assigned to by a match statement. Dotted names (like ``foo."

"bar``), attribute names (the ``x=`` and ``y=`` above) or class names "

"(recognized by the \"(...)\" next to them like ``Point`` above) are never "

"assigned to."

msgstr ""

"Una recomendación para leer patrones es verlos como una forma extendida de "

"lo que pondrías en el lado izquierdo de una asignación, para así entender "

"cuales variables tomarían que valores. Sólo los nombres que aparecen por si "

"solos (cómo ``var`` arriba) son asignados por una sentencia match. Nunca se "

"asigna a los nombres con puntos (como ``foo.bar``), nombres de atributos "

"(los ``x=`` e ``y=`` arriba) o nombres de clases (reconocidos por los "

"\"(...)\" junto a ellos, como ``Point`` arriba)."

#: ../Doc/tutorial/controlflow.rst:344

msgid ""

"Patterns can be arbitrarily nested. For example, if we have a short list of "

"points, we could match it like this::"

msgstr ""

"Los patrones pueden anidarse arbitrariamente. Por ejemplo, si tuviéramos una "

"lista corta de puntos, podríamos aplicar match así::"

#: ../Doc/tutorial/controlflow.rst:359

msgid ""

"We can add an ``if`` clause to a pattern, known as a \"guard\". If the "

"guard is false, ``match`` goes on to try the next case block. Note that "

"value capture happens before the guard is evaluated::"

msgstr ""

"Podemos añadir una clausula ``if`` a un patrón, conocida como \"guarda\". Si "

"la guarda es falsa, ``match`` pasa a intentar el siguiente bloque case. "

"Obsérvese que la captura de valores sucede antes de que la guarda sea "

"evaluada::"

#: ../Doc/tutorial/controlflow.rst:369

msgid "Several other key features of this statement:"

msgstr "Algunas otras propiedades importantes de esta sentencia:"

#: ../Doc/tutorial/controlflow.rst:371

msgid ""

"Like unpacking assignments, tuple and list patterns have exactly the same "

"meaning and actually match arbitrary sequences. An important exception is "

"that they don't match iterators or strings."

msgstr ""

"Al igual que las asignaciones con desempaquetado, los patrones de lista o "

"tupla tienen el mismo significado y en realidad coinciden con cualquier "

"secuencia. Una excepción importante es que no coinciden ni con iteradores ni "

"con cadenas de caracteres."

#: ../Doc/tutorial/controlflow.rst:375

msgid ""

"Sequence patterns support extended unpacking: ``[x, y, *rest]`` and ``(x, y, "

"*rest)`` work similar to unpacking assignments. The name after ``*`` may "

"also be ``_``, so ``(x, y, *_)`` matches a sequence of at least two items "

"without binding the remaining items."

msgstr ""

"Los patrones de secuencia soportan desempaquetado extendido: ``[x, y, "

"*otros]`` and ``(x, y, *otros)`` funcionan de manera similar a las "

"asignaciones con desempaquetado. El nombre luego de ``*`` también puede ser "

"``_``, con lo cual ``(x, y, *_)`` coincide con cualquier secuencia de al "

"menos del elementos, sin ligar ninguno de los demás elementos."

#: ../Doc/tutorial/controlflow.rst:380

#, fuzzy

msgid ""

"Mapping patterns: ``{\"bandwidth\": b, \"latency\": l}`` captures the "

"``\"bandwidth\"`` and ``\"latency\"`` values from a dictionary. Unlike "

"sequence patterns, extra keys are ignored. An unpacking like ``**rest`` is "

"also supported. (But ``**_`` would be redundant, so it is not allowed.)"

msgstr ""

"Los patrones de mapeo: ``{\"ancho de banda\": c, \"latencia\": l}`` capturan "

"los valores ``\"ancho de banda\"`` y ``\"latencia\"`` de un diccionario. A "

"diferencia de los patrones de secuencia, las claves adicionales en el sujeto "

"son ignoradas. Puede usarse un desempaquetado como ``**rest`` . (Aunque "

"``**_`` sería redundante, con lo cual no está permitido)"

#: ../Doc/tutorial/controlflow.rst:385

msgid "Subpatterns may be captured using the ``as`` keyword::"

msgstr "Pueden capturarse subpatrones usando la palabra clave ``as``::"

#: ../Doc/tutorial/controlflow.rst:389

msgid ""

"will capture the second element of the input as ``p2`` (as long as the input "

"is a sequence of two points)"

msgstr ""

"capturará el segundo elemento de la entrada en ``p2`` (siempre y cuando la "

"entrada sea una secuencia de dos puntos)"

#: ../Doc/tutorial/controlflow.rst:392

msgid ""

"Most literals are compared by equality, however the singletons ``True``, "

"``False`` and ``None`` are compared by identity."

msgstr ""

"La mayoría de los literales se comparan por igualdad, pero los singletons "

"``True``, ``False`` y ``None`` se comparan por identidad."

#: ../Doc/tutorial/controlflow.rst:395

msgid ""

"Patterns may use named constants. These must be dotted names to prevent "

"them from being interpreted as capture variable::"

msgstr ""

"En un patrón pueden usarse constantes con nombres. Los nombres deben tener "

"puntos para impedir que sean interpretados como variables a capturar::"

#: ../Doc/tutorial/controlflow.rst:414

msgid ""

"For a more detailed explanation and additional examples, you can look into :"

"pep:`636` which is written in a tutorial format."

msgstr ""

"Para una explicación más detallada y más ejemplos, puede leerse :pep:`636` "

"que está escrita en un formato de tutorial."

#: ../Doc/tutorial/controlflow.rst:420

msgid "Defining Functions"

msgstr "Definiendo funciones"

#: ../Doc/tutorial/controlflow.rst:422

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:442

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:447

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:454

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:465

msgid ""

"The actual parameters (arguments) to a function call are introduced in the "

"local symbol table of the called function when it is called; thus, arguments "

"are passed using *call by value* (where the *value* is always an object "

"*reference*, not the value of the object). [#]_ When a function calls "

"another function, or calls itself recursively, a new local symbol table is "

"created for that call."

msgstr ""

"Los parámetros (argumentos) reales para una llamada de función se introducen "

"en la tabla de símbolos local de la función llamada cuando se llama; por lo "

"tanto, los argumentos se pasan usando *llamada por valor* (donde el *valor* "

"es siempre un objeto *referencia*, no el valor del objeto). [#]_ Cuando una "

"función llama a otra función, o se llama a sí misma de forma recursiva, se "

"crea una nueva tabla de símbolos locales para esa llamada."

#: ../Doc/tutorial/controlflow.rst:472

msgid ""

"A function definition associates the function name with the function object "

"in the current symbol table. The interpreter recognizes the object pointed "

"to by that name as a user-defined function. Other names can also point to "

"that same function object and can also be used to access the function::"

msgstr ""

"Una definición de función asocia el nombre de la función con el objeto de "

"función en la tabla de símbolos actual. El intérprete reconoce el objeto al "

"que apunta ese nombre como una función definida por el usuario. Otros "

"nombres también pueden apuntar a ese mismo objeto de función y también se "

"pueden usar para acceder a la función:"

#: ../Doc/tutorial/controlflow.rst:483

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:494

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:510

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:512

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:516

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:531

msgid "More on Defining Functions"

msgstr "Más sobre definición de funciones"

#: ../Doc/tutorial/controlflow.rst:533

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:540

msgid "Default Argument Values"

msgstr "Argumentos con valores por omisión"

#: ../Doc/tutorial/controlflow.rst:542

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:558

msgid "This function can be called in several ways:"

msgstr "Esta función puede ser llamada de distintas maneras::"

#: ../Doc/tutorial/controlflow.rst:560

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:562

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:564

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:567

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:570

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:581

msgid "will print ``5``."

msgstr "...imprimirá ```5``."

#: ../Doc/tutorial/controlflow.rst:583

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:596

msgid "This will print ::"

msgstr "Imprimirá ::"

#: ../Doc/tutorial/controlflow.rst:602

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:615

msgid "Keyword Arguments"

msgstr "Palabras claves como argumentos"

#: ../Doc/tutorial/controlflow.rst:617

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:626

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:637

msgid "but all the following calls would be invalid::"

msgstr "...pero estas otras llamadas serían todas inválidas::"

#: ../Doc/tutorial/controlflow.rst:644

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:660

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:677

msgid "It could be called like this::"

msgstr "Puede ser llamada así::"

#: ../Doc/tutorial/controlflow.rst:685

msgid "and of course it would print:"

msgstr "...y por supuesto imprimirá::"

#: ../Doc/tutorial/controlflow.rst:698

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:702

msgid "Special parameters"

msgstr "Parámetros especiales"

#: ../Doc/tutorial/controlflow.rst:704

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:710

msgid "A function definition may look like:"

msgstr "La definición de una función puede ser como la siguiente:"

#: ../Doc/tutorial/controlflow.rst:721

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:728

msgid "Positional-or-Keyword Arguments"

msgstr "Argumentos posicionales o de palabras claves"

#: ../Doc/tutorial/controlflow.rst:730

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:735

msgid "Positional-Only Parameters"

msgstr "Parámetros únicamente posicionales"

#: ../Doc/tutorial/controlflow.rst:737

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:745

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:749

msgid "Keyword-Only Arguments"

msgstr "Argumentos únicamente de palabras clave"

#: ../Doc/tutorial/controlflow.rst:751

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:757

msgid "Function Examples"

msgstr "Ejemplos de Funciones"

#: ../Doc/tutorial/controlflow.rst:759

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:775

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:785

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:796

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:807

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:827

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:832

msgid ""

"There is no possible call that will make it return ``True`` as the keyword "

"``'name'`` will always bind to the first parameter. For example::"

msgstr ""

"No hay una llamada posible que lo haga retornar ``True`` ya que la palabra "

"clave ``'name'`` siempre se vinculará al primer parámetro. Por ejemplo::"

#: ../Doc/tutorial/controlflow.rst:841

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:848

msgid ""

"In other words, the names of positional-only parameters can be used in "

"``**kwds`` without ambiguity."

msgstr ""