# 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 yields 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 yields lo que la lista de expresión yields: si la lista contiene al menos una coma, produce una tupla; en caso contrario, yields la única expresión que que forma la lista de expresiones.

Un par de paréntesis vacío yields 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 yields el mismo objeto).

Tenga en cuenta que las tuplas no se forman con paréntesis, sino mediante el uso de coma. La excepción es la tupla vacía, para la cual se requieren paréntesis. Permitir «nada» sin paréntesis en las expresiones causaría ambigüedades y permitiría que errores tipográficos comunes pasaran sin detectarse.

### 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: Las comprensiones asincrónicas ahora están permitidas dentro de las comprensiones en funciones asincrónicas. Las comprensiones externas implícitamente se vuelven asincrónicas.

### 6.2.5. Despliegues de lista

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

    list_display ::= "[" [flexible_expression_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 ::= "{" (flexible_expression_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

La visualización de un diccionario es una serie posiblemente vacía de elementos de dictado (pares clave/valor) encerrados entre llaves:

    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.

Si se proporciona una secuencia de elementos dict separados por comas, se evalúan de izquierda a derecha para definir las entradas del diccionario: cada objeto clave se utiliza como clave en el diccionario para almacenar el valor correspondiente. Esto significa que puede especificar la misma clave varias veces en la lista de elementos de dictado, y el valor final del diccionario para esa clave será el último que se proporcione.

Un asterisco doble `**` indica descomprimiendo el diccionario. Su operando debe ser un mapping. Cada elemento de mapeo se agrega al nuevo diccionario. Los valores posteriores reemplazan los valores ya establecidos por elementos de dictado anteriores y desempaquetados de diccionarios anteriores.

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.

Las restricciones sobre los tipos de valores clave se enumeran anteriormente en la sección Jerarquía de tipos estándar. (En resumen, el tipo de clave debe ser hashable, que excluye todos los objetos mutables). No se detectan conflictos entre claves duplicadas; prevalece el último valor (textualmente más a la derecha en la pantalla) almacenado para un valor clave determinado.

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" yield_list | yield_from

La expresión yield se usa al definir una función generator o una función asynchronous generator y, por lo tanto, solo se puede usar en el cuerpo de una definición de función. El uso de una expresión yield en el cuerpo de una función hace que esa función sea una función generadora, y su uso en el cuerpo de una función `async def` hace que la función corrutina sea una función generadora asíncrona. Por ejemplo:

    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 `yield_list` to the generator’s caller, or `None` if `yield_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; yield 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 yield; 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

  La propuesta para introducir la sintaxis `yield_from`, facilitando la delegación a subgeneradores.

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 `yield_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]])

  Genera una excepción en el punto donde se pausó el generador y devuelve el siguiente valor generado por la función del generador. Si el generador sale sin generar otro valor, se genera una excepción `StopIteration`. Si la función generadora no detecta la excepción pasada o genera una excepción diferente, esa excepción se propaga a la persona que llama.

  En el uso típico, esto se llama con una sola instancia de excepción similar a la forma en que se usa la palabra clave `raise`.

  Sin embargo, para la compatibilidad con versiones anteriores, se admite la segunda firma, siguiendo una convención de versiones anteriores de Python. El argumento type debe ser una clase de excepción y value debe ser una instancia de excepción. Si no se proporciona value, se llama al constructor type para obtener una instancia. Si se proporciona traceback, se establece en la excepción; de lo contrario, se puede borrar cualquier atributo `__traceback__` existente almacenado en value.

  Distinto en la versión 3.12: La segunda firma (type[, value[, traceback]]) está obsoleta y puede eliminarse en una versión futura de 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 `yield_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.

async 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 `yield_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`.

async agen.asend(value)

  Returns an awaitable which when run resumes the execution of the asynchronous generator. As with the `send()` method for a generator, this «sends» a value into the asynchronous generator function, and the value argument becomes the result of the current yield expression. The awaitable returned by the `asend()` method will return the next value yielded by the generator as the value of the raised `StopIteration`, or raises `StopAsyncIteration` if the asynchronous generator exits without yielding another value. When `asend()` is called to start the asynchronous generator, it must be called with `None` as the argument, because there is no yield expression that could receive the value.

async agen.athrow(value)
async 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 yield por la función generadora como el valor de la excepción `StopIteration` generada. Si el generador asincrónico termina sin yield 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: La segunda firma (type[, value[, traceback]]) está obsoleta y puede eliminarse en una versión futura de Python.

async 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 yield 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

La suscripción de una instancia de un container class generalmente seleccionará un elemento del contenedor. La suscripción de un generic class generalmente devolverá un objeto GenericAlias.

    subscription ::= primary "[" flexible_expression_list "]"

Cuando se subíndice un objeto, el intérprete evaluará el primario y la lista de expresiones.

El primario debe evaluarse como un objeto que admita la suscripción. Un objeto puede admitir la suscripción mediante la definición de uno o ambos `__getitem__()` y `__class_getitem__()`. Cuando se subíndice el principal, el resultado evaluado de la lista de expresiones se pasará a uno de estos métodos. Para obtener más detalles sobre cuándo se llama a `__class_getitem__` en lugar de `__getitem__`, consulte __class_getitem__ frente a __getitem__.

If the expression list contains at least one comma, or if any of the expressions are starred, the expression list 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.

Distinto en la versión 3.11: Expressions in an expression list may be starred. See PEP 646.

Para los objetos integrados, existen dos tipos de objetos que admiten la suscripción a través de `__getitem__()`:

1. Mapeos. Si el primario es mapping, la lista de expresiones debe evaluarse como un objeto cuyo valor sea una de las claves de la asignación, y la suscripción selecciona el valor en la asignación que corresponde a esa clave. Un ejemplo de una clase de mapeo incorporada es la clase `dict`.

2. Secuencias. Si el primario es un sequence, la lista de expresiones debe evaluarse como un `int` o un `slice` (como se explica en la siguiente sección). Los ejemplos de clases de secuencia integradas incluyen las clases `str`, `list` y `tuple`.

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.

Un `string` es un tipo especial de secuencia cuyos elementos son characters. Un carácter no es un tipo de datos independiente sino una cadena de exactamente un carácter.

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

Si hay argumentos de palabras clave, primero se convierten en argumentos posicionales, de la siguiente manera. Primero, se crea una lista de espacios vacantes para los parámetros formales. Si hay N argumentos posicionales, se colocan en los primeros N espacios. A continuación, para cada argumento de palabra clave, se utiliza el identificador para determinar la ranura correspondiente (si el identificador es el mismo que el nombre del primer parámetro formal, se utiliza la primera ranura, y así sucesivamente). Si el espacio ya está ocupado, se genera una excepción `TypeError`. De lo contrario, el argumento se coloca en el espacio, llenándolo (incluso si la expresión es `None`, llena el espacio). Cuando se han procesado todos los argumentos, los espacios que aún están vacíos se llenan con el valor predeterminado correspondiente de la definición de función. (Los valores predeterminados se calculan, una vez, cuando se define la función; por lo tanto, un objeto mutable como una lista o diccionario usado como valor predeterminado será compartido por todas las llamadas que no especifican un valor de argumento para la ranura correspondiente; esto debería normalmente se evita.) Si hay espacios vacíos para los cuales no se especifica ningún valor predeterminado, se genera una excepción `TypeError`. De lo contrario, la lista de espacios ocupados se utiliza como lista de argumentos para la llamada.

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

Es inusual que se utilicen argumentos de palabras clave y la sintaxis `*expression` en la misma llamada, por lo que en la práctica esta confusión no suele surgir.

Si la sintaxis `**expression` aparece en la llamada de función, `expression` debe evaluarse como mapping, cuyo contenido se trata como argumentos de palabras clave adicionales. Si a un parámetro que coincide con una clave ya se le ha asignado un valor (mediante un argumento de palabra clave explícito o de otro desempaquetado), se genera una excepción `TypeError`.

Cuando se usa `**expression`, cada clave en esta asignación debe ser una cadena. Cada valor del mapeo se asigna al primer parámetro formal elegible para la asignación de palabras clave cuyo nombre es igual a la clave. No es necesario que una clave sea un identificador de Python (por ejemplo, `"max-temp °F"` es aceptable, aunque no coincidirá con ningún parámetro formal que pueda declararse). Si no hay ninguna coincidencia con un parámetro formal, el par clave-valor se recopila mediante el parámetro `**`; si lo hay, o si no lo hay, se genera una excepción `TypeError`.

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:

  The code block for the function is executed, passing it the argument list. The first thing the code block will do is bind the formal parameters to the arguments; this is described in section Definiciones de funciones. When the code block executes a `return` statement, this specifies the return value of the function call. If execution reaches the end of the code block without executing a `return` statement, the return value is `None`.

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

- Las asignaciones (instancias de `dict`) se comparan iguales si y solo si tienen pares `(key, value)` iguales. La comparación equitativa de las claves y los valores impone la reflexividad.

  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` yield 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

En el contexto de operaciones booleanas, y también cuando las declaraciones de flujo de control utilizan expresiones, los siguientes valores se interpretan como falsos: `False`, `None`, cero numérico de todos los tipos y cadenas y contenedores vacíos (incluidas cadenas, tuplas, listas, diccionarios). , conjuntos y conjuntos congelados). Todos los demás valores se interpretan como verdaderos. Los objetos definidos por el usuario pueden personalizar su valor de verdad proporcionando un método `__bool__()`.

El operador `not` yield `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'` yield 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

Una expresión de asignación (a veces también llamada «expresión con nombre» o «morsa») asigna un `expression` a un `identifier`, al mismo tiempo que devuelve el valor de el `expresión`.

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` yield 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

    starred_expression       ::= ["*"] or_expr
    flexible_expression      ::= assignment_expression | starred_expression
    flexible_expression_list ::= flexible_expression ("," flexible_expression)* [","]
    starred_expression_list  ::= starred_expression ("," starred_expression)* [","]
    expression_list          ::= expression ("," expression)* [","]
    yield_list               ::= expression_list | starred_expression "," [starred_expression_list]

Excepto cuando son parte de un despliegue de lista o conjunto, una lista de expresión conteniendo al menos una coma yield 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.

Added in version 3.11: Any item in an expression list may be starred. See PEP 646.

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

La siguiente tabla resume la precedencia de operadores en Python, desde la precedencia más alta (más vinculante) hasta la precedencia más baja (menos vinculante). Los operadores en el mismo cuadro tienen la misma prioridad. A menos que la sintaxis se proporcione explícitamente, los operadores son binarios. Los operadores en el mismo cuadro se agrupan de izquierda a derecha (excepto la exponenciación y las expresiones condicionales, que se agrupan de derecha a izquierda).

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: value...}`, `{expressions...}` | Expresión de enlace o entre paréntesis, despliegues de lista, diccionario y conjunto
`x[index]`, `x[index:index]`, `x(arguments...)`, `x.attribute` | Subscripción, segmentación, 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.