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

#### 6.2.1.1. Private name mangling

When an identifier that textually occurs in a class definition begins with two or more underscore characters and does not end in two or more underscores, it is considered a private name of that class.

Ver também

The class specifications.

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

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

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

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

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

- The name of an imported member, e.g., `__f` in `from spam import __f`.

The transformation rule is defined as follows:

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

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

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

Observe que as tuplas não são formadas pelos parênteses, mas sim pelo uso da vírgula. A exceção é a tupla vazia, para a qual os parênteses são obrigatórios – permitir “nada” sem parênteses em expressões causaria ambiguidades e permitiria que erros de digitação comuns passassem sem serem detectados.

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

Desde o Python 3.6, em uma função `async def`, uma cláusula `async for` pode ser usada para iterar sobre um iterador assíncrono. Uma compreensão em uma função `async def` pode consistir em uma cláusula `for` ou `async for` seguindo a expressão inicial, pode conter `for` adicional ou `async for` e também pode usar expressões `await`.

Se uma compreensão contém cláusulas `async for`, ou se contém expressões `await` ou outras compreensões assíncronas em qualquer lugar, exceto a expressão iterável na cláusula `for` mais à esquerda, ela é chamada uma compreensão assíncrona. Uma compreensão assíncrona pode suspender a execução da função de corrotina em que aparece. Veja também a PEP 530.

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

Alterado na versão 3.11: Compreensões assíncronas agora são permitidas dentro de compreensões em funções assíncronas. As compreensões externas tornam-se implicitamente assíncronas.

### 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 sintaxe de criação de dicionário é uma série possivelmente vazia de itens de dicionário (pares chave/valor) envolto entre chaves:

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

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 itens de dicionário, 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 valor correspondente. Isso significa que você pode especificar a mesma chave várias vezes na lista de itens de dicionário, 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 itens de dicionário anteriores e desempacotamentos de dicionário anteriores.

Adicionado na versão 3.5: Descompactando 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 valor (textualmente mais à direita na sintaxe de criação) 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).

Adicionado 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_from       ::=  "yield" "from" expression
    yield_expression ::=  "yield" expression_list | yield_from

A expressão yield é usada ao definir uma função generadora ou uma função geradora assíncrona e, portanto, só pode ser usada no corpo de uma definição de função. Usar uma expressão yield no corpo de uma função faz com que essa função seja uma função geradora, e usá-la no corpo de uma função `async def` faz com que essa função de corrotina seja uma função geradora assíncrona. Por exemplo:

    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

Quando uma função geradora é chamada, ela retorna um iterador conhecido como gerador. Esse gerador então controla a execução da função geradora. A execução começa quando um dos métodos do gerador é chamado. Nesse momento, a execução segue para a primeira expressão yield, onde é suspensa novamente, retornando o valor de `expression_list` ao chamador do gerador, ou `None` se `expression_list` é omitido. Por suspenso, queremos dizer que todo o estado local é retido, incluindo as chamadas atuais de variáveis locais, o ponteiro de instrução, a pilha de avaliação interna e o estado de qualquer tratamento de exceção. Quando a execução é retomada chamando um dos métodos do gerador, a função pode prosseguir exatamente como se a expressão yield fosse apenas outra chamada externa. O valor da expressão yield após a retomada depende do método que retomou a execução. Se `__next__()` for usado (tipicamente através de uma `for` ou do `next()` embutido) então o resultado será `None`. Caso contrário, se `send()` for usado, o resultado será o valor passado para esse método.

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 - Geradores simples

  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

  A proposta de introduzir a sintaxe `yield_from`, facilitando a delegação a subgeradores.

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__()

  Inicia a execução de uma função geradora ou a retoma na última expressão yield executada. Quando uma função geradora é retomada com um método `__next__()`, a expressão yield atual sempre é avaliada como `None`. A execução então continua para a próxima expressão yield, onde o gerador é suspenso novamente, e o valor de `expression_list` é retornado para o chamador de `__next__()`. Se o gerador sair sem produzir outro valor, uma exceção `StopIteration` será levantada.

  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(value)
generator.throw(type[, value[, traceback]])

  Levanta uma exceção no ponto em que o gerador foi pausado e retorna o próximo valor gerado pela função geradora. Se o gerador sair sem gerar outro valor, uma exceção `StopIteration` será levantada. Se a função geradora não detectar a exceção passada ou levanta uma exceção diferente, essa exceção se propagará para o chamador.

  Em uso típico, isso é chamado com uma única instância de exceção semelhante à forma como a palavra reservada `raise` é usada.

  Para compatibilidade com versões anteriores, no entanto, a segunda assinatura é suportada, seguindo uma convenção de versões mais antigas do Python. O argumento type deve ser uma classe de exceção e value deve ser uma instância de exceção. Se o valor não for fornecido, o construtor tipo será chamado para obter uma instância. Se traceback for fornecido, ele será definido na exceção, caso contrário, qualquer atributo `__traceback__` existente armazenado em value poderá ser limpo.

  Alterado na versão 3.12: A segunda assinatura (tipo[, valor[, traceback]]) foi descontinuada e pode ser removida em uma versão futura do Python.

generator.close()

  Levanta `GeneratorExit` no ponto onde a função geradora foi pausada. Se a função geradora captura a exceção, e retorna um valor, este valor é retornado de `close()`. Se a função geradora já estiver fechada ou levantar `GeneratorExit` (por não capturar a exceção), `close()` retornará `None`. Se o gerador produzir um valor, uma exceção `RuntimeError` é levantada. Se o gerador levantar qualquer outra exceção, ela será propagada para o chamador. Se o gerador já saiu devido a uma exceção ou saída normal, `close()` retorna `None` e tem nenhum outro efeito.

  Alterado na versão 3.13: Se um gerador retornar um valor ao ser fechado, o valor será retornado por `close()`.

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

A chamada de um dos métodos do gerador assíncrono retorna um objeto aguardável, e a execução começa quando esse objeto é aguardado. Nesse momento, a execução prossegue até a primeira expressão yield, onde é suspensa novamente, retornando o valor de `expression_list` para a corrotina em aguardo. Assim como ocorre com um gerador, a suspensão significa que todo o estado local é mantido, inclusive as ligações atuais das variáveis locais, o ponteiro de instruções, a pilha de avaliação interna e o estado de qualquer tratamento de exceção. Quando a execução é retomada, aguardando o próximo objeto retornado pelos métodos do gerador assíncrono, a função pode prosseguir exatamente como se a expressão de rendimento fosse apenas outra chamada externa. O valor da expressão yield após a retomada depende do método que retomou a execução. Se `__anext__()` for usado, o resultado será `None`. Caso contrário, se `asend()` for usado, o resultado será o valor passado para esse método.

Se um gerador assíncrono encerrar mais cedo por `break`, pela tarefa que fez sua chamada ser cancelada ou por outras exceções, o código de limpeza assíncrona do gerador será executado e possivelmente levantará alguma exceção ou acessará as variáveis de contexto em um contexto inesperado – talvez após o tempo de vida das tarefas das quais ele depende, ou durante o laço de eventos de encerramento quando o gancho de coleta de lixo do gerador assíncrono for chamado. Para prevenir isso, o chamador deve encerrar explicitamente o gerador assíncrono chamando o método `aclose()` para finalizar o gerador e, por fim, desconectá-lo do laço de eventos.

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.

Para cuidar da finalização após o término do laço de eventos, um laço de eventos deve definir uma função finalizer que recebe um gerador assíncrono e provavelmente chama `aclose()` e executa a corrotina. Este finalizer pode ser registrado chamando `sys.set_asyncgen_hooks()`. Quando iterado pela primeira vez, um gerador assíncrono armazenará o finalizer registrado para ser chamado na finalização. Para um exemplo de referência de um método finalizer, consulte a implementação de `asyncio.Loop.shutdown_asyncgens` em 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__()

  Retorna um objeto aguardável que, quando executado, começa a executar o gerador assíncrono ou o retoma na última expressão yield executada. Quando uma função geradora assíncrona é retomada com o método `__anext__()`, a expressão yield atual sempre avalia para `None` no objeto aguardável retornado, que, quando executado, continuará para a próxima expressão yield. O valor de `expression_list` da expressão yield é o valor da exceção `StopIteration` levantada pela corrotina em conclusão. Se o gerador assíncrono sair sem produzir outro valor, o objeto aguardável em vez disso levanta uma exceção `StopAsyncIteration`, sinalizando que a iteração assíncrona foi concluída.

  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.

  Alterado na versão 3.12: A segunda assinatura (tipo[, valor[, traceback]]) foi descontinuada e pode ser removida em uma versão futura do Python.

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

A primária deve avaliar para um objeto de um tipo que tem suporte a referências de atributo, o que a maioria dos objetos faz. Este objeto é então solicitado a produzir o atributo cujo nome é o identificador. O tipo e o valor produzido são determinados pelo objeto. Várias avaliações da mesma referência de atributo podem produzir diferentes objetos.

Esta produção pode ser personalizada substituindo o método `__getattribute__()` ou o método `__getattr__()`. O método `__getattribute__()` é chamado primeiro e retorna um valor ou levanta uma `AttributeError` se o atributo não estiver disponível.

Se for levantada uma `AttributeError` e o objeto tiver um método `__getattr__()`, esse método será chamado como alternativa.

### 6.3.2. Subscrições

A subscrição de uma instância de uma classe de classe de contêiner geralmente selecionará um elemento do contêiner. A subscrição de uma classe genérica geralmente retornará um objeto GenericAlias.

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

Quando um objeto é subscrito, o interpretador avaliará o primário e a lista de expressões.

O primário deve ser avaliado como um objeto que dê suporte à subscrição. Um objeto pode prover suporte a subscrição através da definição de um ou ambos `__getitem__()` e `__class_getitem__()`. Quando o primário é subscrito, o resultado avaliado da lista de expressões será passado para um desses métodos. Para mais detalhes sobre quando `__class_getitem__` é chamado em vez de `__getitem__`, veja __class_getitem__ versus __getitem__.

Se a lista de expressões contiver pelo menos uma vírgula, ela será avaliada como uma `tuple` contendo os itens da lista de expressões. Caso contrário, a lista de expressões será avaliada como o valor do único membro da lista.

Para objetos embutido, existem dois tipos de objetos que oferecem suporte a subscrição via `__getitem__()`:

1. Mapeamentos. Se o primário for um mapeamento, a lista de expressões deve ser avaliada como um objeto cujo valor é uma das chaves do mapeamento, e a subscrição seleciona o valor no mapeamento que corresponde a essa chave. Um exemplo de classe de mapeamento integrada é a classe `dict`.

2. Sequências. Se o primário for uma sequência, a lista de expressões deve ser avaliada como `int` ou `slice` (conforme discutido na seção seguinte). Exemplos de classes de sequência embutidas incluem as classes `str`, `list` e `tuple`.

A sintaxe formal não faz nenhuma provisão especial para índices negativos em sequências. No entanto, todas as sequências embutidas fornecem um método `__getitem__()` que interpreta índices negativos adicionando o comprimento da sequência ao índice para que, por exemplo, `x[-1]` selecione o último item de `x`. O valor resultante deve ser um número inteiro não negativo menor que o número de itens na sequência, e a subscrição seleciona o item cujo índice é esse valor (contando a partir de zero). Como o suporte para índices negativos e fatiamento ocorre no método `__getitem__()` do objeto, as subclasses que substituem esse método precisarão adicionar explicitamente esse suporte.

Uma `string` é um tipo especial de sequência cujos itens são caracteres. Um caractere não é um tipo de dados separado, mas uma string de exatamente um caractere.

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

A semântica para um fatiamento é a seguinte. O primário é indexado (usando o mesmo método `__getitem__()` da subscrição normal) com uma chave que é construída a partir da lista de fatias, como segue. Se a lista de fatias contiver pelo menos uma vírgula, a chave será uma tupla contendo a conversão dos itens da fatia; caso contrário, a conversão do item de fatia isolada é a chave. A conversão de um item de fatia que é uma expressão é essa expressão. A conversão de uma fatia adequada é um objeto fatia (veja a seção A hierarquia de tipos padrão) cujos `start`, `stop` e `step` atributos são os valores das expressões fornecidas como limite inferior, limite superior e passo, respectivamente, substituindo `None` pelas expressões ausentes.

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

O primário deve ser avaliado como um objeto que pode ser chamado (funções definidas pelo usuário, funções embutidas, métodos de objetos embutidos, objetos de classe, métodos de instâncias de classe e todos os objetos que possuem um método `__call__()` são chamáveis). Todas as expressões de argumento são avaliadas antes da tentativa de chamada. Consulte a seção Definições de função para a sintaxe das listas formais de parâmetros.

Se houver argumentos nomeados, eles serão primeiro convertidos em argumentos posicionais, como segue. Primeiro, é criada uma lista de slots não preenchidos para os parâmetros formais. Se houver N argumentos posicionais, eles serão colocados nos primeiros N slots. A seguir, para cada argumento nomeado, o identificador é usado para determinar o slot correspondente (se o identificador for igual ao primeiro nome formal do parâmetro, o primeiro slot será usado e assim por diante). Se o slot já estiver preenchido, uma exceção `TypeError` será levantada. Caso contrário, o argumento é colocado no slot, preenchendo-o (mesmo que a expressão seja `None`, ela preenche o slot). Quando todos os argumentos forem processados, os slots ainda não preenchidos serão preenchidos com o valor padrão correspondente da definição da função. (Os valores padrão são calculados, uma vez, quando a função é definida; assim, um objeto mutável, como uma lista ou dicionário usado como valor padrão, será compartilhado por todas as chamadas que não especificam um valor de argumento para o slot correspondente; isso deve geralmente ser evitado.) Se houver algum slot não preenchido para o qual nenhum valor padrão for especificado, uma exceção `TypeError` será levantada. Caso contrário, a lista de slots preenchidos será usada como lista de argumentos para a chamada.

Detalhes da implementação do CPython: 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

É incomum que ambos os argumentos nomeados e a sintaxe `*expressão` sejam usados na mesma chamada, portanto, na prática, essa confusão não surge com frequência.

Se a sintaxe `**expressão` aparecer na chamada de função, `expressão` deve ser avaliada como um mapeamento, cujo conteúdo é tratado como argumentos nomeados adicionais. Se um parâmetro que corresponde a uma chave já recebeu um valor (por um argumento nomeado explícito ou de outra descompactação), uma exceção `TypeError` é levantada.

Quando `**expressão` é usada, cada chave neste mapeamento deve ser uma string. Cada valor do mapeamento é atribuído ao primeiro parâmetro formal elegível para atribuição de nomeas cujo nome é igual à chave. Uma chave não precisa ser um identificador Python (por exemplo, `"max-temp °F"` é aceitável, embora não corresponda a nenhum parâmetro formal que possa ser declarado). Se não houver correspondência com um parâmetro formal, o par chave-valor é coletado pelo parâmetro `**`, se houver, ou se não houver, uma exceção `TypeError` é levantada.

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 descompactações `*` e `**`, argumentos posicionais podem seguir descompactações iteráveis (`*`) e argumentos nomeados podem seguir descompactações 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:

  A classe deve definir um método `__call__()`; o efeito é então o mesmo como se esse método fosse chamado.

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

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

Esta operação pode ser personalizada usando os métodos especial `__pow__()` e `__rpow__()`.

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

O operador unário `-` (menos) produz a negação de seu argumento numérico; a operação pode ser substituída pelo método especial `__neg__()`.

O operador unário `+` (mais) produz seu argumento numérico inalterado; a operação pode ser substituída pelo método especial `__pos__()`.

O operador unário `~` (inverter) produz a inversão bit a bit de seu argumento inteiro. A inversão bit a bit de `x` é definida como `-(x+1)`. Aplica-se apenas a números inteiros ou a objetos personalizados que substituem o método especial `__invert__()`.

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.

Esta operação pode ser personalizada usando os métodos especial `__mul__()` e `__rmul__()`.

O operador `@` (arroba) deve ser usado para multiplicação de matrizes. Nenhum tipo embutido do Python implementa este operador.

Esta operação pode ser personalizada usando os métodos especial `__matmul__()` e `__rmatmul__()`.

Adicionado 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`.

A operação de divisão pode ser personalizada usando os métodos especiais `__truediv__()` e `__rtruediv__()`. A operação de divisão pelo piso pode ser personalizada usando os métodos especiais `__floordiv__()` e `__rfloordiv__()`.

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.

A operação módulo pode ser personalizada usando os métodos especial `__mod__()` e `__rmod__()`.

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.

Esta operação pode ser personalizada usando os métodos especial `__add__()` e `__radd__()`.

O operador `-` (subtração) produz a diferença de seus argumentos. Os argumentos numéricos são primeiro convertidos em um tipo comum.

Esta operação pode ser personalizada usando os métodos especial `__sub__()` e `__rsub__()`.

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

A operação de deslocamento à esquerda pode ser personalizada usando os métodos especiais `__lshift__()` e `__rlshift__()`. A operação de deslocamento à direita pode ser personalizada usando os métodos especiais `__rshift__()` e `__rrshift__()`.

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

O operador `&` produz o E (AND) bit a bit de seus argumentos, que devem ser inteiros ou um deles deve ser um objeto personalizado substituindo os métodos especiais `__and__()` ou `__rand__()`.

O operador `^` produz o XOR bit a bit (OU exclusivo) de seus argumentos, que devem ser inteiros ou um deles deve ser um objeto personalizado sobrescrevendo os métodos especiais `__xor__()` ou `__rxor__()`.

O operador `|` produz o OU (OR) bit a bit de seus argumentos, que devem ser inteiros ou um deles deve ser um objeto personalizado sobrescrevendo os métodos especiais `__or__()` ou `__ror__()`.

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

Comparações produzem valores booleanos: `True` ou `False`. métodos de comparação rica personalizados podem retornar valores não booleanos. Neste caso, o Python chamará `bool()` nesse valor em contextos booleanos.

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.

Como todos os tipos são subtipos (diretos ou indiretos) de `object`, eles herdam o comportamento de comparação padrão de `object`. Os tipos podem personalizar seu comportamento de comparação implementando métodos de comparação rica como `__lt__()`, descrito em 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` e `NotImplemented` são singletons. PEP 8 aconselha que comparações para singletons devem sempre ser feitas com `is` ou `is not`, nunca com os operadores de igualdade.

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

- Mapeamentos (instâncias de `dict`) comparam iguais se e somente se eles tiverem pares `(chave, valor)` iguais. A comparação de igualdade das chaves e valores reforça a reflexividade.

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

Para classes definidas pelo usuário que definem o método `__contains__()`, `x in y` retorna `True` se `y.__contains__(x)` retorna um valor verdadeiro, e `False` caso contrário.

Para classes definidas pelo usuário que não definem `__contains__()`, mas definem `__iter__()`, `x in y` é `True` se algum valor `z`, para a qual a expressão `x is z or x == z` é verdadeira, é produzida durante a iteração sobre `y`. Se uma exceção for levantada durante a iteração, é como se `in` tivesse levantado essa exceção.

Por último, o protocolo de iteração de estilo antigo é tentado: se uma classe define `__getitem__()`, `x in y` é `True` se, e somente se, houver um índice inteiro não negativo i tal que `x is y[i] or x == y[i]`, e nenhum índice inteiro inferior levanta a exceção `IndexError`. (Se qualquer outra exceção for levantada, é como se `in` levantasse essa exceção).

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

No contexto de operações booleanas, e também quando expressões são usadas por instruções de fluxo de controle, os seguintes valores são interpretados como falsos: `False`, `None`, zero numérico de todos os tipos e strings e contêineres vazios (incluindo strings, tuplas, listas, dicionários, conjuntos e frozensets). Todos os outros valores são interpretados como verdadeiros. Objetos definidos pelo usuário podem personalizar seu valor verdade fornecendo um método `__bool__()`.

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

Uma expressão de atribuição (às vezes também chamada de “expressão nomeada” ou “morsa”) atribui um `expression` a um `identifier`, ao mesmo tempo que retorna o valor de `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)

As expressões de atribuição devem ser colocadas entre parênteses quando usadas como instruções de expressão e quando usadas como subexpressões em expressões de fatiamento, condicionais, de lambda, de argumento nomeado e de if de compreensão e em instruções `assert`, `with` e `assignment`. Em todos os outros lugares onde eles podem ser usados, os parênteses não são necessários, inclusive nas instruções `if` e `while`.

Adicionado 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

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

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 descompactação 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 da descompactação.

Adicionado na versão 3.5: Descompactação de iterável em listas de expressões, originalmente proposta pela PEP 448.

Uma vírgula final é necessária apenas para criar uma tupla de um item, como `1,`; é opcional em todos os outros casos. Uma única expressão sem vírgula final não cria uma tupla, mas produz o valor dessa expressão. (Para criar uma tupla vazia, use um par vazio de parênteses: `()`.)

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

A tabela a seguir resume a precedência de operadores no Python, da precedência mais alta (mais vinculativa) à precedência mais baixa (menos vinculativa). Os operadores na mesma caixa têm a mesma precedência. A menos que a sintaxe seja fornecida explicitamente, os operadores são binários. Os operadores na mesma caixa agrupam-se da esquerda para a direita (exceto exponenciação e expressões condicionais, que agrupam da direita para a esquerda).

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
--- | ---
`(expressions...)`, `[expressões...]`, `{chave: valor...}`, `{expressões...}` | 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
`x[índice]`, `x[índice:índice]`, `x(argumentos...)`, `x.atributo` | subscrição, fatiamento, chamada, referência a atributo
`await x` | Expressão await
`**` | Exponenciação [5]
`+x`, `-x`, `~x` | positivo, negativo, NEGAÇÃO (NOT) bit a bit
`*`, `@`, `/`, `//`, `%` | Multiplicação, multiplicação de matrizes, divisão, divisão pelo piso, resto [6]
`+`, `-` | Adição e subtração
`<<`, `>>` | Deslocamentos
`&` | E (AND) bit a bit
`^` | OU EXCLUSIVO (XOR) bit a bit
`|` | OU (OR) bit a bit
`in`, `not in`, `is`, `is not`, `<`, `<=`, `>`, `>=`, `!=`, `==` | Comparações, incluindo testes de pertinência e testes de identidade
`not x` | NEGAÇÃO (NOT) booleana
`and` | E (AND) booleano
`or` | OU (OR) booleano
`if` – `else` | Expressão condicional
`lambda` | Expressão lambda
`:=` | Expressão de atribuição

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

[6]

O operador `%` também é usado para formatação de strings; a mesma precedência se aplica.