Nota
¡Ayúdanos a traducir la documentación oficial de Python al Español! Puedes encontrar más información en Como contribuir. Ayuda a acercar Python a más personas de habla hispana.
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;
de otra forma, si cualquier de los argumentos es un número de punto flotante, el otro es convertido a punto flotante;
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
.
Alteración de nombre privado: Cuando un identificador que ocurre textualmente en una definición de clase comienza con dos o más caracteres de guión bajo y no termina en dos o más guiones bajos, es considerado un private name de esa clase. Los nombres privados son transformados a una forma más larga antes de que sea generado código para ellos. La transformación inserta el nombre de clase, con los guiones bajos iniciales eliminados y un solo guión bajo insertado, delante del nombre. Por ejemplo, el identificador __spam
que se encuentra en una clase denominada Ham
será transformado a _Ham__spam
. Esta transformación es independiente del contexto sintáctico en el cual es usado el identificador. Si el nombre transformado es extremadamente largo (más largo que 255 caracteres), puede ocurrir el truncamiento definido por la implementación. Si el nombre de clase consiste únicamente de guiones bajos, no se realiza transformación.
6.2.2. Literales¶
Python soporta literales de cadenas de caracteres y bytes y varios literales numéricos:
literal ::=stringliteral
|bytesliteral
|integer
|floatnumber
|imagnumber
La evaluación de un literal produce un objeto del tipo dado (cadena de caracteres, bytes, entero, número de punto flotante, número complejo) con el valor dado. El valor puede ser aproximado en el caso de literales de número de punto flotante e imaginarios (complejos). Vea la sección Literales para más detalles.
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 either async for
clauses or
await
expressions or other asynchronous comprehensions 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.
Nuevo en la versión 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.
Nuevo en la versión 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).
Nuevo en la versión 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_expression ::= "yield" [expression_list
| "from"expression
]
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 toNone
. The execution then continues to the next yield expression, where the generator is suspended again, and the value of theexpression_list
is returned to__next__()
”s caller. If the generator exits without yielding another value, aStopIteration
exception is raised.Este método es normalmente invocado implícitamente, por ejemplo, por un bucle
for
o por la función incorporadanext()
.
- 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 generaStopIteration
si el generador termina sin producir otro valor. Cuando se ejecutasend()
para comenzar el generador, debe ser invocado conNone
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 generaGeneratorExit
(sin cazar la excepción), close retorna a su invocador. Si el generador produce un valor, se genera unRuntimeError
. 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 toNone
in the returned awaitable, which when run will continue to the next yield expression. The value of theexpression_list
of the yield expression is the value of theStopIteration
exception raised by the completing coroutine. If the asynchronous generator exits without yielding another value, the awaitable instead raises aStopAsyncIteration
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étodoasend()
retornará el siguiente valor producido por el generador como el valor de laStopIteration
generada o generaStopAsyncIteration
si el generador asincrónico termina sin producir otro valor. Cuando se invocaasend()
para empezar el generador asincrónico, debe ser invocado conNone
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ónStopIteration
generada. Si el generador asincrónico termina sin producir otro valor, el esperable genera una excepciónStopAsyncIteration
. 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 generaGeneratorExit
(sin cazar la excepción), el esperable retornado lanzará una excepciónStopIteration
. Otros esperables retornados por subsecuentes invocaciones al generador asincrónico lanzarán una excepciónStopAsyncIteration
. Si el generador asincrónico produce un valor, el esperable genera unRuntimeError
. 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 aaclose()
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
El primario debe evaluar a un objeto de un tipo que soporte referencias de atributos, lo cual la mayoría de los objetos soportan. Luego se le pide a este objeto que produzca el atributo cuyo nombre es el identificador. Esta producción puede ser personalizada sobrescribiendo el método __getattr__()
. Si este atributo no es esperable, se genera la excepción AtributeError
. De otra forma, el tipo y el valor del objeto producido es determinado por el objeto. Múltiples evaluaciones la misma referencia de atributo pueden producir diferentes objetos.
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__()
:
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.Sequences. If the primary is a sequence, the expression list must evaluate to an
int
or aslice
(as discussed in the following section). Examples of builtin sequence classes include thestr
,list
andtuple
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).
Las semánticas para un segmento son las siguientes. El primario es indexado (usando el mismo método __getitem__()
de una subscripción normal) con una clave que se construye del segmento de lista, tal como sigue. Si el segmento de lista contiene al menos una coma, la clave es una tupla que contiene la conversión de los elementos del segmento; de otra forma, la conversión del segmento de lista solitario es la clave. La conversión de un elemento de segmento que es una expresión es esa expresión. La conversión de un segmento apropiado es un objeto segmento (ver sección Jerarquía de tipos estándar) cuyos atributos start
, stop
y step
son los valores de las expresiones dadas como límite inferior, límite superior y paso, respectivamente, substituyendo None
para las expresiones faltantes.
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.
La clave primaria debe evaluar a un objeto invocable (funciones definidas por el usuario, funciones incorporadas, métodos de objetos incorporados, métodos de instancias de clases y todos los objetos que tienen un método __call__()
son invocables). Todas las expresiones de argumento son evaluadas antes de que la invocación sea intentada. Por favor, refiera a la sección Definiciones de funciones para la sintaxis formal de listas de parameter.
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:
La clase debe definir un método
__call__()
; el efecto es entonces el mismo que si ese método fuera invocado.
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
Nuevo en la versión 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
.)
Esta operación se puede personalizar mediante el método especial __pow__()
.
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
El operador unario -
(menos) produce la negación de su argumento numérico; la operación se puede anular con el método especial __neg__()
.
El operador unario +
(más) produce su argumento numérico sin cambios; la operación se puede anular con el método especial __pos__()
.
El operador unario ~
(invertir) produce la inversión bit a bit de su argumento entero. La inversión bit a bit de x
se define como -(x+1)
. Solo se aplica a números enteros o a objetos personalizados que anulan el método especial __invert__()
.
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.
Esta operación se puede personalizar utilizando los métodos especiales __mul__()
y __rmul__()
.
El operador @
(en) está destinado a ser usado para multiplicación de matrices. Ningún tipo incorporado en Python implementa este operador.
Nuevo en la versión 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
.
Esta operación se puede personalizar utilizando los métodos especiales __truediv__()
y __floordiv__()
.
El operador %
(módulo) produce el resto de la división del primer argumento entre el segundo. Los argumentos numéricos son primero convertidos a un tipo común. Un argumento a la derecha cero genera la excepción ZeroDivisionError
. Los argumentos pueden ser números de punto flotante, ej., 3.14%0.7
es igual a 0.34
(ya que 3.14
es igual a 4*0.7 + 0.34
.) El operador módulo siempre produce un resultado con el mismo signo que su segundo operando (o cero); el valor absoluto del resultado es estrictamente más pequeño que el valor absoluto del segundo operando [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*.
La operación modulo se puede personalizar utilizando el método especial __mod__()
.
El operador de división entera a la baja, el operador de módulo y la función divmod()
no están definidas para números complejos. En su lugar, convierta a un número de punto flotante usando la función abs()
si es apropiado.
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.
Esta operación se puede personalizar utilizando los métodos especiales __add__()
y __radd__()
.
El operador -
(resta) produce la diferencia de sus argumentos. Los argumentos numéricos son primero convertidos a un tipo común.
Esta operación se puede personalizar mediante el método especial __sub__()
.
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.
Esta operación se puede personalizar utilizando los métodos especiales __lshift__()
y __rshift__()
.
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
El operador &
produce el AND bit a bit de sus argumentos, que deben ser números enteros o uno de ellos debe ser un objeto personalizado que anule los métodos especiales __and__()
o __rand__()
.
El operador ^
produce el XOR bit a bit (OR exclusivo) de sus argumentos, que deben ser números enteros o uno de ellos debe ser un objeto personalizado que anule los métodos especiales __xor__()
o __rxor__()
.
El operador |
produce el OR bit a bit (inclusive) de sus argumentos, que deben ser números enteros o uno de ellos debe ser un objeto personalizado que anule los métodos especiales __or__()
o __ror__()
.
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.
Debido a que todos los tipos son subtipos (directos o indirectos) de object
, ellos heredan el comportamiento de comparación predeterminado desde object
. Los tipos pueden personalizar su comportamiento de comparación implementando rich comparison methods como __lt__()
, descritos en 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
ydecimal.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')
ydecimal.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, six = float('NaN')
,3 < x
,x < 3
yx == x
son todos falso, mientrasx != x
es verdadero. Este comportamiento cumple con IEEE 754.None
yNotImplemented
son singletons. PEP 8 avisa que las comparaciones para singletons deben ser realizadas siempre conis
ois not
, nunca los operadores de igualdad.Las secuencias binarias (instancias de
bytes
obytearray
) 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 incorporadaord()
) o sus caracteres. [3]Las cadenas de caracteres y las secuencias binarias no pueden ser comparadas directamente.
Las secuencias (instancias de
tuple
,list
, orange
) 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 generaTypeError
.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 quex <= 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>=
) generanTypeError
.Conjuntos (instancias de
set
ofrozenset
) 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()
ysorted()
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
implicax == y
La comparación debe ser simétrica. En otras palabras, las siguientes expresiones deben tener el mismo resultado:
x == y
yy == x
x != y
yy != x
x < y
yy > x
x <= y
yy >= x
La comparación debe ser transitiva. Los siguientes ejemplos (no exhaustivos) ilustran esto:
x > y and y > z
implicax > z
x < y and y <= z
implicax < 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
ynot x != y
x < y
ynot x >= y
(para ordenación completa)x > y
ynot 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
.
Para clases definidas por el usuario las cuales definen el método __contains__()
, x in y
retorna True
si y.__contains__(x)
retorna un valor verdadero y False
si no.
Para clases definidas por el usuario las cuales no definen __contains__()
pero definen __iter__()
, x in y
es True
si algún valor z
, para el cual la expresión x is z or x == z
es verdadera, es producido iterando sobre y
. Si una excepción es generada durante la iteración, es como si in
hubiera generado esa excepción.
Por último, se intenta el protocolo de iteración al estilo antiguo: si una clase define __getitem__()
, x in y
es True
si y sólo si hay un índice entero no negativo i tal que x is y[i] or x == y[i]
y ningún entero menor genera la excepción IndexError
. (Si cualquier otra excepción es generada, es como si in
hubiera generado esa excepción).
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 sub-expressions in slicing, conditional, lambda,
keyword-argument, and comprehension-if expressions
and in assert
and with
statements.
In all other places where they can be used, parentheses are not required,
including in if
and while
statements.
Nuevo en la versión 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.
Nuevo en la versión 3.5: Desempaquetado iterable en listas de expresiones, originalmente propuesto por PEP 488.
La coma final sólo es requerida para crear una tupla única (también denominada un singleton); es opcional en todos los otros casos. Una única expresión sin una coma final no crea una tupla, si no produce el valor de esa expresión. (Para crear una tupla vacía, usa un par de paréntesis vacío: ()
.)
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 |
---|---|
|
Expresión de enlace o entre paréntesis, despliegues de lista, diccionario y conjunto |
|
Subscripción, segmentación, invocación, referencia de atributo |
Expresión await |
|
|
Exponenciación [5] |
|
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 |
Comparaciones, incluyendo comprobaciones de membresía y de identidad |
|
Booleano NOT |
|
Booleano AND |
|
Booleano OR |
|
|
Expresión condicional |
Expresión lambda |
|
|
Expresión de asignación |
Notas al pie