Operadores e Expressões Já leu

Se variáveis são os recipientes que guardam dados, os operadores são as ferramentas que permitem trabalhar com esses dados. Python oferece um conjunto rico e expressivo de operadores — alguns familiares para quem já programou em outra linguagem, outros exclusivos do Python.

Operadores Aritméticos

Os mais básicos — realizam cálculos matemáticos:

a = 10
b = 3

print(a + b)   # 13  — adição
print(a - b)   # 7   — subtração
print(a * b)   # 30  — multiplicação
print(a / b)   # 3.3333...  — divisão real (sempre retorna float)
print(a // b)  # 3   — divisão inteira (descarta o decimal)
print(a % b)   # 1   — módulo (resto da divisão)
print(a ** b)  # 1000 — potenciação

A divisão com / sempre retorna float em Python 3 — isso foi uma das correções feitas em relação ao Python 2, onde 10 / 3 retornava 3.

O operador ** é especialmente útil:

raiz_quadrada = 25 ** 0.5
print(raiz_quadrada)  # 5.0

cubo = 4 ** 3
print(cubo)  # 64

Operadores de Comparação

Retornam sempre True ou False:

x = 10
y = 20

print(x == y)   # False — igual a
print(x != y)   # True  — diferente de
print(x < y)    # True  — menor que
print(x > y)    # False — maior que
print(x <= 10)  # True  — menor ou igual
print(x >= 10)  # True  — maior ou igual

Atenção ao erro clássico de confundir = (atribuição) com == (comparação):

x = 5       # atribui o valor 5 a x
x == 5      # compara x com 5, retorna True

Operadores Lógicos

Combinam expressões booleanas:

idade = 25
tem_carteira = True

# and — verdadeiro se ambos forem verdadeiros
pode_dirigir = idade >= 18 and tem_carteira
print(pode_dirigir)  # True

# or — verdadeiro se pelo menos um for verdadeiro
tem_acesso = idade >= 18 or tem_carteira
print(tem_acesso)  # True

# not — inverte o valor
nao_pode = not pode_dirigir
print(nao_pode)  # False

Python avalia expressões com curto-circuito: em um and, se o primeiro operando for False, o segundo nem é avaliado. Em um or, se o primeiro for True, o segundo é ignorado. Isso é importante para evitar erros:

lista = []

# sem curto-circuito, lista[0] causaria IndexError
if lista and lista[0] == "Python":
    print("Encontrado")

Operadores de Atribuição

Além do = básico, Python oferece formas compactas de atualizar variáveis:

x = 10

x += 5   # equivale a x = x + 5  → 15
x -= 3   # equivale a x = x - 3  → 12
x *= 2   # equivale a x = x * 2  → 24
x /= 4   # equivale a x = x / 4  → 6.0
x //= 2  # equivale a x = x // 2 → 3.0
x **= 3  # equivale a x = x ** 3 → 27.0
x %= 5   # equivale a x = x % 5  → 2.0

Operadores de Identidade e Pertinência

Dois operadores que não existem em muitas linguagens, mas são muito usados em Python:

is e is not — verificam se dois nomes apontam para o mesmo objeto na memória:

a = [1, 2, 3]
b = a          # b aponta para o mesmo objeto
c = [1, 2, 3]  # c é um objeto diferente, mas com o mesmo conteúdo

print(a is b)   # True
print(a is c)   # False
print(a == c)   # True — conteúdo igual, objetos diferentes

in e not in — verificam se um valor está contido em uma sequência:

frutas = ["maçã", "banana", "laranja"]

print("banana" in frutas)      # True
print("uva" in frutas)         # False
print("uva" not in frutas)     # True

frase = "Python é incrível"
print("Python" in frase)       # True

Precedência de Operadores

Quando há múltiplos operadores em uma expressão, Python segue uma ordem de precedência. Da mais alta para a mais baixa:

1. **              (potenciação)
2. +x, -x         (sinais unários)
3. *, /, //, %    (multiplicação, divisão)
4. +, -           (adição, subtração)
5. ==, !=, <, >   (comparação)
6. not            (negação lógica)
7. and            (e lógico)
8. or             (ou lógico)

Exemplos:

print(2 + 3 * 4)      # 14, não 20 — multiplicação primeiro
print((2 + 3) * 4)    # 20 — parênteses forçam a ordem
print(2 ** 3 ** 2)    # 512 — potenciação associa da direita: 2 ** (3**2) = 2**9

A recomendação é sempre usar parênteses quando a expressão tiver risco de ambiguidade — o código fica mais legível e você evita surpresas.

Expressões com Strings

Strings também aceitam alguns operadores:

# Concatenação
primeiro = "Python"
segundo = " é incrível"
print(primeiro + segundo)  # Python é incrível

# Repetição
linha = "-" * 40
print(linha)  # ----------------------------------------

# Comparação (ordem lexicográfica)
print("apple" < "banana")  # True
print("Z" < "a")           # True — maiúsculas têm valor menor

Resumo

• Operadores aritméticos incluem // para divisão inteira e ** para potência
• Operadores de comparação sempre retornam bool
• and, or e not combinam expressões lógicas com curto-circuito
• +=, -= e similares são formas compactas de atualização
• is compara identidade de objetos; == compara conteúdo
• in verifica pertinência em sequências
• Use parênteses para controlar e deixar clara a precedência

Referências e Leituras Complementares

• Operadores do Python — https://docs.python.org/3/reference/expressions.html#operator-precedence
• Operadores de identidade e pertinência — https://docs.python.org/3/library/stdtypes.html#comparisons
• PEP 8 sobre expressões — https://peps.python.org/pep-0008/#programming-recommendations
• MATTHES, Eric. Python Crash Course. 3. ed. No Starch Press, 2023. Cap. 2–3.
• LUTZ, Mark. Learning Python. 5. ed. O'Reilly Media, 2013. Cap. 5.
• RAMALHO, Luciano. Fluent Python. 2. ed. O'Reilly Media, 2022. Cap. 1.