# 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: 2021-10-16 21:42+0200\n"

"PO-Revision-Date: 2021-08-02 19:31+0200\n"

"Last-Translator: Cristián Maureira-Fredes <cmaureirafredes@gmail.com>\n"

"Language-Team: python-doc-es\n"

"Language: es\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=utf-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=2; plural=(n != 1)\n"

"Generated-By: Babel 2.9.1\n"

#: ../Doc/reference/expressions.rst:6

msgid "Expressions"

msgstr "Expresiones"

#: ../Doc/reference/expressions.rst:10

msgid ""

"This chapter explains the meaning of the elements of expressions in Python."

msgstr ""

"Este capítulo explica el significado de los elementos de expresiones en "

"Python."

#: ../Doc/reference/expressions.rst:12

msgid ""

"**Syntax Notes:** In this and the following chapters, extended BNF notation "

"will be used to describe syntax, not lexical analysis. When (one "

"alternative of) a syntax rule has the form"

msgstr ""

"**Notas de Sintaxis:** En este y los siguientes capítulos será usada "

"notación BNF extendida para describir sintaxis, no análisis léxico. Cuando "

"(una alternativa de) una regla de sintaxis tiene la forma"

#: ../Doc/reference/expressions.rst:19

msgid ""

"and no semantics are given, the semantics of this form of ``name`` are the "

"same as for ``othername``."

msgstr ""

"y no han sido dadas semánticas, las semánticas de esta forma de ``name`` son "

"las mismas que para ``othername``."

#: ../Doc/reference/expressions.rst:26

msgid "Arithmetic conversions"

msgstr "Conversiones aritméticas"

#: ../Doc/reference/expressions.rst:30

msgid ""

"When a description of an arithmetic operator below uses the phrase \"the "

"numeric arguments are converted to a common type\", this means that the "

"operator implementation for built-in types works as follows:"

msgstr ""

"Cuando una descripción de un operador aritmético a continuación usa la frase "

"\"los argumentos numéricos son convertidos a un tipo común\", esto significa "

"que la implementación de operador para tipos incorporados funciona de la "

"siguiente forma:"

#: ../Doc/reference/expressions.rst:34

msgid ""

"If either argument is a complex number, the other is converted to complex;"

msgstr ""

"Si cualquiera de los argumentos es un número complejo, el otro es convertido "

"a complejo;"

#: ../Doc/reference/expressions.rst:36

msgid ""

"otherwise, if either argument is a floating point number, the other is "

"converted to floating point;"

msgstr ""

"de otra forma, si cualquier de los argumentos es un número de punto "

"flotante, el otro es convertido a punto flotante;"

#: ../Doc/reference/expressions.rst:39

msgid "otherwise, both must be integers and no conversion is necessary."

msgstr "de otra forma, ambos deben ser enteros y no se necesita conversión."

#: ../Doc/reference/expressions.rst:41

msgid ""

"Some additional rules apply for certain operators (e.g., a string as a left "

"argument to the '%' operator). Extensions must define their own conversion "

"behavior."

msgstr ""

"Algunas reglas adicionales aplican para ciertos operadores (ej., una cadena "

"de caracteres como argumento a la izquierda del operador '%'). Las "

"extensiones deben definir su comportamiento de conversión."

#: ../Doc/reference/expressions.rst:49

msgid "Atoms"

msgstr "Átomos"

#: ../Doc/reference/expressions.rst:53

msgid ""

"Atoms are the most basic elements of expressions. The simplest atoms are "

"identifiers or literals. Forms enclosed in parentheses, brackets or braces "

"are also categorized syntactically as atoms. The syntax for atoms is:"

msgstr ""

"Los átomos son los elementos más básicos de las expresiones. Los átomos más "

"simples son identificadores o literales. Las formas encerradas en "

"paréntesis, corchetes o llaves son también sintácticamente categorizadas "

"como átomos. La sintaxis para átomos es:"

#: ../Doc/reference/expressions.rst:66

msgid "Identifiers (Names)"

msgstr "Identificadores (Nombres)"

#: ../Doc/reference/expressions.rst:70

msgid ""

"An identifier occurring as an atom is a name. See section :ref:"

"`identifiers` for lexical definition and section :ref:`naming` for "

"documentation of naming and binding."

msgstr ""

"Un identificador encontrándose como un átomo es un nombre. Vea la sección :"

"ref:`identifiers` para la definición léxica y la sección :ref:`naming` para "

"documentación de nombrar y vincular."

#: ../Doc/reference/expressions.rst:76

msgid ""

"When the name is bound to an object, evaluation of the atom yields that "

"object. When a name is not bound, an attempt to evaluate it raises a :exc:"

"`NameError` exception."

msgstr ""

"Cuando el nombre es vinculado a un objeto, la evaluación del átomo produce "

"ese objeto. Cuando un nombre no es vinculado, un intento de evaluarlo genera "

"una excepción :exc:`NameError`."

#: ../Doc/reference/expressions.rst:86

msgid ""

"**Private name mangling:** When an identifier that textually occurs in a "

"class definition begins with two or more underscore characters and does not "

"end in two or more underscores, it is considered a :dfn:`private name` of "

"that class. Private names are transformed to a longer form before code is "

"generated for them. The transformation inserts the class name, with leading "

"underscores removed and a single underscore inserted, in front of the name. "

"For example, the identifier ``__spam`` occurring in a class named ``Ham`` "

"will be transformed to ``_Ham__spam``. This transformation is independent "

"of the syntactical context in which the identifier is used. If the "

"transformed name is extremely long (longer than 255 characters), "

"implementation defined truncation may happen. If the class name consists "

"only of underscores, no transformation is done."

msgstr ""

"**Alteración de nombre privado:** Cuando un identificador que ocurre "

"textualmente en una definición de clase comienza con dos o más caracteres de "

"guión bajo y no termina en dos o más guiones bajos, es considerado un :dfn:"

"`private name` de esa clase. Los nombres privados son transformados a una "

"forma más larga antes de que sea generado código para ellos. La "

"transformación inserta el nombre de clase, con los guiones bajos iniciales "

"eliminados y un solo guión bajo insertado, delante del nombre. Por ejemplo, "

"el identificador ``__spam`` que se encuentra en una clase denominada ``Ham`` "

"será transformado a ``_Ham__spam``. Esta transformación es independiente del "

"contexto sintáctico en el cual es usado el identificador. Si el nombre "

"transformado es extremadamente largo (más largo que 255 caracteres), puede "

"ocurrir el truncamiento definido por la implementación. Si el nombre de "

"clase consiste únicamente de guiones bajos, no se realiza transformación."

#: ../Doc/reference/expressions.rst:102

msgid "Literals"

msgstr "Literales"

#: ../Doc/reference/expressions.rst:106

msgid "Python supports string and bytes literals and various numeric literals:"

msgstr ""

"Python soporta literales de cadenas de caracteres y bytes y varios literales "

"numéricos:"

#: ../Doc/reference/expressions.rst:112

msgid ""

"Evaluation of a literal yields an object of the given type (string, bytes, "

"integer, floating point number, complex number) with the given value. The "

"value may be approximated in the case of floating point and imaginary "

"(complex) literals. See section :ref:`literals` for details."

msgstr ""

"La evaluación de un literal produce un objeto del tipo dado (cadena de "

"caracteres, bytes, entero, número de punto flotante, número complejo) con el "

"valor dado. El valor puede ser aproximado en el caso de literales de número "

"de punto flotante e imaginarios (complejos). Vea la sección :ref:`literals` "

"para más detalles."

#: ../Doc/reference/expressions.rst:121

msgid ""

"All literals correspond to immutable data types, and hence the object's "

"identity is less important than its value. Multiple evaluations of literals "

"with the same value (either the same occurrence in the program text or a "

"different occurrence) may obtain the same object or a different object with "

"the same value."

msgstr ""

"Todos los literales corresponden a tipos de datos inmutables y, por lo "

"tanto, la identidad del objeto es menos importante que su valor. Múltiples "

"evaluaciones de literales con el mismo valor (ya sea la misma ocurrencia en "

"el texto del programa o una ocurrencia diferente) pueden obtener el mismo "

"objeto o un objeto diferente con el mismo valor."

#: ../Doc/reference/expressions.rst:131

msgid "Parenthesized forms"

msgstr "Formas entre paréntesis"

#: ../Doc/reference/expressions.rst:137

msgid ""

"A parenthesized form is an optional expression list enclosed in parentheses:"

msgstr ""

"Una forma entre paréntesis es una lista de expresiones opcionales encerradas "

"entre paréntesis:"

#: ../Doc/reference/expressions.rst:142

msgid ""

"A parenthesized expression list yields whatever that expression list yields: "

"if the list contains at least one comma, it yields a tuple; otherwise, it "

"yields the single expression that makes up the expression list."

msgstr ""

"Una expresión entre paréntesis produce lo que la lista de expresión produce: "

"si la lista contiene al menos una coma, produce una tupla; en caso "

"contrario, produce la única expresión que que forma la lista de expresiones."

#: ../Doc/reference/expressions.rst:148

msgid ""

"An empty pair of parentheses yields an empty tuple object. Since tuples are "

"immutable, the same rules as for literals apply (i.e., two occurrences of "

"the empty tuple may or may not yield the same object)."

msgstr ""

"Un par de paréntesis vacío producen un objeto de tupla vacío. Debido a que "

"las tuplas son inmutables, se aplican las mismas reglas que aplican para "

"literales (ej., dos ocurrencias de una tupla vacía puede o no producir el "

"mismo objeto)."

#: ../Doc/reference/expressions.rst:156

msgid ""

"Note that tuples are not formed by the parentheses, but rather by use of the "

"comma operator. The exception is the empty tuple, for which parentheses "

"*are* required --- allowing unparenthesized \"nothing\" in expressions would "

"cause ambiguities and allow common typos to pass uncaught."

msgstr ""

"Note que las tuplas no son formadas por los paréntesis, sino más bien "

"mediante el uso del operador de coma. La excepción es la tupla vacía, para "

"la cual los paréntesis *son* requeridos -- permitir \"nada\" sin paréntesis "

"en expresiones causaría ambigüedades y permitiría que errores tipográficos "

"comunes pasaran sin ser detectados."

#: ../Doc/reference/expressions.rst:165

msgid "Displays for lists, sets and dictionaries"

msgstr "Despliegues para listas, conjuntos y diccionarios"

#: ../Doc/reference/expressions.rst:169

msgid ""

"For constructing a list, a set or a dictionary Python provides special "

"syntax called \"displays\", each of them in two flavors:"

msgstr ""

"Para construir una lista, un conjunto o un diccionario, Python provee "

"sintaxis especial denominada \"despliegue\", cada una de ellas en dos "

"sabores:"

#: ../Doc/reference/expressions.rst:172

msgid "either the container contents are listed explicitly, or"

msgstr "los contenidos del contenedor son listados explícitamente o"

#: ../Doc/reference/expressions.rst:174

msgid ""

"they are computed via a set of looping and filtering instructions, called a :"

"dfn:`comprehension`."

msgstr ""

"son calculados mediante un conjunto de instrucciones de bucle y filtrado, "

"denominadas una :dfn:`comprehension`."

#: ../Doc/reference/expressions.rst:182

msgid "Common syntax elements for comprehensions are:"

msgstr "Los elementos comunes de sintaxis para las comprensiones son:"

#: ../Doc/reference/expressions.rst:190

msgid ""

"The comprehension consists of a single expression followed by at least one :"

"keyword:`!for` clause and zero or more :keyword:`!for` or :keyword:`!if` "

"clauses. In this case, the elements of the new container are those that "

"would be produced by considering each of the :keyword:`!for` or :keyword:`!"

"if` clauses a block, nesting from left to right, and evaluating the "

"expression to produce an element each time the innermost block is reached."

msgstr ""

"La comprensión consiste en una única expresión seguida por al menos una "

"cláusula :keyword:`!for` y cero o más cláusulas :keyword:`!for` o :keyword:`!"

"if`. En este caso, los elementos del nuevo contenedor son aquellos que "

"serían producidos mediante considerar cada una de las cláusulas :keyword:`!"

"for` o :keyword:`!if` un bloque, anidado de izquierda a derecha y evaluando "

"la expresión para producir un elemento cada vez que se alcanza el bloque más "

"interno."

#: ../Doc/reference/expressions.rst:197

msgid ""

"However, aside from the iterable expression in the leftmost :keyword:`!for` "

"clause, the comprehension is executed in a separate implicitly nested scope. "

"This ensures that names assigned to in the target list don't \"leak\" into "

"the enclosing scope."

msgstr ""

"Sin embargo, aparte de la expresión iterable en la cláusula :keyword:`!for` "

"más a la izquierda, la comprensión es ejecutada en un alcance separado "

"implícitamente anidado. Esto asegura que los nombres asignados a en la lista "

"objetiva no se \"filtren\" en el alcance adjunto."

#: ../Doc/reference/expressions.rst:201

msgid ""

"The iterable expression in the leftmost :keyword:`!for` clause is evaluated "

"directly in the enclosing scope and then passed as an argument to the "

"implicitly nested scope. Subsequent :keyword:`!for` clauses and any filter "

"condition in the leftmost :keyword:`!for` clause cannot be evaluated in the "

"enclosing scope as they may depend on the values obtained from the leftmost "

"iterable. For example: ``[x*y for x in range(10) for y in range(x, x+10)]``."

msgstr ""

"La expresión iterable en la cláusula más a la izquierda :keyword:`!for` es "

"evaluada directamente en el alcance anidado y luego pasada como un argumento "

"al alcance implícitamente anidado. Subsecuentes cláusulas :keyword:`!for` y "

"cualquier condición de filtro en la cláusula :keyword:`!for` más a la "

"izquierda no pueden ser evaluadas en el alcance adjunto ya que pueden "

"depender de los valores obtenidos del iterable de más a la izquierda. Por "

"ejemplo, ``[x*y for x in range(10) for y in range(x, x+10)]``."

#: ../Doc/reference/expressions.rst:208

msgid ""

"To ensure the comprehension always results in a container of the appropriate "

"type, ``yield`` and ``yield from`` expressions are prohibited in the "

"implicitly nested scope."

msgstr ""

"Para asegurar que la comprensión siempre resulta en un contenedor del tipo "

"apropiado, las expresiones ``yield`` y ``yield from`` están prohibidas en el "

"alcance implícitamente anidado."

#: ../Doc/reference/expressions.rst:215

msgid ""

"Since Python 3.6, in an :keyword:`async def` function, an :keyword:`!async "

"for` clause may be used to iterate over a :term:`asynchronous iterator`. A "

"comprehension in an :keyword:`!async def` function may consist of either a :"

"keyword:`!for` or :keyword:`!async for` clause following the leading "

"expression, may contain additional :keyword:`!for` or :keyword:`!async for` "

"clauses, and may also use :keyword:`await` expressions. If a comprehension "

"contains either :keyword:`!async for` clauses or :keyword:`!await` "

"expressions it is called an :dfn:`asynchronous comprehension`. An "

"asynchronous comprehension may suspend the execution of the coroutine "

"function in which it appears. See also :pep:`530`."

msgstr ""

"A partir de Python 3.6, en una función :keyword:`async def`, una cláusula :"

"keyword:`!async for` puede ser usada para iterar sobre un :term:"

"`asynchronous iterator`. Una comprensión en una función :keyword:`!async "

"def` puede consistir en una cláusula :keyword:`!for` o :keyword:`!async for` "

"siguiendo la expresión inicial, puede contener cláusulas adicionales :"

"keyword:`!for` o :keyword:`!async for` y también pueden usar expresiones :"

"keyword:`await`. Si una comprensión contiene cláusulas :keyword:`!async for` "

"o expresiones :keyword:`!await` es denominada una :dfn:`asynchronous "

"comprehension`. Una comprensión asincrónica puede suspender la ejecución de "

"la función de corrutina en la cual aparece. Vea también :pep:`530`."

#: ../Doc/reference/expressions.rst:227

msgid "Asynchronous comprehensions were introduced."

msgstr "Fueron introducidas las comprensiones asincrónicas."

#: ../Doc/reference/expressions.rst:230 ../Doc/reference/expressions.rst:403

msgid "``yield`` and ``yield from`` prohibited in the implicitly nested scope."

msgstr ""

"Prohibidas ``yield`` y ``yield from`` en el alcance implícitamente anidado."

#: ../Doc/reference/expressions.rst:237

msgid "List displays"

msgstr "Despliegues de lista"

#: ../Doc/reference/expressions.rst:247

msgid ""

"A list display is a possibly empty series of expressions enclosed in square "

"brackets:"

msgstr ""

"Un despliegue de lista es una serie de expresiones posiblemente vacía "

"encerrada entre corchetes:"

#: ../Doc/reference/expressions.rst:253

msgid ""

"A list display yields a new list object, the contents being specified by "

"either a list of expressions or a comprehension. When a comma-separated "

"list of expressions is supplied, its elements are evaluated from left to "

"right and placed into the list object in that order. When a comprehension "

"is supplied, the list is constructed from the elements resulting from the "

"comprehension."

msgstr ""

"Un despliegue de lista produce un nuevo objeto lista, el contenido se "

"especifica por una lista de expresiones o una comprensión. Cuando se "

"proporciona una lista de expresiones, sus elementos son evaluados desde la "

"izquierda a la derecha y colocados en el objeto lista en ese orden. Cuando "

"se proporciona una comprensión, la lista es construida desde los elementos "

"resultantes de la comprensión."

#: ../Doc/reference/expressions.rst:263

msgid "Set displays"

msgstr "Despliegues de conjuntos"

#: ../Doc/reference/expressions.rst:272

msgid ""

"A set display is denoted by curly braces and distinguishable from dictionary "

"displays by the lack of colons separating keys and values:"

msgstr ""

"Un despliegue de conjunto se denota mediante llaves y se distinguen de los "

"despliegues de diccionarios por la ausencia de caracteres de doble punto "

"separando claves y valores:"

#: ../Doc/reference/expressions.rst:278

msgid ""

"A set display yields a new mutable set object, the contents being specified "

"by either a sequence of expressions or a comprehension. When a comma-"

"separated list of expressions is supplied, its elements are evaluated from "

"left to right and added to the set object. When a comprehension is "

"supplied, the set is constructed from the elements resulting from the "

"comprehension."

msgstr ""

"Un despliegue de conjunto produce un nuevo objeto conjunto mutable, el "

"contenido se especifica mediante una secuencia de expresiones o una "

"comprensión. Cuando se proporciona una lista de expresiones separadas por "

"comas, sus elementos son evaluados desde la izquierda a la derecha y "

"añadidos al objeto de conjunto. Cuando se proporciona una comprensión, el "

"conjunto es construido de los elementos resultantes de la comprensión."

#: ../Doc/reference/expressions.rst:284

msgid ""

"An empty set cannot be constructed with ``{}``; this literal constructs an "

"empty dictionary."

msgstr ""

"Un conjunto vacío no puede ser construido con ``{}``; este literal construye "

"un diccionario vacío."

#: ../Doc/reference/expressions.rst:291

msgid "Dictionary displays"

msgstr "Despliegues de diccionario"

#: ../Doc/reference/expressions.rst:302

msgid ""

"A dictionary display is a possibly empty series of key/datum pairs enclosed "

"in curly braces:"

msgstr ""

"Un despliegue de diccionario es una serie posiblemente vacía de pares clave/"

"datos encerrados entre llaves:"

#: ../Doc/reference/expressions.rst:311

msgid "A dictionary display yields a new dictionary object."

msgstr "Un despliegue de diccionario produce un nuevo objeto diccionario."

#: ../Doc/reference/expressions.rst:313

msgid ""

"If a comma-separated sequence of key/datum pairs is given, they are "

"evaluated from left to right to define the entries of the dictionary: each "

"key object is used as a key into the dictionary to store the corresponding "

"datum. This means that you can specify the same key multiple times in the "

"key/datum list, and the final dictionary's value for that key will be the "

"last one given."

msgstr ""

"Si es dada una secuencia separada por comas de pares clave/datos, son "

"evaluadas desde la izquierda a la derecha para definir las entradas del "

"diccionario: cada objeto clave es usado como una clave dentro del "

"diccionario para almacenar el dato correspondiente. Esto significa que "

"puedes especificar la misma clave múltiples veces en la lista clave/datos y "

"el valor final del diccionario para esa clave será la última dada."

#: ../Doc/reference/expressions.rst:323

msgid ""

"A double asterisk ``**`` denotes :dfn:`dictionary unpacking`. Its operand "

"must be a :term:`mapping`. Each mapping item is added to the new "

"dictionary. Later values replace values already set by earlier key/datum "

"pairs and earlier dictionary unpackings."

msgstr ""

"Un doble asterisco ``**`` denota :dfn:`dictionary unpacking`. Su operando "

"debe ser un :term:`mapping`. Cada elemento de mapeo es añadido al nuevo "

"diccionario. Valores más tardíos remplazan los valores ya establecidos para "

"los pares clave/dato y para los desempaquetados de diccionario anteriores."

#: ../Doc/reference/expressions.rst:328

msgid "Unpacking into dictionary displays, originally proposed by :pep:`448`."

msgstr ""

"Desempaquetar en despliegues de diccionarios, originalmente propuesto por :"

"pep:`448`."

#: ../Doc/reference/expressions.rst:331

msgid ""

"A dict comprehension, in contrast to list and set comprehensions, needs two "

"expressions separated with a colon followed by the usual \"for\" and \"if\" "

"clauses. When the comprehension is run, the resulting key and value elements "

"are inserted in the new dictionary in the order they are produced."

msgstr ""

"Una comprensión de diccionario, en contraste a las compresiones de lista y "

"conjunto, necesita dos expresiones separadas con un caracter de doble punto "

"seguido por las cláusulas usuales \"for\" e \"if\". Cuando la comprensión se "

"ejecuta, los elementos resultantes clave y valor son insertados en el nuevo "

"diccionario en el orden que son producidos."

#: ../Doc/reference/expressions.rst:339

msgid ""

"Restrictions on the types of the key values are listed earlier in section :"

"ref:`types`. (To summarize, the key type should be :term:`hashable`, which "

"excludes all mutable objects.) Clashes between duplicate keys are not "

"detected; the last datum (textually rightmost in the display) stored for a "

"given key value prevails."

msgstr ""

"Las restricciones de los tipos de los valores de clave son listados "

"anteriormente en la sección :ref:`types`. (Para resumir, el tipo de la clave "

"debe ser :term:`hashable`, el cual excluye todos los objetos mutables.) No "

"se detectan choques entre claves duplicadas; el último dato (textualmente el "

"más a la derecha en el despliegue) almacenado para una clave dada prevalece."

#: ../Doc/reference/expressions.rst:345

msgid ""

"Prior to Python 3.8, in dict comprehensions, the evaluation order of key and "

"value was not well-defined. In CPython, the value was evaluated before the "

"key. Starting with 3.8, the key is evaluated before the value, as proposed "

"by :pep:`572`."

msgstr ""

"Antes de Python 3.8, en las comprensiones de diccionarios, el orden de "

"evaluación de clave y valor no fue bien definido. En CPython, el valor fue "

"evaluado antes de la clave. A partir de 3.8, la clave es evaluada antes que "

"el valor, como fue propuesto por :pep:`572`."

#: ../Doc/reference/expressions.rst:355

msgid "Generator expressions"

msgstr "Expresiones de generador"

#: ../Doc/reference/expressions.rst:362

msgid "A generator expression is a compact generator notation in parentheses:"

msgstr ""

"Una expresión de generador es una notación compacta de generador en "

"paréntesis:"

#: ../Doc/reference/expressions.rst:367

msgid ""

"A generator expression yields a new generator object. Its syntax is the "

"same as for comprehensions, except that it is enclosed in parentheses "

"instead of brackets or curly braces."

msgstr ""

"Una expresión de generador produce un nuevo objeto generador. Su sintaxis es "

"la misma que para las comprensiones, excepto que es encerrado en paréntesis "

"en lugar de corchetes o llaves."

#: ../Doc/reference/expressions.rst:371

msgid ""

"Variables used in the generator expression are evaluated lazily when the :"

"meth:`~generator.__next__` method is called for the generator object (in the "

"same fashion as normal generators). However, the iterable expression in the "

"leftmost :keyword:`!for` clause is immediately evaluated, so that an error "

"produced by it will be emitted at the point where the generator expression "

"is defined, rather than at the point where the first value is retrieved. "

"Subsequent :keyword:`!for` clauses and any filter condition in the leftmost :"

"keyword:`!for` clause cannot be evaluated in the enclosing scope as they may "

"depend on the values obtained from the leftmost iterable. For example: "

"``(x*y for x in range(10) for y in range(x, x+10))``."

msgstr ""

"Las variables usadas en la expresión de generador son evaluadas "

"perezosamente cuando se ejecuta el método :meth:`~generator.__next__` para "

"el objeto generador (de la misma forma que los generadores normales). Sin "

"embargo, la expresión iterable en la cláusula :keyword:`!for` más a la "

"izquierda es inmediatamente evaluada, de forma que un error producido por "

"ella será emitido en el punto en el que se define la expresión de generador, "

"en lugar de en el punto donde se obtiene el primer valor. Subsecuentes "

"cláusulas :keyword:`!for` y cualquier condición en la cláusula :keyword:`!"

"for` más a la izquierda no pueden ser evaluadas en el alcance adjunto, ya "

"que puede depender de los valores obtenidos por el iterable de más a la "

"izquierda. Por ejemplo: ``(x*y for x in range(10) for y in range(x, x+10))``."

#: ../Doc/reference/expressions.rst:382

msgid ""

"The parentheses can be omitted on calls with only one argument. See "

"section :ref:`calls` for details."

msgstr ""

"Los paréntesis pueden ser omitidos en ejecuciones con un solo argumento. Vea "

"la sección :ref:`calls` para más detalles."

#: ../Doc/reference/expressions.rst:385

msgid ""

"To avoid interfering with the expected operation of the generator expression "

"itself, ``yield`` and ``yield from`` expressions are prohibited in the "

"implicitly defined generator."

msgstr ""

"Para evitar interferir con la operación esperada de la expresión misma del "

"generador, las expresiones ``yield`` y ``yield from`` están prohibidas en el "

"generador definido implícitamente."

#: ../Doc/reference/expressions.rst:389

msgid ""

"If a generator expression contains either :keyword:`!async for` clauses or :"

"keyword:`await` expressions it is called an :dfn:`asynchronous generator "

"expression`. An asynchronous generator expression returns a new "

"asynchronous generator object, which is an asynchronous iterator (see :ref:"

"`async-iterators`)."

msgstr ""

"Si una expresión de generador contiene cláusulas :keyword:`!async for` o "

"expresiones :keyword:`await`, se ejecuta una :dfn:`asynchronous generator "

"expression`. Una expresión de generador asincrónica retorna un nuevo objeto "

"de generador asincrónico, el cual es un iterador asincrónico (ver :ref:"

"`async-iterators`)."

#: ../Doc/reference/expressions.rst:395

msgid "Asynchronous generator expressions were introduced."

msgstr "Las expresiones de generador asincrónico fueron introducidas."

#: ../Doc/reference/expressions.rst:398

msgid ""

"Prior to Python 3.7, asynchronous generator expressions could only appear "

"in :keyword:`async def` coroutines. Starting with 3.7, any function can use "

"asynchronous generator expressions."

msgstr ""

"Antes de Python 3.7, las expresiones de generador asincrónico podrían "

"aparecer sólo en corrutinas :keyword:`async def`. Desde 3.7, cualquier "

"función puede usar expresiones de generador asincrónico."

#: ../Doc/reference/expressions.rst:410

msgid "Yield expressions"

msgstr "Expresiones yield"

#: ../Doc/reference/expressions.rst:422

msgid ""

"The yield expression is used when defining a :term:`generator` function or "

"an :term:`asynchronous generator` function and thus can only be used in the "

"body of a function definition. Using a yield expression in a function's "

"body causes that function to be a generator, and using it in an :keyword:"

"`async def` function's body causes that coroutine function to be an "

"asynchronous generator. For example::"

msgstr ""

"La expresión yield se usa al definir una función :term:`generator` o una "

"función :term:`asynchronous generator` y, por lo tanto, solo se puede usar "

"en el cuerpo de una definición de función. Usar una expresión yield en el "

"cuerpo de una función hace que esa función sea un generador y usarla en el "

"cuerpo de una función :keyword:`async def` hace que la función de corrutina "

"sea un generador asincrónico. Por ejemplo::"

#: ../Doc/reference/expressions.rst:435

msgid ""

"Due to their side effects on the containing scope, ``yield`` expressions are "

"not permitted as part of the implicitly defined scopes used to implement "

"comprehensions and generator expressions."

msgstr ""

"Debido a sus efectos secundarios sobre el alcance contenedor, las "

"expresiones ``yield`` no están permitidas como parte de los alcances "

"implícitamente definidos usados para implementar comprensiones y expresiones "

"de generador."

#: ../Doc/reference/expressions.rst:439

msgid ""

"Yield expressions prohibited in the implicitly nested scopes used to "

"implement comprehensions and generator expressions."

msgstr ""

"Expresiones yield prohibidas en los ámbitos anidados implícitamente "

"utilizados para implementar comprensiones y expresiones de generador."

#: ../Doc/reference/expressions.rst:443

msgid ""

"Generator functions are described below, while asynchronous generator "

"functions are described separately in section :ref:`asynchronous-generator-"

"functions`."

msgstr ""

"Las funciones generadoras son descritas a continuación, mientras que las "

"funciones generadoras asincrónicas son descritas separadamente en la "

"sección :ref:`asynchronous-generator-functions`."

#: ../Doc/reference/expressions.rst:447

msgid ""

"When a generator function is called, it returns an iterator known as a "

"generator. That generator then controls the execution of the generator "

"function. The execution starts when one of the generator's methods is "

"called. At that time, the execution proceeds to the first yield expression, "

"where it is suspended again, returning the value of :token:`expression_list` "

"to the generator's caller. By suspended, we mean that all local state is "

"retained, including the current bindings of local variables, the instruction "

"pointer, the internal evaluation stack, and the state of any exception "

"handling. When the execution is resumed by calling one of the generator's "

"methods, the function can proceed exactly as if the yield expression were "

"just another external call. The value of the yield expression after "

"resuming depends on the method which resumed the execution. If :meth:"

"`~generator.__next__` is used (typically via either a :keyword:`for` or the :"

"func:`next` builtin) then the result is :const:`None`. Otherwise, if :meth:"

"`~generator.send` is used, then the result will be the value passed in to "

"that method."

msgstr ""

"Cuando una función generadora es invocada, retorna un iterador conocido como "

"un generador. Este generador controla la ejecución de la función generadora. "

"La ejecución empieza cuando uno de los métodos del generador es invocado. En "

"ese momento, la ejecución procede a la primera expresión yield, donde es "

"suspendida de nuevo, retornando el valor de :token:`expression_list` al "

"invocador del generador. Por suspendido, nos referimos a que se retiene todo "

"el estado local, incluyendo los enlaces actuales de variables locales, el "

"puntero de instrucción, la pila de evaluación interna y el estado de "

"cualquier manejo de excepción. Cuando la ejecución se reanuda al invocar uno "

"de los métodos del generador, la función puede proceder como si la expresión "

"yield fuera sólo otra invocación externa. El valor de la expresión yield "

"después de la reanudación depende del método que ha reanudado la ejecución. "

"Si se usa :meth:`~generator.__next__` (típicamente mediante un :keyword:"

"`for` o la función incorporada :func:`next`) entonces el resultado es :const:"

"`None`. De otra forma, si se usa :meth:`~generator.send`, entonces el "

"resultado será el valor pasado a ese método."

#: ../Doc/reference/expressions.rst:466

msgid ""

"All of this makes generator functions quite similar to coroutines; they "

"yield multiple times, they have more than one entry point and their "

"execution can be suspended. The only difference is that a generator "

"function cannot control where the execution should continue after it yields; "

"the control is always transferred to the generator's caller."

msgstr ""

"Todo este hace a las funciones generadores similar a las corrutinas; "

"producen múltiples veces, tienen más de un punto de entrada y su ejecución "

"puede ser suspendida. La única diferencia es que una función generadora no "

"puede controlar si la ejecución debe continuar después de producir; el "

"control siempre es transferido al invocador del generador."

#: ../Doc/reference/expressions.rst:472

msgid ""

"Yield expressions are allowed anywhere in a :keyword:`try` construct. If "

"the generator is not resumed before it is finalized (by reaching a zero "

"reference count or by being garbage collected), the generator-iterator's :"

"meth:`~generator.close` method will be called, allowing any pending :keyword:"

"`finally` clauses to execute."

msgstr ""

"Las expresiones yield están permitidas en cualquier lugar en un constructo :"

"keyword:`try`. Si el generador no es reanudado antes de finalizar "

"(alcanzando un recuento de referencia cero o colectando basura), el método "

"generador-iterador :meth:`~generator.close` será invocado, permitiendo la "

"ejecución de cualquier cláusula :keyword:`finally` pendiente."

#: ../Doc/reference/expressions.rst:481

msgid ""

"When ``yield from <expr>`` is used, the supplied expression must be an "

"iterable. The values produced by iterating that iterable are passed directly "

"to the caller of the current generator's methods. Any values passed in with :"

"meth:`~generator.send` and any exceptions passed in with :meth:`~generator."

"throw` are passed to the underlying iterator if it has the appropriate "

"methods. If this is not the case, then :meth:`~generator.send` will raise :"

"exc:`AttributeError` or :exc:`TypeError`, while :meth:`~generator.throw` "

"will just raise the passed in exception immediately."

msgstr ""

"Cuando se usa ``yield from <expr>``, la expresión proporcionada debe ser "

"iterable. Los valores producidos al iterar ese iterable se pasan "

"directamente al llamador de los métodos del generador actual. Cualquier "

"valor pasado con :meth:`~generator.send` y cualquier excepción pasada con :"

"meth:`~generator.throw` se pasan al iterador subyacente si tiene los métodos "

"apropiados. Si este no es el caso, entonces :meth:`~generator.send` lanzará :"

"exc:`AttributeError` o :exc:`TypeError`, mientras que :meth:`~generator."

"throw` solo lanzará la excepción pasada inmediatamente."

#: ../Doc/reference/expressions.rst:490

msgid ""

"When the underlying iterator is complete, the :attr:`~StopIteration.value` "

"attribute of the raised :exc:`StopIteration` instance becomes the value of "

"the yield expression. It can be either set explicitly when raising :exc:"

"`StopIteration`, or automatically when the subiterator is a generator (by "

"returning a value from the subgenerator)."

msgstr ""

"Cuando el iterador subyacente está completo, el atributo :attr:"

"`~StopIteration.value` de la instancia :exc:`StopIteration` generada se "

"convierte en el valor de la expresión yield. Puede ser establecido "

"explícitamente al generar :exc:`StopIteration` o automáticamente cuando el "

"subiterador es un generador (retornando un valor del subgenerador)."

#: ../Doc/reference/expressions.rst:496

msgid "Added ``yield from <expr>`` to delegate control flow to a subiterator."

msgstr ""

"Añadido ``yield from <expr>`` para delegar el control de flujo a un "

"subiterador."

#: ../Doc/reference/expressions.rst:499

msgid ""

"The parentheses may be omitted when the yield expression is the sole "

"expression on the right hand side of an assignment statement."

msgstr ""

"Los paréntesis pueden ser omitidos cuando la expresión yield es la única "

"expresión en el lado derecho de una sentencia de asignación."

#: ../Doc/reference/expressions.rst:505

msgid ":pep:`255` - Simple Generators"

msgstr ":pep:`255` - Generadores Simples"

#: ../Doc/reference/expressions.rst:505

msgid ""

"The proposal for adding generators and the :keyword:`yield` statement to "

"Python."

msgstr ""

"La propuesta para añadir generadores y la sentencia :keyword:`yield` a "

"Python."

#: ../Doc/reference/expressions.rst:509

msgid ":pep:`342` - Coroutines via Enhanced Generators"

msgstr ":pep:`342` - Corrutinas mediante Generadores Mejorados"

#: ../Doc/reference/expressions.rst:508

msgid ""

"The proposal to enhance the API and syntax of generators, making them usable "

"as simple coroutines."

msgstr ""

"La propuesta para mejorar la API y la sintaxis de generadores, haciéndolos "

"utilizables como corrutinas simples."

#: ../Doc/reference/expressions.rst:513

msgid ":pep:`380` - Syntax for Delegating to a Subgenerator"

msgstr ":pep:`380` - Sintaxis para Delegar a un Subgenerador"

#: ../Doc/reference/expressions.rst:512

msgid ""

"The proposal to introduce the :token:`yield_from` syntax, making delegation "

"to subgenerators easy."

msgstr ""

"La propuesta para introducir la sintaxis :token:`yield_from`, facilitando la "

"delegación a subgeneradores."

#: ../Doc/reference/expressions.rst:516

msgid ":pep:`525` - Asynchronous Generators"

msgstr ":pep:`525`- Generadores Asincrónicos"

#: ../Doc/reference/expressions.rst:516

msgid ""

"The proposal that expanded on :pep:`492` by adding generator capabilities to "

"coroutine functions."

msgstr ""

"La propuesta que expandió :pep:`492` añadiendo capacidades de generador a "

"las funciones corrutina."

#: ../Doc/reference/expressions.rst:523

msgid "Generator-iterator methods"

msgstr "Métodos generador-iterador"

#: ../Doc/reference/expressions.rst:525

msgid ""

"This subsection describes the methods of a generator iterator. They can be "

"used to control the execution of a generator function."

msgstr ""

"Esta subsección describe los métodos de un generador iterador. Estos pueden "

"ser usados para controlar la ejecución de una función generadora."

#: ../Doc/reference/expressions.rst:528

msgid ""

"Note that calling any of the generator methods below when the generator is "

"already executing raises a :exc:`ValueError` exception."

msgstr ""

"Tenga en cuenta que invocar cualquiera de los métodos de generador "

"siguientes cuando el generador está todavía en ejecución genera una "

"excepción :exc:`ValueError`."

#: ../Doc/reference/expressions.rst:536

msgid ""

"Starts the execution of a generator function or resumes it at the last "

"executed yield expression. When a generator function is resumed with a :"

"meth:`~generator.__next__` method, the current yield expression always "

"evaluates to :const:`None`. The execution then continues to the next yield "

"expression, where the generator is suspended again, and the value of the :"

"token:`expression_list` is returned to :meth:`__next__`'s caller. If the "

"generator exits without yielding another value, a :exc:`StopIteration` "

"exception is raised."

msgstr ""

"Comienza la ejecución de una función generadora o la reanuda en la última "

"expresión yield ejecutada. Cuando una función generadora es reanudada con un "

"método :meth:`~generator.__next__`, la expresión yield actual siempre evalúa "

"a :const:`None`. La ejecución entonces continúa a la siguiente expresión "

"yield, donde el generador se suspende de nuevo y el valor de :token:"

"`expression_list` se retorna al invocador de :meth:`__next__`. Si el "

"generador termina sin producir otro valor, se genera una excepción :exc:"

"`StopIteration`."

#: ../Doc/reference/expressions.rst:545

msgid ""

"This method is normally called implicitly, e.g. by a :keyword:`for` loop, or "

"by the built-in :func:`next` function."

msgstr ""

"Este método es normalmente invocado implícitamente, por ejemplo, por un "

"bucle :keyword:`for` o por la función incorporada :func:`next`."

#: ../Doc/reference/expressions.rst:551

msgid ""

"Resumes the execution and \"sends\" a value into the generator function. "

"The *value* argument becomes the result of the current yield expression. "

"The :meth:`send` method returns the next value yielded by the generator, or "

"raises :exc:`StopIteration` if the generator exits without yielding another "

"value. When :meth:`send` is called to start the generator, it must be "

"called with :const:`None` as the argument, because there is no yield "

"expression that could receive the value."

msgstr ""

"Reanuda la ejecución y \"envía\" un valor dentro de la función generadora. "

"El argumento *value* se convierte en el resultado de la expresión yield "

"actual. El método :meth:`send` retorna el siguiente valor producido por el "

"generador o genera :exc:`StopIteration` si el generador termina sin producir "

"otro valor. Cuando se ejecuta :meth:`send` para comenzar el generador, debe "

"ser invocado con :const:`None` como el argumento, debido a que no hay "

"expresión yield que pueda recibir el valor."

#: ../Doc/reference/expressions.rst:562

msgid ""

"Raises an exception of type ``type`` at the point where the generator was "

"paused, and returns the next value yielded by the generator function. If "

"the generator exits without yielding another value, a :exc:`StopIteration` "

"exception is raised. If the generator function does not catch the passed-in "

"exception, or raises a different exception, then that exception propagates "

"to the caller."

msgstr ""

"Genera una excepción de tipo ``type`` en el punto donde el generador fue "

"pausado y retorna el siguiente valor producido por la función generadora. Si "

"el generador termina sin producir otro valor se genera una excepción :exc:"

"`StopIteration`. Si la función generadora no caza la excepción pasada o "

"genera una excepción diferente, entonces se propaga esa excepción al "

"invocador."

#: ../Doc/reference/expressions.rst:573

msgid ""

"Raises a :exc:`GeneratorExit` at the point where the generator function was "

"paused. If the generator function then exits gracefully, is already closed, "

"or raises :exc:`GeneratorExit` (by not catching the exception), close "

"returns to its caller. If the generator yields a value, a :exc:"

"`RuntimeError` is raised. If the generator raises any other exception, it "

"is propagated to the caller. :meth:`close` does nothing if the generator "

"has already exited due to an exception or normal exit."

msgstr ""

"Genera :exc:`GeneratorExit` en el punto donde la función generadora fue "

"pausada. Si la función generadora termina sin errores, está ya cerrada o "

"genera :exc:`GeneratorExit` (sin cazar la excepción), close retorna a su "

"invocador. Si el generador produce un valor, se genera un :exc:"

"`RuntimeError`. Si el generador genera cualquier otra excepción, es "

"propagado al invocador. :meth:`close` no hace nada si el generador ya fue "

"terminado debido a una excepción o una salida normal."

#: ../Doc/reference/expressions.rst:584

msgid "Examples"

msgstr "Ejemplos"

#: ../Doc/reference/expressions.rst:586

msgid ""

"Here is a simple example that demonstrates the behavior of generators and "

"generator functions::"

msgstr ""

"Aquí hay un ejemplo simple que demuestra el comportamiento de generadores y "

"funciones generadoras:"

#: ../Doc/reference/expressions.rst:613

msgid ""

"For examples using ``yield from``, see :ref:`pep-380` in \"What's New in "

"Python.\""

msgstr ""

"Para ejemplos usando ``yield from``, ver :ref:`pep-380` en \"Qué es nuevo en "

"Python.\""

#: ../Doc/reference/expressions.rst:619

msgid "Asynchronous generator functions"

msgstr "Funciones generadoras asincrónicas"

#: ../Doc/reference/expressions.rst:621

msgid ""

"The presence of a yield expression in a function or method defined using :"

"keyword:`async def` further defines the function as an :term:`asynchronous "

"generator` function."

msgstr ""

"La presencia de una expresión yield en una función o método definido usando :"

"keyword:`async def` adicionalmente define la función como una función :term:"

"`asynchronous generator`."

#: ../Doc/reference/expressions.rst:625

msgid ""

"When an asynchronous generator function is called, it returns an "

"asynchronous iterator known as an asynchronous generator object. That object "

"then controls the execution of the generator function. An asynchronous "

"generator object is typically used in an :keyword:`async for` statement in a "

"coroutine function analogously to how a generator object would be used in a :"

"keyword:`for` statement."

msgstr ""

"Cuando se invoca una función generadora asincrónica, retorna un iterador "

"asincrónico conocido como un objeto generador asincrónico. Este objeto "

"entonces controla la ejecución de la función generadora. Un objeto generador "

"asincrónico se usa típicamente en una sentencia :keyword:`async for` en una "

"función corrutina análogamente a como sería usado un objeto generador en una "

"sentencia :keyword:`for`."

#: ../Doc/reference/expressions.rst:632

msgid ""

"Calling one of the asynchronous generator's methods returns an :term:"

"`awaitable` object, and the execution starts when this object is awaited on. "

"At that time, the execution proceeds to the first yield expression, where it "

"is suspended again, returning the value of :token:`expression_list` to the "

"awaiting coroutine. As with a generator, suspension means that all local "

"state is retained, including the current bindings of local variables, the "

"instruction pointer, the internal evaluation stack, and the state of any "

"exception handling. When the execution is resumed by awaiting on the next "

"object returned by the asynchronous generator's methods, the function can "

"proceed exactly as if the yield expression were just another external call. "

"The value of the yield expression after resuming depends on the method which "

"resumed the execution. If :meth:`~agen.__anext__` is used then the result "

"is :const:`None`. Otherwise, if :meth:`~agen.asend` is used, then the result "

"will be the value passed in to that method."

msgstr ""

"Invocar uno de los métodos de un generador asincrónico retorna un objeto :"

"term:`awaitable` y la ejecución comienza cuando este objeto es esperado. En "

"ese momento, la ejecución avanza a la primera expresión yield, donde es "

"suspendida de nuevo, retornando el valor de :token:`expression_list` a la "

"corrutina en espera. Como con un generador, la suspensión significa que todo "

"el estado local es retenido, incluyendo los enlaces actuales de variables "

"locales, el puntero de instrucción, la pila de evaluación interna y el "

"estado de cualquier manejo de excepción. Cuando se reanuda la ejecución al "

"espera al siguiente objeto retornado por los métodos del generador "

"asincrónico, la función puede avanzar exactamente igual que si la expresión "

"yield fuera otra invocación externa. El valor de la expresión yield después "

"de la reanudación dependen del método que ha resumido la ejecución. Si se "

"usa :meth:`~agen.__anext__` entonces el resultado es :const:`None`. De otra "

"forma, si se usa :meth:`~agen.asend`, entonces el resultado será el valor "