Operadores em Python: aritmética, // e %, comparação, and/or/not e round em Python

Operadores em Python são sinais que transformam valores em novos valores: + soma, // faz divisão inteira, and combina condições. A seguir, a lista completa de operadores com exemplos, a diferença entre / e //, a lógica de and, or e not, além das funções de arredondamento: python round, math.ceil, math.floor e abs. Todos os exemplos podem ser colados no REPL para conferir.

Lista de operadores do Python

Os operadores se dividem em grupos conforme a finalidade. Não é preciso decorar a tabela inteira: no código real aparecem com mais frequência a aritmética, a comparação e as conectivas lógicas.

Operadores aritméticos

Soma, subtração e multiplicação funcionam como na escola. Se na expressão participa pelo menos um float, o resultado também será float: 2 + 1.0 dá 3.0. Inteiros em Python não estouram — 2 ** 100 é calculado com exatidão, qualquer que seja o número de dígitos.

>>> 250 + 120
370
>>> 12.5 * 3
37.5
>>> 2 ** 10
1024
>>> 2 ** 0.5
1.4142135623730951

Potência em Python: o operador **

A potenciação é feita com dois asteriscos, e não com ^: em Python o sinal ^ significa o "OU exclusivo" bit a bit, e 2 ^ 3 devolve 1, não 8. Expoente fracionário dá raiz: 9 ** 0.5 é 3.0. Existe também a função pow(x, y) — o mesmo resultado, além de um terceiro argumento para o resto: pow(2, 10, 1000) devolve 24.

Atenção à prioridade: ** é executado antes do menos unário, por isso -2 ** 2 é -4. Para o quadrado de um número negativo, use parênteses: (-2) ** 2.

Divisão em Python: /, // e %

Em Python há dois tipos de divisão, e essa é a principal fonte de surpresas para iniciantes. A divisão comum / sempre devolve float, mesmo quando a divisão é exata. A divisão inteira // descarta a parte fracionária, e % devolve o resto.

>>> 7 / 2
3.5
>>> 8 / 2
4.0
>>> 7 // 2
3
>>> 7 % 2
1

Divisão inteira // e resto %: na prática

O par // e % resolve problemas do tipo "quantos inteiros cabem e quanto sobra". No curso, o rastreador de despesas guarda o dinheiro em centavos, para não perder precisão, e separa o valor em reais e centavos:

cents = 125050            # guardamos o dinheiro em centavos
brl = cents // 100        # 1250 — reais inteiros
cent = cents % 100        # 50 — resto
print(brl, cent)          # 1250 50

print(40 // 7, "semanas e", 40 % 7, "dias")   # 5 semanas e 5 dias

As duas operações juntas são devolvidas pela função embutida divmod: divmod(125050, 100) dá a tupla (1250, 50). O resto também serve para checar paridade: n % 2 == 0 é verdadeiro para números pares.

Números negativos: // arredonda para baixo

O operador // não apenas descarta a fração: ele arredonda para baixo, em direção ao menos infinito. Para números positivos não há diferença, para negativos há. O sinal do resto % em Python coincide com o sinal do divisor, por isso vale sempre a igualdade a == (a // b) * b + a % b.

>>> -7 // 2
-4
>>> -7 % 2
1
>>> int(-7 / 2)     # descarta a fração, sem arredondar para baixo
-3

Divisão por zero: qual erro aparece

Dividir por zero com qualquer um dos três operadores gera a exceção ZeroDivisionError. Isso vale tanto para inteiros quanto para decimais. Pode-se capturá-la com try/except ou verificar o divisor antecipadamente.

>>> 10 / 0
Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero
>>> count = 0
>>> avg = 1500 / count if count else 0
>>> avg
0

Operadores de comparação

As comparações devolvem True ou False. A igualdade é verificada com dois sinais ==; um único = é atribuição. Strings são comparadas caractere a caractere pelos códigos dos símbolos, por isso "B" < "a" é verdadeiro: letras maiúsculas vêm antes das minúsculas.

>>> 250 == 250.0
True
>>> 3 != 4
True
>>> 1 < 5 <= 10     # encadeamento: 1 < 5 and 5 <= 10
True
>>> 0.1 + 0.2 == 0.3
False

Encadeamentos como 0 <= x < 100 são um recurso cômodo do Python: não é preciso escrever and. A última linha lembra o erro de precisão dos decimais: 0.1 + 0.2 dá 0.30000000000000004. Compare números decimais com math.isclose(a, b), e guarde dinheiro em centavos ou em Decimal.

Operadores lógicos and, or, not

Os operadores lógicos em Python são escritos como palavras, e não com os símbolos && e ||, como em outras linguagens. and é verdadeiro quando ambas as partes são verdadeiras, or — quando pelo menos uma é verdadeira, e not inverte o valor.

Prioridade: primeiro not, depois and, depois or. A expressão True or False and False é True, porque o and é avaliado antes. Em condições complexas use parênteses — assim fica mais claro para você e para os colegas.

O que realmente devolvem and e or

and e or não devolvem necessariamente True ou False, mas um dos operandos. or entrega o primeiro valor verdadeiro (ou o último, se nenhum for verdadeiro), e and — o primeiro falso (ou o último). São considerados falsos 0, 0.0, a string vazia, coleções vazias, None e False.

>>> name = ""
>>> name or "Visitante"
'Visitante'
>>> 5 and 0
0
>>> not ""
True

A avaliação é preguiçosa: se o resultado já está claro pela parte esquerda, a direita não é calculada. Por isso count and total / count não falha com divisão por zero quando count == 0. O operador not, diferentemente dos outros dois, sempre devolve bool.

Operadores is e in

== compara valores, enquanto is verifica se dois nomes apontam para o mesmo objeto. Duas cestas vazias diferentes são iguais, mas não são o mesmo objeto. O único lugar onde o is é usado o tempo todo é a verificação de None: if x is None.

>>> a = [250, 120]
>>> b = [250, 120]
>>> a == b, a is b
(True, False)
>>> c = a
>>> c is a
True

Não compare números e strings com is: às vezes isso "funciona" por causa do cache interno de objetos, mas o resultado depende da implementação, e o Python emite SyntaxWarning para construções como x is 5.

O operador in verifica pertinência: substring em uma string, elemento em uma lista, chave em um dicionário. not in faz a verificação inversa.

>>> "café" in "café com leite"
True
>>> "alimentação" in {"alimentação": 450, "táxi": 300}
True
>>> 5 not in [1, 2, 3]
True

Operadores de atribuição e o operador morsa :=

Os operadores compostos +=, -=, *=, //= e outros são abreviações: total += 250 significa total = total + 250. Em Python não existem ++ e --: x++ provoca erro de sintaxe.

O operador morsa := (o nome vem da semelhança com os olhos e as presas de uma morsa) faz uma atribuição diretamente dentro de uma expressão. É útil quando o valor precisa ser verificado e usado depois:

items = ["café", "táxi", "almoço", "cinema"]
if (n := len(items)) > 3:
    print(f"Gastos demais: {n}")

while (line := input("Valor: ")) != "":
    print(int(line) * 2)

Sem o morsa, seria preciso chamar len duas vezes ou colocar a atribuição em uma linha separada. Abusar dele não vale a pena: se a linha ficou ilegível, uma atribuição comum é melhor.

Arredondamento em Python: round, ceil, floor

Para arredondar em Python existem a função embutida round e as funções do módulo math. Elas resolvem tarefas diferentes, e confundi-las é um erro comum.

A função round em Python e o arredondamento do banqueiro

A função round(x, n) arredonda para n casas após a vírgula; sem o segundo argumento devolve um int. A principal armadilha: o python round arredonda "pelo critério do banqueiro" — metade vai para o par mais próximo. Por isso round(2.5) dá 2, e round(3.5) dá 4. Assim, os erros de arredondamento não se acumulam em uma só direção em cálculos grandes.

>>> round(2.5), round(3.5)
(2, 4)
>>> round(3.14159, 2)
3.14
>>> round(1250, -2)     # até as centenas
1200
>>> round(2.675, 2)     # não 2.68: em binário isso é 2.67499...
2.67

Se você precisa do arredondamento escolar "metade para cima", por exemplo em um recibo, use Decimal com o modo ROUND_HALF_UP. Passe o número como string, para não herdar o erro do float:

>>> from decimal import Decimal, ROUND_HALF_UP
>>> Decimal("2.5").quantize(Decimal("1"), ROUND_HALF_UP)
Decimal('3')
>>> Decimal("2.675").quantize(Decimal("0.01"), ROUND_HALF_UP)
Decimal('2.68')

E mais uma regra do curso: arredonde apenas na hora de exibir. Para uma impressão bonita, round não é necessário — basta uma f-string: f"{amount:.2f}" mostra duas casas, e o próprio número continua exato.

math.ceil e math.floor: arredondamento para cima e para baixo

math.ceil é necessário quando "faltar" é inaceitável: quantos ônibus alugar, quantas páginas de resultados existem. math.floor serve quando só contam as unidades completas. Ambas as funções devolvem int.

import math

guests = 47
seats = 20
print(math.ceil(guests / seats))   # 3 ônibus
print(math.floor(9.99))            # 9
print(-(-guests // seats))         # 3 — ceil sem math, truque com //

No módulo math há outras funções úteis: math.sqrt (raiz), math.isclose (comparação de decimais), math.pi, math.gcd. No Python 3.15 surgiu o submódulo math.integer (PEP 791) para matemática inteira: nele estão comb, factorial, gcd, isqrt, lcm, perm, e as antigas math.gcd e outras continuam funcionando.

Função abs: valor absoluto de um número

abs(x) devolve o módulo — a distância até zero sem sinal. Não é preciso importar nada, a função é embutida. Funciona com inteiros, decimais e até complexos: para 3+4j devolve o comprimento do vetor, 5.0.

>>> abs(-250)
250
>>> abs(-12.5)
12.5
>>> budget, spent = 5000, 5320
>>> abs(budget - spent)    # em quanto saímos do previsto
320

O uso típico é a diferença sem levar em conta o sentido e a comparação com tolerância: abs(a - b) < 0.001. Para decimais é mais seguro usar math.isclose, pois ela leva em conta a escala dos números.

Prioridade dos operadores

Quando há vários operadores em uma expressão, o Python os executa por prioridade — da mais alta para a mais baixa:

1. **
2. unários -x, +x, ~x
3. * / // %
4. + -
5. deslocamentos e operações bit a bit
6. comparações, in, is
7. not
8. and
9. or
10. :=

Assim, 2 + 3 * 4 é 14, enquanto (2 + 3) * 4 é 20. Na dúvida, use parênteses: parênteses extras não custam nada, mas um erro de prioridade demora para ser encontrado.

Erros comuns com operadores

Resumo

Lembre o principal: / sempre dá float, // arredonda para baixo, % devolve o resto com o sinal do divisor, e a potência é **. Os lógicos and, or, not são escritos como palavras e avaliados de forma preguiçosa, e is serve para verificar None. A função python round arredonda para o par mais próximo; para arredondar para cima e para baixo existem math.ceil e math.floor, e o módulo de um número é dado por abs. No curso esses operadores são praticados no rastreador de despesas, onde o dinheiro é guardado em centavos.