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 to "None".  The execution then continues to the
   next yield expression, where the generator is suspended again, and
   the value of the "expression_list" is returned to "__next__()"'s
   caller.  If the generator exits without yielding another value, a
   "StopIteration" exception is raised.

   Este método é normalmente chamado implicitamente, por exemplo por
   um laço "for", ou pela função embutida "next()".

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
   levanta "StopIteration" se o gerador sair sem produzir outro valor.
   Quando "send()" é chamado para iniciar o gerador, ele deve ser
   chamado com "None" 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, 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.

generator.close()

   Levanta uma "GeneratorExit" no ponto onde a função geradora foi
   pausada. Se a função geradora então sair graciosamente, já estiver
   fechada ou levantar "GeneratorExit" (por não capturar a exceção),
   close retorna para seu chamador. Se o gerador produzir um valor, um
   "RuntimeError" é levantada. Se o gerador levantar qualquer outra
   exceção, ela será propagada para o chamador. "close()" não faz nada
   se o gerador já tiver saído 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 to "None" in the returned awaitable, which when run will
   continue to the next yield expression. The value of the
   "expression_list" of the yield expression is the value of the
   "StopIteration" exception raised by the completing coroutine.  If
   the asynchronous generator exits without yielding another value,
   the awaitable instead raises a "StopAsyncIteration" exception,
   signalling that the asynchronous iteration has completed.

   Este método é 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étodo "asend()"
   retornará o próximo valor produzido pelo gerador como o valor da
   exceção "StopIteration" levantada, ou lança "StopAsyncIteration" se
   o gerador assíncrono sair sem produzir outro valor. Quando
   "asend()" é chamado para iniciar o gerador assíncrono, ele deve ser
   chamado com "None" 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ção
   "StopIteration" levantada. Se o gerador assíncrono terminar sem
   produzir outro valor, uma exceção "StopAsyncIteration" é 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 levantar "GeneratorExit" (não
   capturando a exceção), então o objeto aguardável retornado
   levantará uma exceção "StopIteration". Quaisquer outros objetos
   aguardáveis retornados por chamadas subsequentes à função geradora
   assíncrona levantarão uma exceção "StopAsyncIteration". Se a função
   geradora assíncrona levantar um valor, um "RuntimeError" 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étodo "aclose()" 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 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" e "decimal.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')" e "decimal.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, se "x = float('NaN')", "3 < x", "x < 3" e "x == x" são
  todos falsos, enquanto "x != x" é verdadeiro. Esse comportamento é
  compatível com IEEE 754.

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

* Sequências binárias (instâncias de "bytes" ou "bytearray") 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
  embutida "ord()") de seus caracteres. [3]

  Strings e sequências binárias não podem ser comparadas diretamente.

* Sequências (instâncias de "tuple", "list" ou "range") 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 levanta "TypeError".

  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 que "x <= 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 ">=") levantam "TypeError".

* Conjuntos (instâncias de "set" ou "frozenset") 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()" e "sorted()" 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 em "x == y"

* A comparação deve ser simétrica. Em outras palavras, as seguintes
  expressões devem ter o mesmo resultado:

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

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

     "x < y" e "y > x"

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

* A comparação deve ser transitiva. Os seguintes exemplos (não
  exaustivos) ilustram isso:

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

     "x < y and y <= z" implica em "x < 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" e "not x != y"

     "x < y" e "not x >= y" (pra classificação total)

     "x > y" e "not 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               |
+-------------------------------------------------+---------------------------------------+
| "lambda"                                        | Expressão lambda                      |
+-------------------------------------------------+---------------------------------------+
| "if" -- "else"                                  | Expressão condicional                 |
+-------------------------------------------------+---------------------------------------+
| "or"                                            | OU (OR) booleano                      |
+-------------------------------------------------+---------------------------------------+
| "and"                                           | E (AND) booleano                      |
+-------------------------------------------------+---------------------------------------+
| "not" "x"                                       | NEGAÇÃO (NOT) booleana                |
+-------------------------------------------------+---------------------------------------+
| "in", "not in", "is", "is not", "<", "<=", ">", | 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]                             |
+-------------------------------------------------+---------------------------------------+
| "+x", "-x", "~x"                                | positivo, negativo, NEGAÇÃO (NOT) bit |
|                                                 | a bit                                 |
+-------------------------------------------------+---------------------------------------+
| "**"                                            | Exponenciação [6]                     |
+-------------------------------------------------+---------------------------------------+
| "await" "x"                                     | Expressão await                       |
+-------------------------------------------------+---------------------------------------+
| "x[índice]", "x[índice:índice]",                | subscrição, fatiamento, chamada,      |
| "x(argumentos...)", "x.atributo"                | referência a atributo                 |
+-------------------------------------------------+---------------------------------------+
| "(expressions...)",  "[expressões...]",         | Expressão entre parênteses ou de      |
| "{chave: valor...}", "{expressões...}"          | 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 que "1e100", o resultado
    calculado é "-1e-100 + 1e100", que é numericamente exatamente
    igual a "1e100". A função "math.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 que "divmod(x,y)[0] * y + x % y" esteja muito
    próximo de "x".

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