Python Operadores

Esta é a página de consulta rápida dos operadores do Python 3.14: os símbolos e palavras que fazem contas, comparam, combinam condições e guardam valores (+, ==, and, in, +=…). No fim está a tabela de precedência oficial, que diz quem é feito primeiro numa expressão com vários operadores. A explicação passo a passo de cada grupo está nas aulas, a partir de Operadores Aritméticos.

Aritméticos

Com textos e listas

Comparação

Toda comparação responde True ou False.

Lógicos

"Falsos" são False, None, o zero (0, 0.0) e o que está vazio ("", [], {}, set()); todo o resto conta como verdadeiro (aula Booleanos). and e or param assim que sabem a resposta: em False and …, o lado direito nem é calculado.

Identidade (is) e pertinência (in)

Variáveis usadas abaixo: x = None, a = [1, 2], b = a (o mesmo objeto) e c = [1, 2] (outra lista, igual).

idade = 5
print(idade is 5)

$ python3 ro_is5.py
/home/ana/ro_is5.py:2: SyntaxWarning: "is" with 'int' literal. Did you mean "=="?
  print(idade is 5)
True

Bit a bit

Com números inteiros, estes operadores trabalham com os bits: os zeros e uns com que o computador escreve o número. bin(n) mostra os bits (bin(6) é '0b110': 4 + 2), e 0b110 escreve um número direto em binário. Para quem está começando, o importante é não confundi-los com outras coisas: ^ não é potência, e &/| não são and/or.

Os mesmos símbolos com conjuntos e dicionários

Atribuição

O = guarda um valor numa variável. As formas com um operador na frente (+=, -=…) fazem a conta com o valor que já está lá e guardam o resultado: x += 3 é o mesmo que x = x + 3. Em cada linha abaixo, x começa valendo 10:

Há uma forma com = para cada operador de bits também. Com outros tipos, a conta é a do tipo:

O @= também existe, para o @ (mais abaixo). Formas como a, b = b, a e a = b = 0 estão nas aulas Atribuição Múltipla e Desempacotamento.

O operador morsa :=

O := ("expressão de atribuição", apelidada de operador morsa, porque o sinal lembra os olhos e as presas de uma morsa) guarda um valor numa variável e devolve esse valor, no meio de uma expressão. Serve para não calcular a mesma coisa duas vezes:

nome = "Ana Beatriz"
if (tamanho := len(nome)) > 5:
    print(f"Nome comprido: {tamanho} letras")

$ python3 ro_morsa.py
Nome comprido: 11 letras

O len(nome) foi calculado uma vez, guardado em tamanho, comparado com 5 e usado de novo no print. Os parênteses em volta são necessários: sem eles, o :=, que é o operador mais fraco de todos, pegaria len(nome) > 5 inteiro, e tamanho valeria True.

$ python3 ro_morsa_erro.py
  File "/home/ana/ro_morsa_erro.py", line 1
    n := 10
      ^^
SyntaxError: invalid syntax

O @: multiplicação de matrizes

O @ existe na linguagem desde o Python 3.5, mas nenhum tipo que vem com o Python o usa. Ele foi criado para as bibliotecas de cálculo, como a NumPy, em que a @ b multiplica duas matrizes (tabelas de números). Com números comuns, dá erro:

print(2 @ 3)

$ python3 ro_matmul.py
Traceback (most recent call last):
  File "/home/ana/ro_matmul.py", line 1, in <module>
    print(2 @ 3)
          ~~^~~
TypeError: unsupported operand type(s) for @: 'int' and 'int'

"Tipos não suportados para @: int e int". Um tipo passa a aceitar o @ quando define o método especial __matmul__ (aula Métodos Especiais). Um exemplo pequeno, só para ver funcionando:

class Matriz:
    def __init__(self, linhas):
        self.linhas = linhas
    def __matmul__(self, outra):
        a, b = self.linhas, outra.linhas
        return Matriz([[sum(a[i][k] * b[k][j] for k in range(len(b)))
                        for j in range(len(b[0]))] for i in range(len(a))])
m = Matriz([[1, 2], [3, 4]])
id2 = Matriz([[1, 0], [0, 1]])
print((m @ id2).linhas)
print((m @ m).linhas)

$ python3 ro_matriz.py
[[1, 2], [3, 4]]
[[7, 10], [15, 22]]

Não se preocupe em entender a classe agora. Na prática, você só vai escrever @ se um dia trabalhar com matrizes numa biblioteca.

Outros que aparecem na tabela de precedência

Precedência: quem é feito primeiro

Quando uma expressão tem vários operadores, o Python faz primeiro os mais fortes. A tabela abaixo é a da documentação oficial (docs.python.org, seção 6.17), do mais forte (feito primeiro) para o mais fraco (feito por último). Operadores da mesma linha têm a mesma força e são feitos da esquerda para a direita, menos a potência ** e o if/else, que vão da direita para a esquerda. A explicação com calma está na aula Precedência dos Operadores.

Detalhes da tabela oficial: a potência perde para um sinal à direita dela, por isso 2 ** -1 funciona e dá 0.5; e o % com textos (formatação) tem a mesma força do % de resto.

As armadilhas de precedência

Experimente

nota1 = 8
nota2 = 6
media = nota1 + nota2 / 2
print("Média:", media)

nota1 = 8
nota2 = 6
media = (nota1 + nota2) / 2
print("Média:", media)

total = 0
while (texto := input("Preço (vazio para parar): ")) != "":
    total += float(texto)
print(f"Total: R$ {total:.2f}")

No terminal da Ana, o mesmo programa (caixa.py), digitando 0.50, 4.75 e depois só Enter:

$ python3 caixa.py
Preço (vazio para parar): 0.50
Preço (vazio para parar): 4.75
Preço (vazio para parar):
Total: R$ 5.25

Resumo

• Aritméticos: + - * / // % **. / sempre dá float; // arredonda para baixo; ** é potência (não ^).
• Comparação: == != < <= > >=, que podem ser encadeadas (1 < x < 5).
• Lógicos: and, or, not; and/or devolvem um dos valores (nome or "anônimo").
• is pergunta se é o mesmo objeto (use com None); in pergunta se está dentro (no dicionário, só nas chaves).
• Bit a bit: & | ^ ~ << >>; com conjuntos, | & - ^ são união, interseção e diferenças.
• Atribuição: = e as formas +=, -=…; o morsa := guarda e devolve um valor dentro de uma expressão.
• @ é para matrizes em bibliotecas; nos tipos do Python dá TypeError.
• Precedência: parênteses, **, sinal, * / // %, + -, bits, comparações, not, and, or, if/else, lambda, :=. Na dúvida, parênteses.