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

URL: https://skillaria.top/pt/guides/python/operadores-python-arredondamento

O operador / em Python sempre devolve float, // — a parte inteira com arredondamento para baixo, % — o resto, ** — a potência. A função round(x, n) arredonda para n casas decimais pelo critério do banqueiro: round(2.5) dá 2, e round(3.5) dá 4; para arredondar para cima e para baixo até o inteiro usam-se math.ceil e math.floor, e o valor absoluto de um número é dado por abs.

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.

| Grupo | Operadores | Exemplo |
| --- | --- | --- |

| Aritméticos | `+ - * / // % **` | `7 // 2` → 3 |

| Comparação | `== != < > <= >=` | `3 < 5` → True |

| Lógicos | `and or not` | `not True` → False |

| Identidade | `is`, `is not` | `x is None` |

| Pertinência | `in`, `not in` | `"café" in "café com leite"` → True |

| Atribuição | `= += -= *= /= //= %= **=` | `total += 250` |

| Morsa | `:=` | `if (n := len(s)) > 10:` |

| Bit a bit | `& | ^ ~ << >>` | `5 & 3` → 1 |

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

| a | b | a and b | a or b | not a |
| --- | --- | --- | --- | --- |

| True | True | True | True | False |

| True | False | False | True | False |

| False | True | False | True | True |

| False | False | False | False | True |

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.

| Função | O que faz | 2.5 | -2.5 | 2.7 |
| --- | --- | --- | --- | --- |

| `round(x)` | ao mais próximo, metade — para o par | 2 | -2 | 3 |

| `math.floor(x)` | para baixo, em direção ao menos infinito | 2 | -3 | 2 |

| `math.ceil(x)` | para cima, em direção ao mais infinito | 3 | -2 | 3 |

| `math.trunc(x)`, `int(x)` | descartar a fração, em direção a zero | 2 | -2 | 2 |

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

| Erro | O que acontece | Como certo |
| --- | --- | --- |

| `if x = 5:` | SyntaxError: isto é atribuição | `if x == 5:` |

| `2 ^ 3` no lugar da potência | XOR bit a bit, resultado 1 | `2 ** 3` |

| esperar inteiro de `8 / 2` | obtém `4.0` | `8 // 2` |

| `x == 1 or 2` | sempre verdadeiro: `or 2` | `x in (1, 2)` |

| esperar 3 de `round(2.5)` | o arredondamento do banqueiro dá 2 | `Decimal` com `ROUND_HALF_UP` |

| `"5" + 5` | TypeError | `int("5") + 5` |

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

## FAQ

**Como arredondar um número em Python para duas casas decimais?**

Use round(x, 2); se a intenção for apenas exibir o número de forma bonita, use a f-string f"{x:.2f}", que não altera o valor em si.

**Por que round(0.5) em Python devolve 0?**

Porque o round arredonda a metade para o número par mais próximo, e 0 é par; da mesma forma round(1.5) e round(2.5) dão 2.

**Como obter a parte inteira de uma divisão em Python?**

Com o operador //: 17 // 5 devolve 3. Com números negativos ele arredonda para baixo, por isso -17 // 5 dá -4; para descartar a fração em direção a zero, use int(-17 / 5).

**Existe operador ternário em Python?**

Sim, é a expressão condicional: valor_se_verdadeiro if condição else valor_se_falso, por exemplo "par" if n % 2 == 0 else "ímpar".

**Qual é a diferença entre & e and em Python?**

and é um operador lógico com avaliação preguiçosa, enquanto & é o E bit a bit para números e a interseção para conjuntos; em condições if use and.


---
Source: Skillaria.Top (https://skillaria.top)