6. Expresiones
**************

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

**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

   name ::= othername

y no han sido dadas semánticas, las semánticas de esta forma de "name"
son las mismas que para "othername".


6.1. Conversiones aritméticas
=============================

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:

* Si cualquiera de los argumentos es un número complejo, el otro es
  convertido a complejo;

* otherwise, if either argument is a floating-point number, the other
  is converted to floating point;

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

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.


6.2. Átomos
===========

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:

   atom      ::= identifier | literal | enclosure
   enclosure ::= parenth_form | list_display | dict_display | set_display
                 | generator_expression | yield_atom


6.2.1. Identificadores (Nombres)
--------------------------------

Un identificador encontrándose como un átomo es un nombre. Vea la
sección Identificadores y palabras clave para la definición léxica y
la sección Nombres y vínculos para documentación de nombrar y
vincular.

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 "NameError".


6.2.1.1. 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 *private name* of that class.

Ver también: The class specifications.

More precisely, private names are transformed to a longer form before
code is generated for them.  If the transformed name is longer than
255 characters, implementation-defined truncation may happen.

The transformation is independent of the syntactical context in which
the identifier is used but only the following private identifiers are
mangled:

* Any name used as the name of a variable that is assigned or read or
  any name of an attribute being accessed.

  The "__name__" attribute of nested functions, classes, and type
  aliases is however not mangled.

* The name of imported modules, e.g., "__spam" in "import __spam". If
  the module is part of a package (i.e., its name contains a dot), the
  name is *not* mangled, e.g., the "__foo" in "import __foo.bar" is
  not mangled.

* The name of an imported member, e.g., "__f" in "from spam import
  __f".

The transformation rule is defined as follows:

* The class name, with leading underscores removed and a single
  leading underscore inserted, is inserted in front of the identifier,
  e.g., the identifier "__spam" occurring in a class named "Foo",
  "_Foo" or "__Foo" is transformed to "_Foo__spam".

* If the class name consists only of underscores, the transformation
  is the identity, e.g., the identifier "__spam" occurring in a class
  named "_" or "__" is left as is.


6.2.2. Literales
----------------

Python soporta literales de cadenas de caracteres y bytes y varios
literales numéricos:

   literal ::= stringliteral | bytesliteral
               | integer | floatnumber | imagnumber

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 Literales for details.

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.


6.2.3. Formas entre paréntesis
------------------------------

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

   parenth_form ::= "(" [starred_expression] ")"

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.

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).

Note that tuples are not formed by the parentheses, but rather by use
of the comma.  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.


6.2.4. Despliegues para listas, conjuntos y diccionarios
--------------------------------------------------------

Para construir una lista, un conjunto o un diccionario, Python provee
sintaxis especial denominada "despliegue", cada una de ellas en dos
sabores:

* los contenidos del contenedor son listados explícitamente o

* son calculados mediante un conjunto de instrucciones de bucle y
  filtrado, denominadas una *comprehension*.

Los elementos comunes de sintaxis para las comprensiones son:

   comprehension ::= assignment_expression comp_for
   comp_for      ::= ["async"] "for" target_list "in" or_test [comp_iter]
   comp_iter     ::= comp_for | comp_if
   comp_if       ::= "if" or_test [comp_iter]

La comprensión consiste en una única expresión seguida por al menos
una cláusula "for" y cero o más cláusulas "for" o "if". En este caso,
los elementos del nuevo contenedor son aquellos que serían producidos
mediante considerar cada una de las cláusulas "for" o "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.

Sin embargo, aparte de la expresión iterable en la cláusula "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.

La expresión iterable en la cláusula más a la izquierda "for" es
evaluada directamente en el alcance anidado y luego pasada como un
argumento al alcance implícitamente anidado. Subsecuentes cláusulas
"for" y cualquier condición de filtro en la cláusula "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)]".

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.

Since Python 3.6, in an "async def" function, an "async for" clause
may be used to iterate over a *asynchronous iterator*. A comprehension
in an "async def" function may consist of either a "for" or "async
for" clause following the leading expression, may contain additional
"for" or "async for" clauses, and may also use "await" expressions.

If a comprehension contains "async for" clauses, or if it contains
"await" expressions or other asynchronous comprehensions anywhere
except the iterable expression in the leftmost "for" clause, it is
called an *asynchronous comprehension*. An asynchronous comprehension
may suspend the execution of the coroutine function in which it
appears. See also **PEP 530**.

Added in version 3.6: Fueron introducidas las comprensiones
asincrónicas.

Distinto en la versión 3.8: Prohibidas "yield" y "yield from" en el
alcance implícitamente anidado.

Distinto en la versión 3.11: Asynchronous comprehensions are now
allowed inside comprehensions in asynchronous functions. Outer
comprehensions implicitly become asynchronous.


6.2.5. Despliegues de lista
---------------------------

Un despliegue de lista es una serie de expresiones posiblemente vacía
encerrada entre corchetes:

   list_display ::= "[" [starred_list | comprehension] "]"

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.


6.2.6. Despliegues de conjuntos
-------------------------------

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:

   set_display ::= "{" (starred_list | comprehension) "}"

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.

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


6.2.7. Despliegues de diccionario
---------------------------------

A dictionary display is a possibly empty series of dict items
(key/value pairs) enclosed in curly braces:

   dict_display       ::= "{" [dict_item_list | dict_comprehension] "}"
   dict_item_list     ::= dict_item ("," dict_item)* [","]
   dict_item          ::= expression ":" expression | "**" or_expr
   dict_comprehension ::= expression ":" expression comp_for

Un despliegue de diccionario produce un nuevo objeto diccionario.

If a comma-separated sequence of dict items 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 value.  This means that you can specify the same key
multiple times in the dict item list, and the final dictionary's value
for that key will be the last one given.

A double asterisk "**" denotes *dictionary unpacking*. Its operand
must be a *mapping*.  Each mapping item is added to the new
dictionary.  Later values replace values already set by earlier dict
items and earlier dictionary unpackings.

Added in version 3.5: Desempaquetar en despliegues de diccionarios,
originalmente propuesto por **PEP 448**.

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.

Restrictions on the types of the key values are listed earlier in
section Jerarquía de tipos estándar.  (To summarize, the key type
should be *hashable*, which excludes all mutable objects.)  Clashes
between duplicate keys are not detected; the last value (textually
rightmost in the display) stored for a given key value prevails.

Distinto en la versión 3.8: 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**.


6.2.8. Expresiones de generador
-------------------------------

Una expresión de generador es una notación compacta de generador en
paréntesis:

   generator_expression ::= "(" expression comp_for ")"

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.

Las variables usadas en la expresión de generador son evaluadas
perezosamente cuando se ejecuta el método "__next__()" para el objeto
generador (de la misma forma que los generadores normales). Sin
embargo, la expresión iterable en la cláusula "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 "for" y cualquier condición en la cláusula
"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))".

Los paréntesis pueden ser omitidos en ejecuciones con un solo
argumento. Vea la sección Invocaciones para más detalles.

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.

Si una expresión de generador contiene cláusulas "async for" o
expresiones "await", se ejecuta una *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 Iteradores asíncronos).

Added in version 3.6: Las expresiones de generador asincrónico fueron
introducidas.

Distinto en la versión 3.7: Antes de Python 3.7, las expresiones de
generador asincrónico podrían aparecer sólo en corrutinas "async def".
Desde 3.7, cualquier función puede usar expresiones de generador
asincrónico.

Distinto en la versión 3.8: Prohibidas "yield" y "yield from" en el
alcance implícitamente anidado.


6.2.9. Expresiones yield
------------------------

   yield_atom       ::= "(" yield_expression ")"
   yield_from       ::= "yield" "from" expression
   yield_expression ::= "yield" expression_list | yield_from

The yield expression is used when defining a *generator* function or
an *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 function, and
using it in an "async def" function's body causes that coroutine
function to be an asynchronous generator function. For example:

   def gen():  # defines a generator function
       yield 123

   async def agen(): # defines an asynchronous generator function
       yield 123

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.

Distinto en la versión 3.8: Expresiones yield prohibidas en los
ámbitos anidados implícitamente utilizados para implementar
comprensiones y expresiones de generador.

Las funciones generadoras son descritas a continuación, mientras que
las funciones generadoras asincrónicas son descritas separadamente en
la sección Funciones generadoras asincrónicas.

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
"expression_list" to the generator's caller, or "None" if
"expression_list" is omitted. 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 "__next__()" is used (typically via either
a "for" or the "next()" builtin) then the result is "None".
Otherwise, if "send()" is used, then the result will be the value
passed in to that method.

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.

Las expresiones yield están permitidas en cualquier lugar en un
constructo "try". Si el generador no es reanudado antes de finalizar
(alcanzando un recuento de referencia cero o colectando basura), el
método generador-iterador "close()" será invocado, permitiendo la
ejecución de cualquier cláusula "finally" pendiente.

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 "send()" y cualquier excepción pasada con
"throw()" se pasan al iterador subyacente si tiene los métodos
apropiados. Si este no es el caso, entonces "send()" lanzará
"AttributeError" o "TypeError", mientras que "throw()" solo lanzará la
excepción pasada inmediatamente.

Cuando el iterador subyacente está completo, el atributo "value" de la
instancia "StopIteration" generada se convierte en el valor de la
expresión yield. Puede ser establecido explícitamente al generar
"StopIteration" o automáticamente cuando el subiterador es un
generador (retornando un valor del subgenerador).

Distinto en la versión 3.3: Añadido "yield from <expr>" para delegar
el control de flujo a un subiterador.

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.

Ver también:

  **PEP 255** - Generadores Simples
     La propuesta para añadir generadores y la sentencia "yield" a
     Python.

  **PEP 342** - Corrutinas mediante Generadores Mejorados
     La propuesta para mejorar la API y la sintaxis de generadores,
     haciéndolos utilizables como corrutinas simples.

  **PEP 380** - Sintaxis para Delegar a un Subgenerador
     The proposal to introduce the "yield_from" syntax, making
     delegation to subgenerators easy.

  **PEP 525**- Generadores Asincrónicos
     La propuesta que expandió **PEP 492** añadiendo capacidades de
     generador a las funciones corrutina.


6.2.9.1. Métodos generador-iterador
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

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.

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 "ValueError".

generator.__next__()

   Starts the execution of a generator function or resumes it at the
   last executed yield expression.  When a generator function is
   resumed with a "__next__()" method, the current yield expression
   always evaluates to "None".  The execution then continues to the
   next yield expression, where the generator is suspended again, and
   the value of the "expression_list" is returned to "__next__()"'s
   caller.  If the generator exits without yielding another value, a
   "StopIteration" exception is raised.

   Este método es normalmente invocado implícitamente, por ejemplo,
   por un bucle "for" o por la función incorporada "next()".

generator.send(value)

   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 "send()" retorna el siguiente
   valor producido por el generador o genera "StopIteration" si el
   generador termina sin producir otro valor. Cuando se ejecuta
   "send()" para comenzar el generador, debe ser invocado con "None"
   como el argumento, debido a que no hay expresión yield que pueda
   recibir el valor.

generator.throw(value)
generator.throw(type[, value[, traceback]])

   Raises an exception 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
   "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.

   In typical use, this is called with a single exception instance
   similar to the way the "raise" keyword is used.

   For backwards compatibility, however, the second signature is
   supported, following a convention from older versions of Python.
   The *type* argument should be an exception class, and *value*
   should be an exception instance. If the *value* is not provided,
   the *type* constructor is called to get an instance. If *traceback*
   is provided, it is set on the exception, otherwise any existing
   "__traceback__" attribute stored in *value* may be cleared.

   Distinto en la versión 3.12: The second signature (type[, value[,
   traceback]]) is deprecated and may be removed in a future version
   of Python.

generator.close()

   Genera "GeneratorExit" en el punto donde la función generadora fue
   pausada. Si la función generadora termina sin errores, está ya
   cerrada o genera "GeneratorExit" (sin cazar la excepción), close
   retorna a su invocador. Si el generador produce un valor, se genera
   un "RuntimeError". Si el generador genera cualquier otra excepción,
   es propagado al invocador. "close()" no hace nada si el generador
   ya fue terminado debido a una excepción o una salida normal.


6.2.9.2. Ejemplos
~~~~~~~~~~~~~~~~~

Aquí hay un ejemplo simple que demuestra el comportamiento de
generadores y funciones generadoras:

   >>> def echo(value=None):
   ...     print("Execution starts when 'next()' is called for the first time.")
   ...     try:
   ...         while True:
   ...             try:
   ...                 value = (yield value)
   ...             except Exception as e:
   ...                 value = e
   ...     finally:
   ...         print("Don't forget to clean up when 'close()' is called.")
   ...
   >>> generator = echo(1)
   >>> print(next(generator))
   Execution starts when 'next()' is called for the first time.
   1
   >>> print(next(generator))
   None
   >>> print(generator.send(2))
   2
   >>> generator.throw(TypeError, "spam")
   TypeError('spam',)
   >>> generator.close()
   Don't forget to clean up when 'close()' is called.

Para ejemplos usando "yield from", ver PEP 380: Sintaxis para delegar
en un subgenerador en "Qué es nuevo en Python."


6.2.9.3. Funciones generadoras asincrónicas
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

La presencia de una expresión yield en una función o método definido
usando "async def" adicionalmente define la función como una función
*asynchronous generator*.

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
"async for" en una función corrutina análogamente a como sería usado
un objeto generador en una sentencia "for".

Calling one of the asynchronous generator's methods returns an
*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
"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 "__anext__()" is used then the result
is "None". Otherwise, if "asend()" is used, then the result will be
the value passed in to that method.

Si un generador asincrónico sale temprano por "break", la tarea de la
persona que llama se cancela u otras excepciones, el código de
limpieza asíncrono del generador se ejecutará y posiblemente lanzará
excepciones o accederá a variables de contexto en un contexto
inesperado, tal vez después de la vida útil de las tareas de las que
depende, o durante el cierre del ciclo de eventos cuando se llama al
gancho de recolección de basura del generador asíncrono. Para evitar
esto, la persona que llama debe cerrar explícitamente el generador
asíncrono llamando al método "aclose()" para finalizar el generador y
finalmente desconectarlo del bucle de eventos.

En una función generadora asincrónica, las expresiones yield están
permitidas en cualquier lugar de un constructo "try". Sin embargo, si
un generador asincrónico no es reanudado antes de finalizar
(alcanzando un contador de referencia cero o recogiendo basura),
entonces una expresión yield dentro de un constructo "try" podría
fallar al ejecutar cláusulas "finally" pendientes. En este caso, es
responsabilidad del bucle de eventos o del planificador ejecutando el
generador asincrónico invocar el método "aclose()" del generador-
iterador asincrónico y ejecutar el objeto corrutina resultante,
permitiendo así la ejecución de cualquier cláusula "finally"
pendiente.

Para encargarse de la finalización tras la finalización del ciclo de
eventos, un ciclo de eventos debe definir una función *finalizer* que
tome un generador-iterador asíncrono y presumiblemente llame a
"aclose()" y ejecute la rutina. Este *finalizer* se puede registrar
llamando a "sys.set_asyncgen_hooks()". Cuando se itera por primera
vez, un generador-iterador asíncrono almacenará el *finalizer*
registrado para ser llamado al finalizar. Para obtener un ejemplo de
referencia de un método *finalizer*, consulte la implementación de
"asyncio.Loop.shutdown_asyncgens" en Lib/asyncio/base_events.py.

La expresión "yield from <expr>" es un error de sintaxis cuando es
usada en una función generadora asincrónica.


6.2.9.4. Métodos asincrónicos de generador-iterador
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Esta subsección describe los métodos de un generador iterador
asincrónico, los cuales son usados para controlar la ejecución de una
función generadora.

coroutine agen.__anext__()

   Returns an awaitable which when run starts to execute the
   asynchronous generator or resumes it at the last executed yield
   expression.  When an asynchronous generator function is resumed
   with an "__anext__()" method, the current yield expression always
   evaluates to "None" in the returned awaitable, which when run will
   continue to the next yield expression. The value of the
   "expression_list" of the yield expression is the value of the
   "StopIteration" exception raised by the completing coroutine.  If
   the asynchronous generator exits without yielding another value,
   the awaitable instead raises a "StopAsyncIteration" exception,
   signalling that the asynchronous iteration has completed.

   Este método es invocado normalmente de forma implícita por un bucle
   "async for".

coroutine agen.asend(value)

   Retorna un esperable el cual cuando corre reanuda la ejecución del
   generador asincrónico. Como el método "send()" para un generador,
   este "envía" un valor a la función generadora asincrónica y el
   argumento *value* se convierte en el resultado de la expresión
   yield actual. El esperable retornado por el método "asend()"
   retornará el siguiente valor producido por el generador como el
   valor de la "StopIteration" generada o genera "StopAsyncIteration"
   si el generador asincrónico termina sin producir otro valor. Cuando
   se invoca "asend()" para empezar el generador asincrónico, debe ser
   invocado con "None" como argumento, porque no hay expresión yield
   que pueda recibir el valor.

coroutine agen.athrow(value)
coroutine agen.athrow(type[, value[, traceback]])

   Retorna un esperable que genera una excepción de tipo "type" en el
   punto donde el generador asincrónico fue pausado y retorna el
   siguiente valor producido por la función generadora como el valor
   de la excepción "StopIteration" generada. Si el generador
   asincrónico termina sin producir otro valor, el esperable genera
   una excepción "StopAsyncIteration". Si la función generadora no
   caza la excepción pasada o genera una excepción diferente, entonces
   cuando se ejecuta el esperable esa excepción se propaga al
   invocador del esperable.

   Distinto en la versión 3.12: The second signature (type[, value[,
   traceback]]) is deprecated and may be removed in a future version
   of Python.

coroutine agen.aclose()

   Retorna un esperable que cuando corre lanza un "GeneratorExit" a la
   función generadora asincrónica en el punto donde fue pausada. Si la
   función generadora asincrónica termina exitosamente, ya está
   cerrada o genera  "GeneratorExit" (sin cazar la excepción), el
   esperable retornado lanzará una excepción "StopIteration". Otros
   esperables retornados por subsecuentes invocaciones al generador
   asincrónico lanzarán una excepción "StopAsyncIteration". Si el
   generador asincrónico produce un valor, el esperable genera un
   "RuntimeError". Si el generador asincrónico genera cualquier otra
   excepción, esta es propagada al invocador del esperable. Si el
   generador asincrónico ha terminado debido a una excepción o una
   terminación normal, entonces futuras invocaciones a "aclose()"
   retornarán un esperable que no hace nada.


6.3. Primarios
==============

Los primarios representan las operaciones más fuertemente ligadas al
lenguaje. Su sintaxis es:

   primary ::= atom | attributeref | subscription | slicing | call


6.3.1. Referencias de atributos
-------------------------------

Una referencia de atributo es un primario seguido de un punto y un
nombre:

   attributeref ::= primary "." identifier

The primary must evaluate to an object of a type that supports
attribute references, which most objects do.  This object is then
asked to produce the attribute whose name is the identifier. The type
and value produced is determined by the object.  Multiple evaluations
of the same attribute reference may yield different objects.

This production can be customized by overriding the
"__getattribute__()" method or the "__getattr__()" method.  The
"__getattribute__()" method is called first and either returns a value
or raises "AttributeError" if the attribute is not available.

If an "AttributeError" is raised and the object has a "__getattr__()"
method, that method is called as a fallback.


6.3.2. Suscripciones
--------------------

The subscription of an instance of a container class will generally
select an element from the container. The subscription of a *generic
class* will generally return a GenericAlias object.

   subscription ::= primary "[" expression_list "]"

When an object is subscripted, the interpreter will evaluate the
primary and the expression list.

The primary must evaluate to an object that supports subscription. An
object may support subscription through defining one or both of
"__getitem__()" and "__class_getitem__()". When the primary is
subscripted, the evaluated result of the expression list will be
passed to one of these methods. For more details on when
"__class_getitem__" is called instead of "__getitem__", see
__class_getitem__ frente a __getitem__.

If the expression list contains at least one comma, it will evaluate
to a "tuple" containing the items of the expression list. Otherwise,
the expression list will evaluate to the value of the list's sole
member.

For built-in objects, there are two types of objects that support
subscription via "__getitem__()":

1. Mappings. If the primary is a *mapping*, the expression list must
   evaluate to an object whose value is one of the keys of the
   mapping, and the subscription selects the value in the mapping that
   corresponds to that key. An example of a builtin mapping class is
   the "dict" class.

2. Sequences. If the primary is a *sequence*, the expression list must
   evaluate to an "int" or a "slice" (as discussed in the following
   section). Examples of builtin sequence classes include the "str",
   "list" and "tuple" classes.

The formal syntax makes no special provision for negative indices in
*sequences*. However, built-in sequences all provide a "__getitem__()"
method that interprets negative indices by adding the length of the
sequence to the index so that, for example, "x[-1]" selects the last
item of "x". The resulting value must be a nonnegative integer less
than the number of items in the sequence, and the subscription selects
the item whose index is that value (counting from zero). Since the
support for negative indices and slicing occurs in the object's
"__getitem__()" method, subclasses overriding this method will need to
explicitly add that support.

A "string" is a special kind of sequence whose items are *characters*.
A character is not a separate data type but a string of exactly one
character.


6.3.3. Segmentos
----------------

Un segmento selecciona un rango de elementos en una objeto secuencia
(ej., una cadena de caracteres, tupla o lista). Los segmentos pueden
ser usados como expresiones o como objetivos en asignaciones o
sentencias "del". La sintaxis para un segmento:

   slicing      ::= primary "[" slice_list "]"
   slice_list   ::= slice_item ("," slice_item)* [","]
   slice_item   ::= expression | proper_slice
   proper_slice ::= [lower_bound] ":" [upper_bound] [ ":" [stride] ]
   lower_bound  ::= expression
   upper_bound  ::= expression
   stride       ::= expression

Hay ambigüedad en la sintaxis formal aquí: todo lo que parezca una
expresión de lista también parece una segmento de lista, así que
cualquier subscripción puede ser interpretada como un segmento. En
lugar de complicar aún más la sintaxis, esta es desambiguada
definiendo que en este caso la interpretación como una subscripción
toma prioridad sobre la interpretación como un segmento (este es el
caso si el segmento de lista no contiene un segmento adecuado).

The semantics for a slicing are as follows.  The primary is indexed
(using the same "__getitem__()" method as normal subscription) with a
key that is constructed from the slice list, as follows.  If the slice
list contains at least one comma, the key is a tuple containing the
conversion of the slice items; otherwise, the conversion of the lone
slice item is the key.  The conversion of a slice item that is an
expression is that expression.  The conversion of a proper slice is a
slice object (see section Jerarquía de tipos estándar) whose "start",
"stop" and "step" attributes are the values of the expressions given
as lower bound, upper bound and stride, respectively, substituting
"None" for missing expressions.


6.3.4. Invocaciones
-------------------

Una invocación invoca un objeto invocable (ej., una *function*) con
una serie posiblemente vacía de *argumentos*:

   call                 ::= primary "(" [argument_list [","] | comprehension] ")"
   argument_list        ::= positional_arguments ["," starred_and_keywords]
                       ["," keywords_arguments]
                     | starred_and_keywords ["," keywords_arguments]
                     | keywords_arguments
   positional_arguments ::= positional_item ("," positional_item)*
   positional_item      ::= assignment_expression | "*" expression
   starred_and_keywords ::= ("*" expression | keyword_item)
                            ("," "*" expression | "," keyword_item)*
   keywords_arguments   ::= (keyword_item | "**" expression)
                          ("," keyword_item | "," "**" expression)*
   keyword_item         ::= identifier "=" expression

Una coma final opcional puede estar presente después de los argumentos
posicionales y de palabra clave pero no afecta a las semánticas.

The primary must evaluate to a callable object (user-defined
functions, built-in functions, methods of built-in objects, class
objects, methods of class instances, and all objects having a
"__call__()" method are callable).  All argument expressions are
evaluated before the call is attempted.  Please refer to section
Definiciones de funciones for the syntax of formal *parameter* lists.

If keyword arguments are present, they are first converted to
positional arguments, as follows.  First, a list of unfilled slots is
created for the formal parameters.  If there are N positional
arguments, they are placed in the first N slots.  Next, for each
keyword argument, the identifier is used to determine the
corresponding slot (if the identifier is the same as the first formal
parameter name, the first slot is used, and so on).  If the slot is
already filled, a "TypeError" exception is raised. Otherwise, the
argument is placed in the slot, filling it (even if the expression is
"None", it fills the slot).  When all arguments have been processed,
the slots that are still unfilled are filled with the corresponding
default value from the function definition.  (Default values are
calculated, once, when the function is defined; thus, a mutable object
such as a list or dictionary used as default value will be shared by
all calls that don't specify an argument value for the corresponding
slot; this should usually be avoided.)  If there are any unfilled
slots for which no default value is specified, a "TypeError" exception
is raised.  Otherwise, the list of filled slots is used as the
argument list for the call.

**Detalles de implementación de CPython:** Una implementación puede
proveer funciones incorporadas cuyos argumentos posicionales no tienen
nombres, incluso si son "nombrados" a efectos de documentación y los
cuales por consiguiente no pueden ser suplidos por palabras clave. En
CPython, este es el caso para funciones implementadas en C que usan
"PyArg_ParseTuple()" para analizar sus argumentos.

Si hay más argumentos posicionales que ranuras formales de parámetros,
se genera una excepción "TypeError", a no ser que un parámetro formal
usando la sintaxis "*identifier" se encuentre presente; en este caso,
ese parámetro formal recibe una tupla conteniendo los argumentos
posicionales sobrantes (o una tupla vacía su no hay argumentos
posicionales sobrantes).

Si un argumento de palabra clave no corresponde a un nombre de
parámetro formal, se genera una excepción "TypeError", a no ser que un
parámetro formal usando la sintaxis "**identifier" esté presente; en
este caso, ese parámetro formal recibe un diccionario que contiene los
argumentos de palabra clave sobrantes (usando las palabras clave como
claves y los valores de argumento como sus valores correspondientes),
o un (nuevo) diccionario vacío si no hay argumentos de palabra clave
sobrantes.

Si la sintaxis "*expression" aparece en la invocación de función,
"expression" debe evaluar a un *iterable*. Elementos de esos iterables
son tratados como si fueran argumentos posicionales adicionales. Para
la invocación "f(x1, x2, *y, x3, x4)", si *y* evalúa a una secuencia
*y1*, ..., *yM*, equivale a una invocación con M+4 argumentos
posicionales *x1*, *x2*, *y1*, ..., *yM*, *x3*, *x4*.

Una consecuencia de esto es que aunque la sintaxis "*expression" puede
aparecer *después* de argumentos de palabra clave explícitos, es
procesada *antes* de los argumentos de palabra clave (y cualquiera de
los argumentos "*expression" -- ver abajo). Así que:

   >>> def f(a, b):
   ...     print(a, b)
   ...
   >>> f(b=1, *(2,))
   2 1
   >>> f(a=1, *(2,))
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: f() got multiple values for keyword argument 'a'
   >>> f(1, *(2,))
   1 2

It is unusual for both keyword arguments and the "*expression" syntax
to be used in the same call, so in practice this confusion does not
often arise.

If the syntax "**expression" appears in the function call,
"expression" must evaluate to a *mapping*, the contents of which are
treated as additional keyword arguments. If a parameter matching a key
has already been given a value (by an explicit keyword argument, or
from another unpacking), a "TypeError" exception is raised.

When "**expression" is used, each key in this mapping must be a
string. Each value from the mapping is assigned to the first formal
parameter eligible for keyword assignment whose name is equal to the
key. A key need not be a Python identifier (e.g. ""max-temp °F"" is
acceptable, although it will not match any formal parameter that could
be declared). If there is no match to a formal parameter the key-value
pair is collected by the "**" parameter, if there is one, or if there
is not, a "TypeError" exception is raised.

No pueden ser usados parámetros formales usando la sintaxis
"*identifier" o "**identifier" como ranuras de argumentos posicionales
o como nombres de argumentos de palabra clave.

Distinto en la versión 3.5: Las invocaciones de función aceptan
cualquier número de desempaquetados "*" y "**", los argumentos
posicionales pueden seguir a desempaquetados de iterable ("*") y los
argumentos de palabra clave pueden seguir a desempaquetados de
diccionario ("*"). Originalmente propuesto por **PEP 448**.

Una invocación siempre retorna algún valor, posiblemente "None", a no
ser que genere una excepción. Cómo se calcula este valor depende del
tipo del objeto invocable.

Si es---

una función definida por el usuario:
   Se ejecuta el bloque de código para la función, pasándole la lista
   de argumentos. Lo primero que hace el bloque de código es enlazar
   los parámetros formales a los argumentos; esto es descrito en la
   sección Definiciones de funciones. Cuando el bloque de código
   ejecuta una sentencia "return", esto especifica el valor de retorno
   de la invocación de función.

una función o método incorporado:
   El resultado depende del intérprete; ver Funciones incorporadas
   para las descripciones de funciones y métodos incorporados.

un objeto de clase:
   Se retorna una nueva instancia de esa clase.

un método de una instancia de clase:
   Se invoca la función definida por el usuario correspondiente, con
   una lista de argumentos con un largo uno mayor que la lista de
   argumentos de la invocación: la instancia se convierte en el primer
   argumento.

una instancia de clase:
   The class must define a "__call__()" method; the effect is then the
   same as if that method was called.


6.4. Expresión await
====================

Suspende la ejecución de *coroutine* o un objeto *awaitable*. Puede
ser usado sólo dentro de una *coroutine function*.

   await_expr ::= "await" primary

Added in version 3.5.


6.5. El operador de potencia
============================

El operador de potencia se vincula más estrechamente que los
operadores unarios a su izquierda; se vincula con menos fuerza que los
operadores unarios a su derecha. La sintaxis es:

   power ::= (await_expr | primary) ["**" u_expr]

Por lo tanto, en una secuencia sin paréntesis de operadores unarios y
de potencia, los operadores son evaluados desde la derecha a la
izquierda (este no se constriñe al orden de evaluación para los
operandos): "-1**2" resulta en "-1".

El operador de potencia tiene las mismas semánticas que la función
incorporada "pow()" cuando se invoca con dos argumentos: este produce
su argumento de la izquierda elevado a la potencia de su argumento de
la derecha. Los argumentos numéricos se convierten primero en un tipo
común y el resultado es de ese tipo.

Para operandos int, el resultado tiene el mismo tipo que los operandos
a no ser que el segundo argumento sea negativo; en ese caso, todos los
argumentos son convertidos a float y se entrega un resultado float.
Por ejemplo, "10**2" retorna "100", pero "10**-2" retorna "0.01".

Elevar "0.0" a una potencia negativa resulta en un
"ZeroDivisionError". Elevar un número negativo a una potencia
fraccional resulta en un número "complex". (En versiones anteriores se
genera un "ValueError".)

This operation can be customized using the special "__pow__()" and
"__rpow__()" methods.


6.6. Aritmética unaria y operaciones bit a bit
==============================================

Toda la aritmética unaria y las operaciones bit a bit tienen la misma
prioridad:

   u_expr ::= power | "-" u_expr | "+" u_expr | "~" u_expr

The unary "-" (minus) operator yields the negation of its numeric
argument; the operation can be overridden with the "__neg__()" special
method.

The unary "+" (plus) operator yields its numeric argument unchanged;
the operation can be overridden with the "__pos__()" special method.

The unary "~" (invert) operator yields the bitwise inversion of its
integer argument.  The bitwise inversion of "x" is defined as
"-(x+1)".  It only applies to integral numbers or to custom objects
that override the "__invert__()" special method.

En todos los tres casos, si el argumento no tiene el tipo apropiado,
se genera una excepción "TypeError".


6.7. Operaciones aritméticas binarias
=====================================

Las operaciones aritméticas binarias tienen los niveles convencionales
de prioridad. Tenga en cuenta que algunas de esas operaciones también
aplican a ciertos tipos no numéricos. Aparte del operador de potencia,
hay sólo dos niveles, uno para operadores multiplicativos y uno para
aditivos:

   m_expr ::= u_expr | m_expr "*" u_expr | m_expr "@" m_expr |
              m_expr "//" u_expr | m_expr "/" u_expr |
              m_expr "%" u_expr
   a_expr ::= m_expr | a_expr "+" m_expr | a_expr "-" m_expr

El operador "*" (multiplicación) produce el producto de sus
argumentos. Los argumentos pueden ser ambos números, o un argumento
debe ser un entero y el otro debe ser una secuencia. En el primer
caso, los números se convierten a un tipo común y luego son
multiplicados. En el segundo caso, se realiza una repetición de
secuencia; un factor de repetición negativo produce una secuencia
vacía.

This operation can be customized using the special "__mul__()" and
"__rmul__()" methods.

El operador "@" (en) está destinado a ser usado para multiplicación de
matrices. Ningún tipo incorporado en Python implementa este operador.

This operation can be customized using the special "__matmul__()" and
"__rmatmul__()" methods.

Added in version 3.5.

Los operadores "/" (división) y "//" (división entera a la baja)
producen el cociente de sus argumentos. Los argumentos numéricos son
primero convertidos a un tipo común. La división entre enteros
producen un número de punto flotante, mientras que la división entera
a la baja entre enteros resulta en un entero; el resultado es aquel de
una división matemática con la función 'floor' aplicada al resultado.
Dividir entre 0 genera la excepción "ZeroDivisionError".

The division operation can be customized using the special
"__truediv__()" and "__rtruediv__()" methods. The floor division
operation can be customized using the special "__floordiv__()" and
"__rfloordiv__()" methods.

The "%" (modulo) operator yields the remainder from the division of
the first argument by the second.  The numeric arguments are first
converted to a common type.  A zero right argument raises the
"ZeroDivisionError" exception.  The arguments may be floating-point
numbers, e.g., "3.14%0.7" equals "0.34" (since "3.14" equals "4*0.7 +
0.34".)  The modulo operator always yields a result with the same sign
as its second operand (or zero); the absolute value of the result is
strictly smaller than the absolute value of the second operand [1].

El operador de división entera a la baja y el de módulo están
conectados por la siguiente identidad: "x == (x//y)*y + (x%y)". La
división entera a la baja y el módulo también están conectadas por la
función incorporada "divmod()": "divmod(x, y) == (x//y, x%y)". [2].

Adicionalmente a realizar la operación módulo en números, el operador
"%" también está sobrecargado por objetos cadena de caracteres para
realizar formateo de cadenas al estilo antiguo (también conocido como
interpolación). La sintaxis para el formateo de cadenas está descrita
en la Referencia de la Biblioteca de Python, sección Formateo de
cadenas al estilo *printf*.

The *modulo* operation can be customized using the special "__mod__()"
and "__rmod__()" methods.

The floor division operator, the modulo operator, and the "divmod()"
function are not defined for complex numbers.  Instead, convert to a
floating-point number using the "abs()" function if appropriate.

El operador "+" (adición) produce la suma de sus argumentos. Los
argumentos deben ser ambos números o ambos secuencias del mismo tipo.
En el primer caso, los números son convertidos a un tipo común y luego
sumados. En el segundo caso, las secuencias son concatenadas.

This operation can be customized using the special "__add__()" and
"__radd__()" methods.

El operador "-" (resta) produce la diferencia de sus argumentos. Los
argumentos numéricos son primero convertidos a un tipo común.

This operation can be customized using the special "__sub__()" and
"__rsub__()" methods.


6.8. Operaciones de desplazamiento
==================================

Las operaciones de desplazamiento tienen menos prioridad que las
operaciones aritméticas:

   shift_expr ::= a_expr | shift_expr ("<<" | ">>") a_expr

Estos operadores aceptan enteros como argumentos. Ellos desplazan el
primer argumento a la izquierda o derecha el número de dígitos dados
por el segundo argumento.

The left shift operation can be customized using the special
"__lshift__()" and "__rlshift__()" methods. The right shift operation
can be customized using the special "__rshift__()" and "__rrshift__()"
methods.

Un desplazamiento de *n* bits hacia la derecha se define como una
división entera a la baja entre "pow(2,n)". Un desplazamiento de *n*
bits hacia la izquierda se define como una multiplicación por
"pow(2,n)".


6.9. Operaciones bit a bit binarias
===================================

Cada una de las tres operaciones de bits binarias tienen diferente
nivel de prioridad:

   and_expr ::= shift_expr | and_expr "&" shift_expr
   xor_expr ::= and_expr | xor_expr "^" and_expr
   or_expr  ::= xor_expr | or_expr "|" xor_expr

The "&" operator yields the bitwise AND of its arguments, which must
be integers or one of them must be a custom object overriding
"__and__()" or "__rand__()" special methods.

The "^" operator yields the bitwise XOR (exclusive OR) of its
arguments, which must be integers or one of them must be a custom
object overriding "__xor__()" or "__rxor__()" special methods.

The "|" operator yields the bitwise (inclusive) OR of its arguments,
which must be integers or one of them must be a custom object
overriding "__or__()" or "__ror__()" special methods.


6.10. Comparaciones
===================

A diferencia de C, todas las operaciones de comparación en Python
tienen la misma prioridad, la cual es menor que la de cualquier
operación aritmética, de desplazamiento o bit a bit. También, a
diferencia de C, expresiones como "a < b < c" tienen la interpretación
convencional en matemáticas:

   comparison    ::= or_expr (comp_operator or_expr)*
   comp_operator ::= "<" | ">" | "==" | ">=" | "<=" | "!="
                     | "is" ["not"] | ["not"] "in"

Las comparaciones producen valores booleanos: "True" o "False".
Personalizado: dfn: los *métodos de comparación enriquecidos* pueden
retornar valores no booleanos. En este caso, Python llamará a "bool()"
en dicho valor en contextos booleanos.

Las comparaciones pueden ser encadenadas arbitrariamente, ej., "x < y
<= z" es equivalente a "x < y and y <= z", excepto que "y" es evaluado
sólo una vez (pero en ambos casos "z" no es evaluado para nada cuando
"x < y" se encuentra que es falso).

Formalmente, si *a*, *b*, *c*, ..., *y*, *z* son expresiones y *op1*,
*op2*, ..., *opN* son operadores de comparación, entonces "a op1 b op2
c ... y opN z" es equivalente a "a op1 b and b op2 c and ... y opN z",
excepto que cada expresión es evaluada como mucho una vez.

Tenga en cuenta que "a op1 b op2 c" no implica ningún tipo de
comparación entre *a* y *c*, por lo que, por ejemplo, "x < y > z" es
perfectamente legal (aunque quizás no es bonito).


6.10.1. Comparaciones de valor
------------------------------

Los operadores "<", ">", "==", ">=", "<=", y "!=" comparan los valores
de dos objetos. Los objetos no necesitan ser del mismo tipo.

El capítulo Objetos, valores y tipos afirma que los objetos tienen un
valor (en adición al tipo e identidad). El valor de un objeto es una
noción bastante abstracta en Python: Por ejemplo, no existe un método
de acceso canónico para el valor de un objeto. Además, no se requiere
que el valor de un objeto deba ser construido de una forma particular,
ej. compuesto de todos sus atributos de datos. Los operadores de
comparación implementan una noción particular de lo que es el valor de
un objeto. Uno puede pensar en ellos definiendo el valor de un objeto
indirectamente, mediante su implementación de comparación.

Because all types are (direct or indirect) subtypes of "object", they
inherit the default comparison behavior from "object".  Types can
customize their comparison behavior by implementing *rich comparison
methods* like "__lt__()", described in Personalización básica.

El comportamiento predeterminado para comparación de igualdad ("==" y
"!=") se basa en la identidad de los objetos. Por lo tanto, la
comparación de instancias con la misma identidad resulta en igualdad,
y la comparación de igualdad de instancias con diferentes entidades
resulta en desigualdad. Una motivación para este comportamiento
predeterminado es el deseo de que todos los objetos sean reflexivos
(ej. "x is y" implica "x == y").

No se provee un orden de comparación por defecto ("<", ">", "<=", and
">="); un intento genera "TypeError". Una motivación para este
comportamiento predeterminado es la falta de una invariante similar
como para la igualdad.

El comportamiento de la comparación de igualdad predeterminado, que
instancias con diferentes identidades siempre son desiguales, puede
estar en contraste a que los tipos que necesitarán que tengan una
definición sensata de valor de objeto e igualdad basada en el valor.
Tales tipos necesitarán personalizar su comportamiento de comparación
y, de hecho, un número de tipos incorporados lo han realizado.

La siguiente lista describe el comportamiento de comparación de los
tipos incorporados más importantes.

* Números de tipos numéricos incorporadas (Tipos numéricos --- int,
  float, complex) y tipos de la biblioteca estándar
  "fractions.Fraction" y "decimal.Decimal" pueden ser comparados
  consigo mismos y entre sus tipos, con la restricción de que números
  complejos no soportan orden de comparación. Dentro de los límites de
  los tipos involucrados, se comparan matemáticamente
  (algorítmicamente) correctos sin pérdida de precisión.

  Los valores no-un-número "float('NaN')" y "decimal.Decimal('NaN')"
  son especiales. Cualquier comparación ordenada de un número a un no-
  un-número es falsa. Una implicación contraintuitiva es que los
  valores no-un-número son son iguales a sí mismos. Por ejemplo, si "x
  = float('NaN')", "3 < x", "x < 3" y "x == x" son todos falso,
  mientras "x != x" es verdadero. Este comportamiento cumple con IEEE
  754.

* "None" and "NotImplemented" are singletons.  **PEP 8** advises that
  comparisons for singletons should always be done with "is" or "is
  not", never the equality operators.

* Las secuencias binarias (instancias de "bytes" o "bytearray") pueden
  ser comparadas entre sí y con otros tipos. Ellas comparan
  lexicográficamente utilizando los valores numéricos de sus
  elementos.

* Las cadenas de caracteres (instancias de "str") comparan
  lexicográficamente usando los puntos de códigos numéricos Unicode
  (el resultado de la función incorporada "ord()") o sus caracteres.
  [3]

  Las cadenas de caracteres y las secuencias binarias no pueden ser
  comparadas directamente.

* Las secuencias (instancias de "tuple", "list", o "range") pueden ser
  comparadas sólo entre cada uno de sus tipos, con la restricción de
  que los rangos no soportan comparación de orden. Comparación de
  igualdad entre esos tipos resulta en desigualdad y la comparación de
  orden entre esos tipos genera "TypeError".

  Las secuencias comparan lexicográficamente usando comparación de sus
  correspondientes elementos. Los contenedores incorporados asumen que
  los objetos idénticos son iguales a sí mismos. Eso les permite
  omitir las pruebas de igualdad para objetos idénticos para mejorar
  el rendimiento y mantener sus invariantes internos.

  La comparación lexicográfica entre colecciones incorporadas funciona
  de la siguiente forma:

  * Para que dos colecciones sean comparadas iguales, ellas deben ser
    del mismo tipo, tener el mismo largo, y cada para de elementos
    correspondientes deben comparar iguales (por ejemplo, "[1,2] ==
    (1,2)" es falso debido a que el tipo no es el mismo).

  * Las colecciones que soportan comparación de orden son ordenadas
    igual que sus primeros elementos desiguales (por ejemplo, "[1,2,x]
    <= [1,2,y]" tiene el mismo valor que "x <= y"). Si un elemento
    correspondiente no existe, la colección más corta es ordenada
    primero (por ejemplo, "[1,2] < [1,2,3]" es verdadero).

* Mappings (instances of "dict") compare equal if and only if they
  have equal "(key, value)" pairs. Equality comparison of the keys and
  values enforces reflexivity.

  Comparaciones de orden ("<", ">", "<=", and ">=") generan
  "TypeError".

* Conjuntos (instancias de "set" o "frozenset") pueden ser comparadas
  entre sí y entre sus tipos.

  Ellas definen operadores de comparación de orden con la intención de
  comprobar subconjuntos y superconjuntos. Tales relaciones no definen
  ordenaciones completas (por ejemplo, los dos conjuntos "{1,2}" y
  "{2,3}" no son iguales, ni subconjuntos ni superconjuntos uno de
  otro). Acordemente, los conjuntos no son argumentos apropiados para
  funciones que dependen de ordenación completa (por ejemplo, "min()",
  "max()" y "sorted()" producen resultados indefinidos dados una lista
  de conjuntos como entradas).

  La comparación de conjuntos refuerza la reflexibilidad de sus
  elementos.

* La mayoría de los otros tipos incorporados no tienen métodos de
  comparación implementados, por lo que ellos heredan el
  comportamiento de comparación predeterminado.

Las clases definidas por el usuario que personalizan su comportamiento
de comparación deben seguir algunas reglas de consistencia, si es
posible:

* La comparación de igualdad debe ser reflexiva. En otras palabras,
  los objetos idénticos deben comparar iguales:

     "x is y" implica "x == y"

* La comparación debe ser simétrica. En otras palabras, las siguientes
  expresiones deben tener el mismo resultado:

     "x == y" y "y == x"

     "x != y" y "y != x"

     "x < y" y "y > x"

     "x <= y" y "y >= x"

* La comparación debe ser transitiva. Los siguientes ejemplos (no
  exhaustivos) ilustran esto:

     "x > y and y > z" implica "x > z"

     "x < y and y <= z" implica "x < z"

* La comparación inversa debe resultar en la negación booleana. En
  otras palabras, las siguientes expresiones deben tener el mismo
  resultado:

     "x == y" y "not x != y"

     "x < y" y "not x >= y" (para ordenación completa)

     "x > y" y "not x <= y" (para ordenación completa)

  Las últimas dos expresiones aplican a colecciones completamente
  ordenadas (ej. a secuencias, pero no a conjuntos o mapeos). Vea
  también el decorador "total_ordering()".

* La función "hash()" debe ser consistente con la igualdad. Los
  objetos que son iguales deben tener el mismo valor de hash o ser
  marcados como inhashables.

Python no fuerza a cumplir esas reglas de coherencia. De hecho, los
valores no-un-número son u ejemplo para no seguir esas reglas.


6.10.2. Operaciones de prueba de membresía
------------------------------------------

Los operadores "in" y "not in" comprueban membresía. "x in s" evalúa a
"True" si *x* es un miembro de *s* y "False" en caso contrario. "x not
in s" retorna la negación de "x in s". Todas las secuencias
incorporadas y tipos conjuntos soportan esto, así como diccionarios,
para los cuales "in" comprueba si un diccionario tiene una clave dada.
Para tipos contenedores como list, tuple, set, frozenset, dict o
collections.deque, la expresión "x in y" es equivalente a "any(x is e
or x == e for e in y)".

Para los tipos cadenas de caracteres y bytes, "x in y" es "True" si y
sólo si *x* es una subcadena de *y*. Una comprobación equivalente es
"y.find(x) != -1". Las cadenas de caracteres vacías siempre son
consideradas como subcadenas de cualquier otra cadena de caracteres,
por lo que """ in "abc"" retornará "True".

For user-defined classes which define the "__contains__()" method, "x
in y" returns "True" if "y.__contains__(x)" returns a true value, and
"False" otherwise.

For user-defined classes which do not define "__contains__()" but do
define "__iter__()", "x in y" is "True" if some value "z", for which
the expression "x is z or x == z" is true, is produced while iterating
over "y". If an exception is raised during the iteration, it is as if
"in" raised that exception.

Lastly, the old-style iteration protocol is tried: if a class defines
"__getitem__()", "x in y" is "True" if and only if there is a non-
negative integer index *i* such that "x is y[i] or x == y[i]", and no
lower integer index raises the "IndexError" exception.  (If any other
exception is raised, it is as if "in" raised that exception).

El operador "not in" es definido para tener el valor de veracidad
inverso de "in".


6.10.3. Comparaciones de identidad
----------------------------------

Los operadores "is" y "is not" comprueban la identidad de un objeto.
"x is y" es verdadero si y sólo si *x* e *y* son el mismo objeto. La
identidad de un Objeto se determina usando la función "id()". "x is
not y" produce el valor de veracidad inverso. [4]


6.11. Operaciones booleanas
===========================

   or_test  ::= and_test | or_test "or" and_test
   and_test ::= not_test | and_test "and" not_test
   not_test ::= comparison | "not" not_test

In the context of Boolean operations, and also when expressions are
used by control flow statements, the following values are interpreted
as false: "False", "None", numeric zero of all types, and empty
strings and containers (including strings, tuples, lists,
dictionaries, sets and frozensets).  All other values are interpreted
as true.  User-defined objects can customize their truth value by
providing a "__bool__()" method.

El operador "not" produce "True" si su argumento es falso, "False" si
no.

La expresión "x and y" primero evalúa *x*; si *x* es falso, se retorna
su valor; de otra forma, *y* es evaluado y se retorna el valor
resultante.

La expresión "x or y" primero evalúa *x*; si *x* es verdadero, se
retorna su valor; de otra forma, *y* es evaluado y se retorna el valor
resultante.

Tenga en cuenta que ni "and" ni "or" restringen el valor y el tipo que
retornan a "False" y "True", sino retornan el último argumento
evaluado. Esto es útil a veces, ej., si "s" es una cadena de
caracteres que debe ser remplazada por un valor predeterminado si está
vacía, la expresión "s or 'foo'" produce el valor deseado. Debido a
que "not" tiene que crear un nuevo valor, retorna un valor booleano
indiferentemente del tipo de su argumento (por ejemplo, "not 'foo'"
produce "False" en lugar de "''".)


6.12. Expresiones de asignación
===============================

   assignment_expression ::= [identifier ":="] expression

An assignment expression (sometimes also called a "named expression"
or "walrus") assigns an "expression" to an "identifier", while also
returning the value of the "expression".

Un caso de uso común es cuando se manejan expresiones regulares
coincidentes:

   if matching := pattern.search(data):
       do_something(matching)

O, al procesar un flujo de archivos en fragmentos:

   while chunk := file.read(9000):
       process(chunk)

Assignment expressions must be surrounded by parentheses when used as
expression statements and when used as sub-expressions in slicing,
conditional, lambda, keyword-argument, and comprehension-if
expressions and in "assert", "with", and "assignment" statements. In
all other places where they can be used, parentheses are not required,
including in "if" and "while" statements.

Added in version 3.8: Vea **PEP 572** para más detalles sobre las
expresiones de asignación.


6.13. Expresiones condicionales
===============================

   conditional_expression ::= or_test ["if" or_test "else" expression]
   expression             ::= conditional_expression | lambda_expr

Las expresiones condicionales (a veces denominadas un "operador
ternario") tienen la prioridad más baja que todas las operaciones de
Python.

La expresión "x if C else y" primero evalúa la condición, *C* en lugar
de *x*. Si *C* es verdadero, *x* es evaluado y se retorna su valor; en
caso contrario, *y* es evaluado y se retorna su valor.

Vea **PEP 308** para más detalles sobre expresiones condicionales.


6.14. Lambdas
=============

   lambda_expr ::= "lambda" [parameter_list] ":" expression

Las expresiones lambda (a veces denominadas formas lambda) son usadas
para crear funciones anónimas. La expresión "lambda parameters:
expression" produce un objeto de función. El objeto sin nombre se
comporta como un objeto función con:

   def <lambda>(parameters):
       return expression

Vea la sección Definiciones de funciones para la sintaxis de listas de
parámetros. Tenga en cuenta que las funciones creadas con expresiones
lambda no pueden contener sentencias ni anotaciones.


6.15. Listas de expresiones
===========================

   expression_list    ::= expression ("," expression)* [","]
   starred_list       ::= starred_item ("," starred_item)* [","]
   starred_expression ::= expression | (starred_item ",")* [starred_item]
   starred_item       ::= assignment_expression | "*" or_expr

Excepto cuando son parte de un despliegue de lista o conjunto, una
lista de expresión conteniendo al menos una coma produce una tupla. El
largo de la tupla es el número de expresiones en la lista. Las
expresiones son evaluadas de izquierda a derecha.

Un asterisco "*" denota *iterable unpacking*. Su operando deben ser un
*iterable*. El iterable es expandido en una secuencia de elementos,
los cuales son incluidos en la nueva tupla, lista o conjunto en el
lugar del desempaquetado.

Added in version 3.5: Desempaquetado iterable en listas de
expresiones, originalmente propuesto por **PEP 488**.

A trailing comma is required only to create a one-item tuple, such as
"1,"; it is optional in all other cases. A single expression without a
trailing comma doesn't create a tuple, but rather yields the value of
that expression. (To create an empty tuple, use an empty pair of
parentheses: "()".)


6.16. Orden de evaluación
=========================

Python evalúa las expresiones de izquierda a derecha. Note que
mientras se evalúa una asignación, la parte derecha es evaluada antes
que la parte izquierda.

En las siguientes líneas, las expresiones serán evaluadas en el orden
aritmético de sus sufijos:

   expr1, expr2, expr3, expr4
   (expr1, expr2, expr3, expr4)
   {expr1: expr2, expr3: expr4}
   expr1 + expr2 * (expr3 - expr4)
   expr1(expr2, expr3, *expr4, **expr5)
   expr3, expr4 = expr1, expr2


6.17. Prioridad de operador
===========================

The following table summarizes the operator precedence in Python, from
highest precedence (most binding) to lowest precedence (least
binding).  Operators in the same box have the same precedence.  Unless
the syntax is explicitly given, operators are binary.  Operators in
the same box group left to right (except for exponentiation and
conditional expressions, which group from right to left).

Tenga en cuenta que las comparaciones, comprobaciones de membresía y
las comprobaciones de identidad tienen la misma prioridad y una
característica de encadenado de izquierda a derecha como son descritas
en la sección Comparaciones.

+-------------------------------------------------+---------------------------------------+
| Operador                                        | Descripción                           |
|=================================================|=======================================|
| "(expressions...)",  "[expressions...]", "{key: | Expresión de enlace o entre           |
| value...}", "{expressions...}"                  | paréntesis, despliegues de lista,     |
|                                                 | diccionario y conjunto                |
+-------------------------------------------------+---------------------------------------+
| "x[index]", "x[index:index]",                   | Subscripción, segmentación,           |
| "x(arguments...)", "x.attribute"                | invocación, referencia de atributo    |
+-------------------------------------------------+---------------------------------------+
| "await x"                                       | Expresión await                       |
+-------------------------------------------------+---------------------------------------+
| "**"                                            | Exponenciación [5]                    |
+-------------------------------------------------+---------------------------------------+
| "+x", "-x", "~x"                                | NOT positivo, negativo, bit a bit     |
+-------------------------------------------------+---------------------------------------+
| "*", "@", "/", "//", "%"                        | Multiplicación, multiplicación de     |
|                                                 | matrices, división, división entera a |
|                                                 | la baja, resto (módulo) [6]           |
+-------------------------------------------------+---------------------------------------+
| "+", "-"                                        | Adición y sustracción                 |
+-------------------------------------------------+---------------------------------------+
| "<<", ">>"                                      | Desplazamientos                       |
+-------------------------------------------------+---------------------------------------+
| "&"                                             | AND bit a bit                         |
+-------------------------------------------------+---------------------------------------+
| "^"                                             | XOR bit a bit                         |
+-------------------------------------------------+---------------------------------------+
| "|"                                             | OR bit a bit                          |
+-------------------------------------------------+---------------------------------------+
| "in", "not in", "is", "is not", "<", "<=", ">", | Comparaciones, incluyendo             |
| ">=", "!=", "=="                                | comprobaciones de membresía y de      |
|                                                 | identidad                             |
+-------------------------------------------------+---------------------------------------+
| "not x"                                         | Booleano NOT                          |
+-------------------------------------------------+---------------------------------------+
| "and"                                           | Booleano AND                          |
+-------------------------------------------------+---------------------------------------+
| "or"                                            | Booleano OR                           |
+-------------------------------------------------+---------------------------------------+
| "if" -- "else"                                  | Expresión condicional                 |
+-------------------------------------------------+---------------------------------------+
| "lambda"                                        | Expresión lambda                      |
+-------------------------------------------------+---------------------------------------+
| ":="                                            | Expresión de asignación               |
+-------------------------------------------------+---------------------------------------+

-[ Notas al pie ]-

[1] Mientras "abs(x%y) < abs(y)" es matemáticamente verdadero, para
    números de punto flotante puede no ser verdadero numéricamente
    debido al redondeo. Por ejemplo, y asumiendo una plataforma en la
    cual un número de punto flotante de Python es un número de doble
    precisión IEEE 754, a fin de que "-1e-100 % 1e100" tenga el mismo
    signo que "1e100", el resultado calculado es "-1e-100 + 1e100", el
    cual es numéricamente exactamente igual a "1e100". La función
    "math.fmod()" retorna un resultado cuyo signo concuerda con el
    signo del primer argumento en su lugar, y por ello retorna
    "-1e-100" en este caso. La aproximación más apropiada depende de
    su aplicación.

[2] Si x está muy cerca de un entero exacto múltiple de y, es posible
    para "x//y" que sea uno mayor que "(x-x%y)//y" debido al redondeo.
    En tales casos, Python retorna el último resultado, a fin de
    preservar que "divmod(x,y)[0] * y + x % y" sea muy cercano a "x".

[3] El estándar Unicode distingue entre *code points* (ej. U+0041) y
    *abstract characters* (ej. "LETRA MAYÚSCULA LATINA A"). Mientras
    la mayoría de caracteres abstractos en Unicode sólo son
    representados usando un punto de código, hay un número de
    caracteres abstractos que pueden adicionalmente ser representados
    usado una secuencia de más de un punto de código. Por ejemplo, el
    caracter abstracto "LETRA MAYÚSCULA C LATINA CON CEDILLA" puede
    ser representado como un único *precomposed character* en la
    posición de código U+00C7, o como una secuencia de un *base
    character* en la posición de código U+0043 (LETRA MAYÚSCULA C
    LATINA), seguida de un *combining character* en la posición de
    código U+0327 (CEDILLA COMBINADA).

    Los operadores de comparación comparan en cadenas de caracteres al
    nivel de puntos de código Unicode. Esto puede ser contraintuitivo
    para humanos. Por ejemplo, ""\u00C7" == "\u0043\u0327"" es
    "False", incluso aunque ambas cadenas presenten el mismo caracter
    abstracto "LETRA MAYÚSCULA C LATINA CON CEDILLA".

    Para comparar cadenas al nivel de caracteres abstractos (esto es,
    de una forma intuitiva para humanos), usa
    "unicodedata.normalize()".

[4] Debido a la recolección automática de basura, listas libres y a la
    naturaleza dinámica de los descriptores, puede notar un
    comportamiento aparentemente inusual en ciertos usos del operador
    "is", como aquellos involucrando comparaciones entre métodos de
    instancia, o constantes. Compruebe su documentación para más
    información.

[5] El operador de potencia "**" vincula con menos fuerza que un
    operador unario aritmético uno bit a bit en su derecha, esto
    significa que "2**-1" is "0.5".

[6] El operador "%" también es usado para formateo de cadenas; aplica
    la misma prioridad.
