6. Expressões¶
Este capítulo explica o significado dos elementos das expressões em Python.
Notas de sintaxe: Neste e nos capítulos seguintes, a notação BNF estendida será usada para descrever a sintaxe, não a análise lexical. Quando (uma alternativa de) uma regra de sintaxe tem a forma
name ::= othername
e nenhuma semântica é fornecida, a semântica desta forma de name
é a mesma que para othername
.
6.1. Conversões aritméticas¶
Quando uma descrição de um operador aritmético abaixo usa a frase “os argumentos numéricos são convertidos em um tipo comum”, isso significa que a implementação do operador para tipos embutidos funciona da seguinte maneira:
Se um dos argumentos for um número complexo, o outro será convertido em complexo;
caso contrário, se um dos argumentos for um número de ponto flutuante, o outro será convertido em ponto flutuante;
caso contrário, ambos devem ser inteiros e nenhuma conversão é necessária.
Algumas regras adicionais se aplicam a certos operadores (por exemplo, uma string como um argumento à esquerda para o operador ‘%’). As extensões devem definir seu próprio comportamento de conversão.
6.2. Átomos¶
Os átomos são os elementos mais básicos das expressões. Os átomos mais simples são identificadores ou literais. As formas entre parênteses, colchetes ou chaves também são categorizadas sintaticamente como átomos. A sintaxe para átomos é:
atom ::=identifier
|literal
|enclosure
enclosure ::=parenth_form
|list_display
|dict_display
|set_display
|generator_expression
|yield_atom
6.2.1. Identificadores (Nomes)¶
Um identificador que ocorre como um átomo é um nome. Veja a seção Identificadores e palavras-chave para a definição lexical e a seção Nomeação e ligação para documentação de nomenclatura e ligação.
Quando o nome está vinculado a um objeto, a avaliação do átomo produz esse objeto. Quando um nome não está vinculado, uma tentativa de avaliá-lo levanta uma exceção NameError
.
Mangling de nome privado: Quando um identificador que ocorre textualmente em uma definição de classe começa com dois ou mais caracteres de sublinhado e não termina em dois ou mais sublinhados, ele é considerado um nome privado dessa classe. Os nomes privados são transformados em um formato mais longo antes que o código seja gerado para eles. A transformação insere o nome da classe, com sublinhados à esquerda removidos e um único sublinhado inserido na frente do nome. Por exemplo, o identificador __spam
que ocorre em uma classe chamada Ham
será transformado em _Ham__spam
. Essa transformação é independente do contexto sintático em que o identificador é usado. Se o nome transformado for extremamente longo (mais de 255 caracteres), poderá ocorrer truncamento definido pela implementação. Se o nome da classe consistir apenas em sublinhados, nenhuma transformação será feita.
6.2.2. Literais¶
Python oferece suporte a strings e bytes literais e vários literais numéricos:
literal ::=stringliteral
|bytesliteral
|integer
|floatnumber
|imagnumber
A avaliação de um literal produz um objeto do tipo fornecido (string, bytes, inteiro, número de ponto flutuante, número complexo) com o valor fornecido. O valor pode ser aproximado no caso de ponto flutuante e literais imaginários (complexos). Veja a seção Literais para detalhes.
Todos os literais correspondem a tipos de dados imutáveis e, portanto, a identidade do objeto é menos importante que seu valor. Múltiplas avaliações de literais com o mesmo valor (seja a mesma ocorrência no texto do programa ou uma ocorrência diferente) podem obter o mesmo objeto ou um objeto diferente com o mesmo valor.
6.2.3. Formas de parênteses¶
Um forma entre parênteses é uma lista de expressões opcional entre parênteses:
parenth_form ::= "(" [starred_expression
] ")"
Uma lista de expressões entre parênteses produz tudo o que aquela lista de expressões produz: se a lista contiver pelo menos uma vírgula, ela produzirá uma tupla; caso contrário, produz a única expressão que compõe a lista de expressões.
Um par de parênteses vazio produz um objeto tupla vazio. Como as tuplas são imutáveis, aplicam-se as mesmas regras dos literais (isto é, duas ocorrências da tupla vazia podem ou não produzir o mesmo objeto).
Note that tuples are not formed by the parentheses, but rather by use of the comma operator. The exception is the empty tuple, for which parentheses are required — allowing unparenthesized “nothing” in expressions would cause ambiguities and allow common typos to pass uncaught.
6.2.4. Sintaxe de criação de listas, conjuntos e dicionários¶
Para construir uma lista, um conjunto ou um dicionário, o Python fornece uma sintaxe especial chamada “sintaxes de criação” (em inglês, displays), cada uma delas em dois tipos:
o conteúdo do contêiner é listado explicitamente ou
eles são calculados por meio de um conjunto de instruções de laço e filtragem, chamado de compreensão.
Elementos de sintaxe comuns para compreensões são:
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"expression_nocond
[comp_iter
]
A compreensão consiste em uma única expressão seguida por pelo menos uma cláusula for
e zero ou mais cláusulas for
ou if
. Neste caso, os elementos do novo contêiner são aqueles que seriam produzidos considerando cada uma das cláusulas for
ou if
de um bloco, aninhando da esquerda para a direita, e avaliando a expressão para produzir um elemento cada vez que o bloco mais interno é alcançado.
No entanto, além da expressão iterável na cláusula for
mais à esquerda, a compreensão é executada em um escopo aninhado implicitamente separado. Isso garante que os nomes atribuídos na lista de destino não “vazem” para o escopo delimitador.
A expressão iterável na cláusula for
mais à esquerda é avaliada diretamente no escopo envolvente e então passada como um argumento para o escopo aninhado implicitamente. Cláusulas for
subsequentes e qualquer condição de filtro na cláusula for
mais à esquerda não podem ser avaliadas no escopo delimitador, pois podem depender dos valores obtidos do iterável mais à esquerda. Por exemplo: [x*y for x in range(10) for y in range(x, x+10)]
.
Para garantir que a compreensão sempre resulte em um contêiner do tipo apropriado, as expressões yield
e yield from
são proibidas no escopo aninhado implicitamente.
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 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.
Novo na versão 3.6: Compreensões assíncronas foram introduzidas.
Alterado na versão 3.8: yield
e yield from
proibidos no escopo aninhado implícito.
6.2.5. Sintaxes de criação de lista¶
Uma sintaxe de criação de lista é uma série possivelmente vazia de expressões entre colchetes:
list_display ::= "[" [starred_list
|comprehension
] "]"
Uma sintaxe de criação de lista produz um novo objeto de lista, sendo o conteúdo especificado por uma lista de expressões ou uma compreensão. Quando uma lista de expressões separadas por vírgulas é fornecida, seus elementos são avaliados da esquerda para a direita e colocados no objeto de lista nessa ordem. Quando uma compreensão é fornecida, a lista é construída a partir dos elementos resultantes da compreensão.
6.2.6. Sintaxes de criação de conjunto¶
Uma sintaxe de criação definida é denotada por chaves e distinguível de sintaxes de criação de dicionário pela falta de caractere de dois pontos separando chaves e valores:
set_display ::= "{" (starred_list
|comprehension
) "}"
Uma sintaxe de criação de conjunto produz um novo objeto de conjunto mutável, sendo o conteúdo especificado por uma sequência de expressões ou uma compreensão. Quando uma lista de expressões separadas por vírgula é fornecida, seus elementos são avaliados da esquerda para a direita e adicionados ao objeto definido. Quando uma compreensão é fornecida, o conjunto é construído a partir dos elementos resultantes da compreensão.
Um conjunto vazio não pode ser construído com {}
; este literal constrói um dicionário vazio.
6.2.7. Sintaxes de criação de dicionário¶
Uma exibição de dicionário é uma série possivelmente vazia de pares chave/dado entre chaves:
dict_display ::= "{" [key_datum_list
|dict_comprehension
] "}" key_datum_list ::=key_datum
(","key_datum
)* [","] key_datum ::=expression
":"expression
| "**"or_expr
dict_comprehension ::=expression
":"expression
comp_for
Uma sintaxe de criação de dicionário produz um novo objeto dicionário.
Se for fornecida uma sequência separada por vírgulas de pares chave/dado, eles são avaliados da esquerda para a direita para definir as entradas do dicionário: cada objeto chave é usado como uma chave no dicionário para armazenar o dado correspondente. Isso significa que você pode especificar a mesma chave várias vezes na lista de dados/chave, e o valor final do dicionário para essa chave será o último dado.
Um asterisco duplo **
denota desempacotamento do dicionário. Seu operando deve ser um mapeamento. Cada item de mapeamento é adicionado ao novo dicionário. Os valores posteriores substituem os valores já definidos por pares de dados/chave anteriores e desempacotamentos de dicionário anteriores.
Novo na versão 3.5: Desempacotando em sintaxes de criação de dicionário, originalmente proposto pela PEP 448.
Uma compreensão de dict, em contraste com as compreensões de lista e conjunto, precisa de duas expressões separadas por dois pontos, seguidas pelas cláusulas usuais “for” e “if”. Quando a compreensão é executada, os elementos chave e valor resultantes são inseridos no novo dicionário na ordem em que são produzidos.
Restrições nos tipos de valores de chave são listadas anteriormente na seção A hierarquia de tipos padrão. (Para resumir, o tipo de chave deve ser hasheável, que exclui todos os objetos mutáveis.) Não são detectadas colisões entre chaves duplicadas; o último dado (textualmente mais à direita no visor) armazenado para um determinado valor de chave prevalece.
Alterado na versão 3.8: Antes do Python 3.8, em compreensões de dict, a ordem de avaliação de chave e valor não era bem definida. No CPython, o valor foi avaliado antes da chave. A partir de 3.8, a chave é avaliada antes do valor, conforme proposto pela PEP 572.
6.2.8. Expressões geradoras¶
Uma expressão geradora é uma notação geradora compacta entre parênteses:
generator_expression ::= "("expression
comp_for
")"
Uma expressão geradora produz um novo objeto gerador. Sua sintaxe é a mesma das compreensões, exceto pelo fato de estar entre parênteses em vez de colchetes ou chaves.
As variáveis usadas na expressão geradora são avaliadas lentamente quando o método __next__()
é chamado para o objeto gerador (da mesma forma que os geradores normais). No entanto, a expressão iterável na cláusula for
mais à esquerda é avaliada imediatamente, de modo que um erro produzido por ela será emitido no ponto em que a expressão do gerador é definida, em vez de no ponto em que o primeiro valor é recuperado. Cláusulas for
subsequentes e qualquer condição de filtro na cláusula for
mais à esquerda não podem ser avaliadas no escopo delimitador, pois podem depender dos valores obtidos do iterável mais à esquerda. Por exemplo: (x*y for x in range(10) for y in range(x, x+10))
.
Os parênteses podem ser omitidos em chamadas com apenas um argumento. Veja a seção Chamadas para detalhes.
Para evitar interferir com a operação esperada da própria expressão geradora, as expressões yield
e yield from
são proibidas no gerador definido implicitamente.
Se uma expressão geradora contém cláusulas async for
ou expressões await
, ela é chamada de expressão geradora assíncrona. Uma expressão geradora assíncrona retorna um novo objeto gerador assíncrono, que é um iterador assíncrono (consulte Iteradores assíncronos).
Novo na versão 3.6: Expressões geradoras assíncronas foram introduzidas.
Alterado na versão 3.7: Antes do Python 3.7, as expressões geradoras assíncronas só podiam aparecer em corrotinas async def
. A partir da versão 3.7, qualquer função pode usar expressões geradoras assíncronas.
Alterado na versão 3.8: yield
e yield from
proibidos no escopo aninhado implícito.
6.2.9. Expressões 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,
and using it in an async def
function’s body causes that
coroutine function to be an asynchronous generator. For example:
def gen(): # defines a generator function
yield 123
async def agen(): # defines an asynchronous generator function
yield 123
Devido a seus efeitos colaterais no escopo recipiente, as expressões yield
não são permitidas como parte dos escopos definidos implicitamente usados para implementar compreensões e expressões geradoras.
Alterado na versão 3.8: Expressões yield proibidas nos escopos aninhados implicitamente usados para implementar compreensões e expressões geradoras.
As funções geradoras são descritas abaixo, enquanto as funções geradoras assíncronas são descritas separadamente na seção Funções geradoras assíncronas
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. 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.
Tudo isso torna as funções geradoras bastante semelhantes às corrotinas; cedem múltiplas vezes, possuem mais de um ponto de entrada e sua execução pode ser suspensa. A única diferença é que uma função geradora não pode controlar onde a execução deve continuar após o seu rendimento; o controle é sempre transferido para o chamador do gerador.
Expressões yield são permitidas em qualquer lugar em uma construção try
. Se o gerador não for retomado antes de ser finalizado (ao atingir uma contagem de referências zero ou ao ser coletado como lixo), o método close()
do iterador de gerador será chamado, permitindo que quaisquer cláusulas finally
pendentes sejam executadas.
Quando yield from <expr>
é usado, a expressão fornecida deve ser iterável. Os valores produzidos pela iteração desse iterável são passados diretamente para o chamador dos métodos do gerador atual. Quaisquer valores passados com send()
e quaisquer exceções passadas com throw()
são passados para o iterador subjacente se ele tiver os métodos apropriados. Se este não for o caso, então send()
irá levantar AttributeError
ou TypeError
, enquanto throw()
irá apenas levantar a exceção passada imediatamente.
Quando o iterador subjacente estiver completo, o atributo value
da instância StopIteration
gerada torna-se o valor da expressão yield. Ele pode ser definido explicitamente ao levantar StopIteration
ou automaticamente quando o subiterador é um gerador (retornando um valor do subgerador).
Alterado na versão 3.3: Adicionado
yield from <expr>
para delegar o fluxo de controle a um subiterador.
Os parênteses podem ser omitidos quando a expressão yield é a única expressão no lado direito de uma instrução de atribuição.
Ver também
- PEP 255 - Simple Generators
A proposta para adicionar geradores e a instrução
yield
ao Python.- PEP 342 - Corrotinas via Geradores Aprimorados
A proposta de aprimorar a API e a sintaxe dos geradores, tornando-os utilizáveis como simples corrotinas.
- PEP 380 - Sintaxe para Delegar a um Subgerador
The proposal to introduce the
yield_from
syntax, making delegation to subgenerators easy.- PEP 525 - Geradores assíncronos
A proposta que se expandiu em PEP 492 adicionando recursos de gerador a funções de corrotina.
6.2.9.1. Métodos de iterador gerador¶
Esta subseção descreve os métodos de um iterador gerador. Eles podem ser usados para controlar a execução de uma função geradora.
Observe que chamar qualquer um dos métodos do gerador abaixo quando o gerador já estiver em execução levanta uma exceção 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 é normalmente chamado implicitamente, por exemplo por um laço
for
, ou pela função embutidanext()
.
-
generator.
send
(value)¶ Retoma a execução e “envia” um valor para a função geradora. O argumento value torna-se o resultado da expressão yield atual. O método
send()
retorna o próximo valor gerado pelo gerador, ou levantaStopIteration
se o gerador sair sem produzir outro valor. Quandosend()
é chamado para iniciar o gerador, ele deve ser chamado comNone
como argumento, porque não há nenhuma expressão yield que possa receber o valor.
-
generator.
throw
(type[, value[, traceback]])¶ Raises an exception of type
type
at the point where the generator was paused, and returns the next value yielded by the generator function. If the generator exits without yielding another value, aStopIteration
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.
-
generator.
close
()¶ Levanta
GeneratorExit
no ponto onde a função geradora foi pausada. Se a função geradora sair normalmente, já estiver fechada ou levantarGeneratorExit
(por não capturar a exceção), “close” retornará ao seu chamador. Se o gerador produzir um valor, umRuntimeError
é levantado. Se o gerador levantar qualquer outra exceção, ela será propagada para o chamador.close()
não faz nada se o gerador já saiu devido a uma exceção ou saída normal.
6.2.9.2. Exemplos¶
Aqui está um exemplo simples que demonstra o comportamento de geradores e funções geradoras:
>>> 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 exemplos usando yield from
, consulte a PEP 380: Syntax for Delegating to a Subgenerator em “O que há de novo no Python.”
6.2.9.3. Funções geradoras assíncronas¶
A presença de uma expressão yield em uma função ou método definido usando a async def
define ainda mais a função como uma função geradora assíncrona.
Quando uma função geradora assíncrona é chamada, ela retorna um iterador assíncrono conhecido como objeto gerador assíncrono. Esse objeto controla a execução da função geradora. Um objeto gerador assíncrono é normalmente usado em uma instrução async for
em uma função de corrotina de forma análoga a como um objeto gerador seria usado em uma instrução 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.
Em uma função geradora assíncrona, expressões de yield são permitidas em qualquer lugar em uma construção try
. No entanto, se um gerador assíncrono não for retomado antes de ser finalizado (alcançando uma contagem de referência zero ou sendo coletado pelo coletor de lixo), então uma expressão de yield dentro de um construção try
pode resultar em uma falha na execução das cláusulas pendentes de finally
. Nesse caso, é responsabilidade do laço de eventos ou escalonador que executa o gerador assíncrono chamar o método aclose()
do gerador iterador assíncrono e executar o objeto corrotina resultante, permitindo assim que quaisquer cláusulas pendentes de finally
sejam executadas.
To take care of finalization, an event loop should define
a finalizer function which takes an asynchronous generator-iterator
and presumably calls aclose()
and executes the coroutine.
This finalizer may be registered by calling sys.set_asyncgen_hooks()
.
When first iterated over, an asynchronous generator-iterator will store the
registered finalizer to be called upon finalization. For a reference example
of a finalizer method see the implementation of
asyncio.Loop.shutdown_asyncgens
in Lib/asyncio/base_events.py.
O expressão yield from <expr>
é um erro de sintaxe quando usado em uma função geradora assíncrona.
6.2.9.4. Métodos geradores-iteradores assíncronos¶
Esta subseção descreve os métodos de um iterador gerador assíncrono, que são usados para controlar a execução de uma função geradora.
-
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 é normalmente chamado implicitamente por um laço
async for
.
-
coroutine
agen.
asend
(value)¶ Retorna um objeto aguardável que, quando executado, retoma a execução do gerador assíncrono. Assim como o método
send()
para um gerador, isso “envia” um valor para a função geradora assíncrona, e o argumento value se torna o resultado da expressão de yield atual. O objeto aguardável retornado pelo métodoasend()
retornará o próximo valor produzido pelo gerador como o valor da exceçãoStopIteration
levantada, ou lançaStopAsyncIteration
se o gerador assíncrono sair sem produzir outro valor. Quandoasend()
é chamado para iniciar o gerador assíncrono, ele deve ser chamado comNone
como argumento, pois não há expressão yield que possa receber o valor.
-
coroutine
agen.
athrow
(value)¶ -
coroutine
agen.
athrow
(type[, value[, traceback]]) Retorna um objeto aguardável que gera uma exceção do tipo
type
no ponto em que o gerador assíncrono foi pausado, e retorna o próximo valor produzido pela função geradora como o valor da exceçãoStopIteration
levantada. Se o gerador assíncrono terminar sem produzir outro valor, uma exceçãoStopAsyncIteration
é levantada pelo objeto aguardável. Se a função geradora não capturar a exceção passada ou gerar uma exceção diferente, então quando o objeto aguardável for executado, essa exceção se propagará para o chamador do objeto aguardável.
-
coroutine
agen.
aclose
()¶ Retorna um objeto aguardável que, quando executado, levantará uma
GeneratorExit
na função geradora assíncrona no ponto em que foi pausada. Se a função geradora assíncrona sair de forma normal, se estiver já estiver fechada ou levantarGeneratorExit
(não capturando a exceção), então o objeto aguardável retornado levantará uma exceçãoStopIteration
. Quaisquer outros objetos aguardáveis retornados por chamadas subsequentes à função geradora assíncrona levantarão uma exceçãoStopAsyncIteration
. Se a função geradora assíncrona levantar um valor, umRuntimeError
será lançado pelo objeto aguardável. Se a função geradora assíncrona levantar qualquer outra exceção, ela será propagada para o chamador do objeto aguardável. Se a função geradora assíncrona já tiver saído devido a uma exceção ou saída normal, então chamadas posteriores ao métodoaclose()
retornarão um objeto aguardável que não faz nada.
6.3. Primárias¶
Primárias representam as operações mais fortemente vinculadas da linguagem. Sua sintaxe é:
primary ::=atom
|attributeref
|subscription
|slicing
|call
6.3.1. Referências de atributo¶
Uma referência de atributo é um primário seguido de um ponto e um nome.
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. This production can be customized by
overriding the __getattr__()
method. If this attribute is not available,
the exception AttributeError
is raised. Otherwise, the type and value of
the object produced is determined by the object. Multiple evaluations of the
same attribute reference may yield different objects.
6.3.2. Subscrições¶
A subscription selects an item of a sequence (string, tuple or list) or mapping (dictionary) object:
subscription ::=primary
"["expression_list
"]"
The primary must evaluate to an object that supports subscription (lists or
dictionaries for example). User-defined objects can support subscription by
defining a __getitem__()
method.
For built-in objects, there are two types of objects that support subscription:
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. (The expression list is a tuple except if it has exactly one item.)
If the primary is a sequence, the expression list must evaluate to an integer or a slice (as discussed in the following section).
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 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’s items are characters. A character is not a separate data type but a string of exactly one character.
6.3.3. Fatiamentos¶
Um fatiamento seleciona um intervalo de itens em um objeto sequência (por exemplo, uma string, tupla ou lista). As fatias podem ser usadas como expressões ou como alvos em instruções de atribuição ou del
. A sintaxe para um fatiamento:
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
Há ambiguidade na sintaxe formal aqui: qualquer coisa que se pareça com uma lista de expressões também se parece com uma lista de fatias, portanto qualquer subscrição pode ser interpretada como um fatiamento. Em vez de complicar ainda mais a sintaxe, isso é eliminado pela definição de que, neste caso, a interpretação como uma subscrição tem prioridade sobre a interpretação como um fatiamento (este é o caso se a lista de fatias não contiver uma fatia adequada).
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 A hierarquia de tipos padrão) 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. Chamadas¶
Uma chamada chama um objeto que é um chamável (por exemplo, uma função) com uma série possivelmente vazia 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
Uma vírgula final opcional pode estar presente após os argumentos posicionais e nomeados, mas não afeta a semântica.
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 Definições de função for the syntax of formal parameter lists.
If keyword arguments are present, they are first converted to positional
arguments, as follows. First, a list of unfilled slots is created for the
formal parameters. If there are N positional arguments, they are placed in the
first N slots. Next, for each keyword argument, the identifier is used to
determine the corresponding slot (if the identifier is the same as the first
formal parameter name, the first slot is used, and so on). If the slot is
already filled, a TypeError
exception is raised. Otherwise, the value of
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.
CPython implementation detail: Uma implementação pode fornecer funções integradas cujos parâmetros posicionais não possuem nomes, mesmo que sejam ‘nomeados’ para fins de documentação e que, portanto, não possam ser fornecidos por nomes. No CPython, este é o caso de funções implementadas em C que usam PyArg_ParseTuple()
para analisar seus argumentos.
Se houver mais argumentos posicionais do que slots de parâmetros formais, uma exceção TypeError
será levantada, a menos que um parâmetro formal usando a sintaxe *identificador
esteja presente; neste caso, esse parâmetro formal recebe uma tupla contendo os argumentos posicionais em excesso (ou uma tupla vazia se não houver argumentos posicionais em excesso).
Se algum argumento nomeado não corresponder a um nome de parâmetro formal, uma exceção TypeError
é levantada, a menos que um parâmetro formal usando a sintaxe **identificador
esteja presente; neste caso, esse parâmetro formal recebe um dicionário contendo os argumentos nomeados em excesso (usando os nomes como chaves e os valores dos argumentos como valores correspondentes), ou um (novo) dicionário vazio se não houver argumentos nomeados em excesso.
Se a sintaxe *expressão
aparecer na chamada da função, expressão
deverá ser avaliada como iterável. Os elementos desses iteráveis são tratados como se fossem argumentos posicionais adicionais. Para a chamada f(x1, x2, *y, x3, x4)
, se y for avaliado como uma sequência y1, …, yM, isso é equivalente a uma chamada com M+4 argumentos posicionais x1, x2, y1, …, yM, x3, x4.
Uma consequência disso é que embora a sintaxe *expressão
possa aparecer depois de argumentos nomeados explícitos, ela é processada antes dos argumentos nomeados (e de quaisquer argumentos de **expressão
– veja abaixo). Então:
>>> 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 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 keyword is already present
(as an explicit keyword argument, or from another unpacking),
a TypeError
exception is raised.
Parâmetros formais usando a sintaxe *identificador
ou **identificador
não podem ser usados como slots de argumentos posicionais ou como nomes de argumentos nomeados.
Alterado na versão 3.5: Chamadas de função aceitam qualquer número de desempacotamentos *
e **
, argumentos posicionais podem seguir desempacotamentos iteráveis (*
) e argumentos nomeados podem seguir desempacotamentos de dicionário (**
). Originalmente proposto pela PEP 448.
Uma chamada sempre retorna algum valor, possivelmente None
, a menos que levanta uma exceção. A forma como esse valor é calculado depende do tipo do objeto chamável.
Se for…
- uma função definida por usuário:
O bloco de código da função é executado, passando-lhe a lista de argumentos. A primeira coisa que o bloco de código fará é vincular os parâmetros formais aos argumentos; isso é descrito na seção Definições de função. Quando o bloco de código executa uma instrução
return
, isso especifica o valor de retorno da chamada de função.- um método embutido ou uma função embutida:
O resultado fica por conta do interpretador; veja Funções embutidas para descrições de funções embutidas e métodos embutidos.
- um objeto classe:
Uma nova instância dessa classe é retornada.
- um método de instância de classe:
A função correspondente definida pelo usuário é chamada, com uma lista de argumentos que é maior que a lista de argumentos da chamada: a instância se torna o primeiro argumento.
- uma instância de classe:
The class must define a
__call__()
method; the effect is then the same as if that method was called.
6.4. Expressão await¶
Suspende a execução de corrotina em um objeto aguardável. Só pode ser usado dentro de uma função de corrotina.
await_expr ::= "await" primary
Novo na versão 3.5.
6.5. O operador de potência¶
O operador de potência vincula-se com mais força do que os operadores unários à sua esquerda; ele se vincula com menos força do que os operadores unários à sua direita. A sintaxe é:
power ::= (await_expr
|primary
) ["**"u_expr
]
Assim, em uma sequência sem parênteses de operadores de potência e unários, os operadores são avaliados da direita para a esquerda (isso não restringe a ordem de avaliação dos operandos): -1**2
resulta em -1
.
O operador de potência tem a mesma semântica que a função embutida pow()
, quando chamado com dois argumentos: ele produz seu argumento esquerdo elevado à potência de seu argumento direito. Os argumentos numéricos são primeiro convertidos em um tipo comum e o resultado é desse tipo.
Para operandos int, o resultado tem o mesmo tipo que os operandos, a menos que o segundo argumento seja negativo; nesse caso, todos os argumentos são convertidos em ponto flutuante e um resultado ponto flutuante é entregue. Por exemplo, 10**2
retorna 100
, mas 10**-2
retorna 0.01
.
Elevar 0.0
a uma potência negativa resulta em uma exceção ZeroDivisionError
. Elevar um número negativo a uma potência fracionária resulta em um número complex
. (Em versões anteriores, levantava ValueError
.)
6.6. Operações aritméticas unárias e bit a bit¶
Todas as operações aritméticas unárias e bit a bit têm a mesma prioridade:
u_expr ::=power
| "-"u_expr
| "+"u_expr
| "~"u_expr
The unary -
(minus) operator yields the negation of its numeric argument.
The unary +
(plus) operator yields its numeric argument unchanged.
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.
Em todos os três casos, se o argumento não tiver o tipo adequado, uma exceção TypeError
é levantada.
6.7. Operações binárias aritméticas¶
As operações aritméticas binárias possuem os níveis de prioridade convencionais. Observe que algumas dessas operações também se aplicam a determinados tipos não numéricos. Além do operador potência, existem apenas dois níveis, um para operadores multiplicativos e outro para operadores 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
O operador *
(multiplicação) produz o produto de seus argumentos. Os argumentos devem ser números ou um argumento deve ser um número inteiro e o outro deve ser uma sequência. No primeiro caso, os números são convertidos para um tipo comum e depois multiplicados. Neste último caso, é realizada a repetição da sequência; um fator de repetição negativo produz uma sequência vazia.
O operador @
(arroba) deve ser usado para multiplicação de matrizes. Nenhum tipo embutido do Python implementa este operador.
Novo na versão 3.5.
Os operadores /
(divisão) e //
(divisão pelo piso) produzem o quociente de seus argumentos. Os argumentos numéricos são primeiro convertidos em um tipo comum. A divisão de inteiros produz um ponto flutuante, enquanto a divisão pelo piso de inteiros resulta em um inteiro; o resultado é o da divisão matemática com a função ‘floor’ aplicada ao resultado. A divisão por zero levanta a exceção ZeroDivisionError
.
O operador %
(módulo) produz o restante da divisão do primeiro argumento pelo segundo. Os argumentos numéricos são primeiro convertidos em um tipo comum. Um argumento zero à direita levanta a exceção ZeroDivisionError
. Os argumentos podem ser números de ponto flutuante, por exemplo, 3.14%0.7
é igual a 0.34
(já que 3.14
é igual a 4*0.7 + 0.34
.) O operador módulo sempre produz um resultado com o mesmo sinal do seu segundo operando (ou zero); o valor absoluto do resultado é estritamente menor que o valor absoluto do segundo operando 1.
Os operadores de divisão pelo piso e módulo são conectados pela seguinte identidade: x == (x//y)*y + (x%y)
. A divisão pelo piso e o módulo também estão conectados com a função embutida divmod()
: divmod(x, y) == (x//y, x%y)
. 2.
Além de realizar a operação de módulo em números, o operador %
também é sobrecarregado por objetos string para realizar a formatação de string no estilo antigo (também conhecida como interpolação). A sintaxe para formatação de string é descrita na Referência da Biblioteca Python, seção Formatação de String no Formato no estilo printf.
O operador de divisão pelo piso, o operador de módulo e a função divmod()
não são definidos para números complexos. Em vez disso, converta para um número de ponto flutuante usando a função abs()
se apropriado.
O operador +
(adição) produz a soma de seus argumentos. Os argumentos devem ser números ou sequências do mesmo tipo. No primeiro caso, os números são convertidos para um tipo comum e depois somados. Neste último caso, as sequências são concatenadas.
O operador -
(subtração) produz a diferença de seus argumentos. Os argumentos numéricos são primeiro convertidos em um tipo comum.
6.8. Operações de deslocamento¶
As operações de deslocamento têm menor prioridade que as operações aritméticas:
shift_expr ::=a_expr
|shift_expr
("<<" | ">>")a_expr
Esses operadores aceitam números inteiros como argumentos. Eles deslocam o primeiro argumento para a esquerda ou para a direita pelo número de bits fornecido pelo segundo argumento.
Um deslocamento para a direita por n bits é definido como divisão pelo piso por pow(2,n)
. Um deslocamento à esquerda por n bits é definido como multiplicação com pow(2,n)
.
6.9. Operações binárias bit a bit¶
Cada uma das três operações bit a bit tem um nível de prioridade diferente:
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.
The ^
operator yields the bitwise XOR (exclusive OR) of its arguments, which
must be integers.
The |
operator yields the bitwise (inclusive) OR of its arguments, which
must be integers.
6.10. Comparações¶
Ao contrário de C, todas as operações de comparação em Python têm a mesma prioridade, que é menor do que qualquer operação aritmética, de deslocamento ou bit a bit. Também diferentemente de C, expressões como a < b < c
têm a interpretação que é convencional em matemática:
comparison ::=or_expr
(comp_operator
or_expr
)* comp_operator ::= "<" | ">" | "==" | ">=" | "<=" | "!=" | "is" ["not"] | ["not"] "in"
Comparisons yield boolean values: True
or False
.
As comparações podem ser encadeadas arbitrariamente, por exemplo, x < y <= z
é equivalente a x < y and y <= z
, exceto que y
é avaliado apenas uma vez (mas em ambos os casos z
não é avaliado quando x < y
é considerado falso).
Formalmente, se a, b, c, …, y, z são expressões e op1, op2, …, opN são operadores de comparação, então a op1 b op2 c ... y opN z
é equivalente a a op1 b e b op2 c e ... y opN z
, exceto que cada expressão é avaliada no máximo uma vez.
Observe que a op1 b op2 c
não implica qualquer tipo de comparação entre a e c, de modo que, por exemplo, x < y > z
é perfeitamente válido (embora talvez não seja bonito).
6.10.1. Comparações de valor¶
Os operadores <
, >
, ==
, >=
, <=
e !=
comparam os valores de dois objetos. Os objetos não precisam ser do mesmo tipo.
O capítulo Objetos, valores e tipos afirma que os objetos possuem um valor (além do tipo e da identidade). O valor de um objeto é uma noção bastante abstrata em Python: por exemplo, não existe um método de acesso canônico para o valor de um objeto. Além disso, não há exigência de que o valor de um objeto seja construído de uma maneira específica, por exemplo. composto por todos os seus atributos de dados. Os operadores de comparação implementam uma noção específica de qual é o valor de um objeto. Pode-se pensar neles como definindo o valor de um objeto indiretamente, por meio de sua implementação de comparação.
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
Personalização básica.
O comportamento padrão para comparação de igualdade (==
e !=
) é baseado na identidade dos objetos. Consequentemente, a comparação da igualdade de instâncias com a mesma identidade resulta em igualdade, e a comparação da igualdade de instâncias com identidades diferentes resulta em desigualdade. Uma motivação para este comportamento padrão é o desejo de que todos os objetos sejam reflexivos (ou seja, x is y
implica x == y
).
Uma comparação de ordem padrão (<
, >
, <=
e >=
) não é fornecida; uma tentativa levanta TypeError
. Uma motivação para este comportamento padrão é a falta de um invariante semelhante ao da igualdade.
O comportamento da comparação de igualdade padrão, de que instâncias com identidades diferentes são sempre desiguais, pode contrastar com o que os tipos precisarão ter uma definição sensata de valor de objeto e igualdade baseada em valor. Esses tipos precisarão personalizar seu comportamento de comparação e, de fato, vários tipos embutidos fizeram isso.
A lista a seguir descreve o comportamento de comparação dos tipos embutidos mais importantes.
Números de tipos numéricos embutidos (Tipos numéricos — int, float, complex) e dos tipos de biblioteca padrão
fractions.Fraction
edecimal.Decimal
podem ser comparados dentro e entre seus tipos, com a restrição que os números complexos não oferecem suporte a comparação de ordens. Dentro dos limites dos tipos envolvidos, eles comparam matematicamente (algoritmicamente) corretos sem perda de precisão.Os valores não numéricos
float('NaN')
edecimal.Decimal('NaN')
são especiais. Qualquer comparação ordenada de um número com um valor que não é um número é falsa. Uma implicação contraintuitiva é que os valores que não são numéricos não são iguais a si mesmos. Por exemplo, sex = float('NaN')
,3 < x
,x < 3
ex == x
são todos falsos, enquantox != x
é verdadeiro. Esse comportamento é compatível com IEEE 754.None
andNotImplemented
are singletons. PEP 8 advises that comparisons for singletons should always be done withis
oris not
, never the equality operators.Sequências binárias (instâncias de
bytes
oubytearray
) podem ser comparadas dentro e entre seus tipos. Eles comparam lexicograficamente usando os valores numéricos de seus elementos.Strings (instâncias de
str
) são comparadas lexicograficamente usando os pontos de código Unicode numéricos (o resultado da função embutidaord()
) de seus caracteres. 3Strings e sequências binárias não podem ser comparadas diretamente.
Sequências (instâncias de
tuple
,list
ourange
) podem ser comparadas apenas dentro de cada um de seus tipos, com a restrição de que intervalos não oferecem suporte a comparação de ordem. A comparação de igualdade entre esses tipos resulta em desigualdade, e a comparação ordenada entre esses tipos levantaTypeError
.As sequências são comparadas lexicograficamente usando a comparação de elementos correspondentes. Os contêineres embutidos normalmente presumem que objetos idênticos são iguais a si mesmos. Isso permite ignorar testes de igualdade para objetos idênticos para melhorar o desempenho e manter seus invariantes internos.
A comparação lexicográfica entre coleções embutidas funciona da seguinte forma:
Para que duas coleções sejam comparadas iguais, elas devem ser do mesmo tipo, ter o mesmo comprimento e cada par de elementos correspondentes deve ser comparado igual (por exemplo,
[1,2] == (1,2)
é false porque o tipo não é o mesmo).Coleções que oferecem suporte a comparação de ordem são ordenadas da mesma forma que seus primeiros elementos desiguais (por exemplo,
[1,2,x] <= [1,2,y]
tem o mesmo valor quex <= y
). Se um elemento correspondente não existir, a coleção mais curta é ordenada primeiro (por exemplo,[1,2] < [1,2,3]
é verdadeiro).
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.Comparações de ordem (
<
,>
,<=
e>=
) levantamTypeError
.Conjuntos (instâncias de
set
oufrozenset
) podem ser comparados dentro e entre seus tipos.Eles definem operadores de comparação de ordem para significar testes de subconjunto e superconjunto. Essas relações não definem ordenações totais (por exemplo, os dois conjuntos
{1,2}
e{2,3}
não são iguais, nem subconjuntos um do outro, nem superconjuntos um do outro). Consequentemente, conjuntos não são argumentos apropriados para funções que dependem de ordenação total (por exemplo,min()
,max()
esorted()
produzem resultados indefinidos dada uma lista de conjuntos como entradas) .A comparação de conjuntos reforça a reflexividade de seus elementos.
A maioria dos outros tipos embutidos não possui métodos de comparação implementados, portanto, eles herdam o comportamento de comparação padrão.
As classes definidas pelo usuário que personalizam seu comportamento de comparação devem seguir algumas regras de consistência, se possível:
A comparação da igualdade deve ser reflexiva. Em outras palavras, objetos idênticos devem ser comparados iguais:
x is y
implica emx == y
A comparação deve ser simétrica. Em outras palavras, as seguintes expressões devem ter o mesmo resultado:
x == y
ey == x
x != y
ey != x
x < y
ey > x
x <= y
ey >= x
A comparação deve ser transitiva. Os seguintes exemplos (não exaustivos) ilustram isso:
x > y and y > z
implica emx > z
x < y and y <= z
implica emx < z
A comparação inversa deve resultar na negação booleana. Em outras palavras, as seguintes expressões devem ter o mesmo resultado:
x == y
enot x != y
x < y
enot x >= y
(pra classificação total)x > y
enot x <= y
(pra classificação total)As duas últimas expressões aplicam-se a coleções totalmente ordenadas (por exemplo, a sequências, mas não a conjuntos ou mapeamentos). Veja também o decorador
total_ordering()
.O resultado
hash()
deve ser consistente com a igualdade. Objetos iguais devem ter o mesmo valor de hash ou ser marcados como não-hasheáveis.
Python não impõe essas regras de consistência. Na verdade, os valores não numéricos são um exemplo de não cumprimento dessas regras.
6.10.2. Operações de teste de pertinência¶
Os operadores in
e not in
testam se um operando é membro ou não de outro. x in s
é avaliado como True
se x for membro de s, e False
caso contrário. x not in s
retorna a negação de x in s
. Todas as sequências e tipos de conjuntos embutidos oferecem suporte a isso, assim como o dicionário, para o qual in
testa se o dicionário tem uma determinada chave. Para tipos de contêiner como list, tuple, set, frozenset, dict ou Collections.deque, a expressão x in y
é equivalente a any(x is e or x == e for e in y)
.
Para os tipos string e bytes, x in y
é True
se e somente se x for uma substring de y. Um teste equivalente é y.find(x) != -1
. Strings vazias são sempre consideradas uma substring de qualquer outra string, então "" 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).
O operador not in
é definido para ter o valor verdade inverso de in
.
6.10.3. Comparações de identidade¶
Os operadores is
e is not
testam a identidade de um objeto: x is y
é verdadeiro se, e somente se, x e y são o mesmo objeto. A identidade de um objeto é determinada usando a função id()
. x is not y
produz o valor verdade inverso. 4
6.11. Operações 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.
O operador not
produz True
se seu argumento for falso, False
caso contrário.
A expressão x and y
primeiro avalia x; se x for falso, seu valor será retornado; caso contrário, y será avaliado e o valor resultante será retornado.
A expressão x or y
primeiro avalia x; se x for verdadeiro, seu valor será retornado; caso contrário, y será avaliado e o valor resultante será retornado.
Observe que nem and
nem or
restringem o valor e o tipo que retornam para False
e True
, mas sim retornam o último argumento avaliado. Isso às vezes é útil, por exemplo, se s
é uma string que deve ser substituída por um valor padrão se estiver vazia, a expressão s or 'foo'
produz o valor desejado. Como not
precisa criar um novo valor, ele retorna um valor booleano independente do tipo de seu argumento (por exemplo, not 'foo'
produz False
em vez de ''
.)
6.12. Expressões de atribuição¶
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
.
Um caso de uso comum é ao lidar com expressões regulares correspondentes:
if matching := pattern.search(data):
do_something(matching)
Ou, ao processar um fluxo de arquivos em partes:
while chunk := file.read(9000):
process(chunk)
Novo na versão 3.8: Veja PEP 572 para mais detalhes sobre expressões de atribuição.
6.13. Expressões condicionais¶
conditional_expression ::=or_test
["if"or_test
"else"expression
] expression ::=conditional_expression
|lambda_expr
expression_nocond ::=or_test
|lambda_expr_nocond
Expressões condicionais (às vezes chamadas de “operador ternário”) têm a prioridade mais baixa de todas as operações Python.
A expressão x if C else y
primeiro avalia a condição, C em vez de x. Se C for verdadeiro, x é avaliado e seu valor é retornado; caso contrário, y será avaliado e seu valor será retornado.
Veja PEP 308 para mais detalhes sobre expressões condicionais.
6.14. Lambdas¶
lambda_expr ::= "lambda" [parameter_list
] ":"expression
lambda_expr_nocond ::= "lambda" [parameter_list
] ":"expression_nocond
Expressões lambda (às vezes chamadas de funções lambda) são usadas para criar funções anônimas. A expressão lambda parameters: expression
produz um objeto função. O objeto sem nome se comporta como um objeto de função definido com:
def <lambda>(parameters):
return expression
Veja a seção Definições de função para a sintaxe das listas de parâmetros. Observe que as funções criadas com expressões lambda não podem conter instruções ou anotações.
6.15. Listas de expressões¶
expression_list ::=expression
(","expression
)* [","] starred_list ::=starred_item
(","starred_item
)* [","] starred_expression ::=expression
| (starred_item
",")* [starred_item
] starred_item ::=assignment_expression
| "*"or_expr
Exceto quando parte de uma sintaxe de criação de lista ou conjunto, uma lista de expressões contendo pelo menos uma vírgula produz uma tupla. O comprimento da tupla é o número de expressões na lista. As expressões são avaliadas da esquerda para a direita.
Um asterisco *
denota desempacotamento de iterável. Seu operando deve ser um iterável. O iterável é expandido em uma sequência de itens, que são incluídos na nova tupla, lista ou conjunto, no local do desempacotamento.
Novo na versão 3.5: Desempacotamento de iterável em listas de expressões, originalmente proposta pela PEP 448.
The trailing comma is required only to create a single tuple (a.k.a. a
singleton); 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. Ordem de avaliação¶
Python avalia expressões da esquerda para a direita. Observe que ao avaliar uma tarefa, o lado direito é avaliado antes do lado esquerdo.
Nas linhas a seguir, as expressões serão avaliadas na ordem aritmética de seus sufixos:
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. Precedência de operadores¶
The following table summarizes the operator precedence in Python, from lowest precedence (least binding) to highest precedence (most 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, which groups from right to left).
Observe que comparações, testes de pertinência e testes de identidade têm todos a mesma precedência e possuem um recurso de encadeamento da esquerda para a direita, conforme descrito na seção Comparações.
Operador |
Descrição |
---|---|
|
Expressão de atribuição |
Expressão lambda |
|
|
Expressão condicional |
OU (OR) booleano |
|
E (AND) booleano |
|
|
NEGAÇÃO (NOT) booleana |
Comparações, incluindo testes de pertinência e testes de identidade |
|
|
OU (OR) bit a bit |
|
OU EXCLUSIVO (XOR) bit a bit |
|
E (AND) bit a bit |
|
Deslocamentos |
|
Adição e subtração |
|
Multiplicação, multiplicação de matrizes, divisão, divisão pelo piso, resto 5 |
|
positivo, negativo, NEGAÇÃO (NOT) bit a bit |
|
Exponenciação 6 |
|
Expressão await |
|
subscrição, fatiamento, chamada, referência a atributo |
|
Expressão entre parênteses ou de ligação, sintaxe de criação de lista, sintaxe de criação de dicionário, sintaxe de criação de conjunto |
Notas de rodapé
- 1
Embora
abs(x%y) < abs(y)
seja verdadeiro matematicamente, para números flutuantes pode não ser verdadeiro numericamente devido ao arredondamento. Por exemplo, e presumindo uma plataforma na qual um float Python seja um número de precisão dupla IEEE 754, para que-1e-100 % 1e100
tenha o mesmo sinal que1e100
, o resultado calculado é-1e-100 + 1e100
, que é numericamente exatamente igual a1e100
. A funçãomath.fmod()
retorna um resultado cujo sinal corresponde ao sinal do primeiro argumento e, portanto, retorna-1e-100
neste caso. Qual abordagem é mais apropriada depende da aplicação.- 2
Se x estiver muito próximo de um múltiplo inteiro exato de y, é possível que
x//y
seja maior que(x-x%y)//y
devido ao arredondamento. Nesses casos, Python retorna o último resultado, para preservar quedivmod(x,y)[0] * y + x % y
esteja muito próximo dex
.- 3
O padrão Unicode distingue entre pontos de código (por exemplo, U+0041) e caracteres abstratos (por exemplo, “LATIN CAPITAL LETTER A”). Embora a maioria dos caracteres abstratos em Unicode sejam representados apenas por meio de um ponto de código, há vários caracteres abstratos que também podem ser representados por meio de uma sequência de mais de um ponto de código. Por exemplo, o caractere abstrato “LATIN CAPITAL LETTER C WITH CEDILLA” pode ser representado como um único caractere pré-composto na posição de código U+00C7, ou como uma sequência de um caractere base na posição de código U+0043 (LATIN CAPITAL LETTER C), seguido por um caractere de combinação na posição de código U+0327 (COMBINING CEDILLA).
Os operadores de comparação em strings são comparados no nível dos pontos de código Unicode. Isso pode ser contraintuitivo para os humanos. Por exemplo,
"\u00C7" == "\u0043\u0327"
éFalse
, mesmo que ambas as strings representem o mesmo caractere abstrato “LATIN CAPITAL LETTER C WITH CEDILLA”.Para comparar strings no nível de caracteres abstratos (ou seja, de uma forma intuitiva para humanos), use
unicodedata.normalize()
.- 4
Devido à coleta de lixo automática, às listas livres e à natureza dinâmica dos descritores, você pode notar um comportamento aparentemente incomum em certos usos do operador
is
, como aqueles que envolvem comparações entre métodos de instância ou constantes. Confira a documentação para obter mais informações.- 5
O operador
%
também é usado para formatação de strings; a mesma precedência se aplica.- 6
O operador de potência
**
liga-se com menos força do que um operador aritmético ou unário bit a bit à sua direita, ou seja,2**-1
é0.5
.