Introdução aos Operadores Python

Operadores são os símbolos e palavras-chave que dizem ao Python qual ação executar em um ou mais valores. Toda expressão Python significativa — de x + 1 a if age >= 18 — depende de pelo menos um operador. Python agrupa seus operadores em sete categorias: aritméticos, de comparação, de atribuição, lógicos, de identidade, de pertencimento e bit a bit. Este capítulo explica cada categoria, mostra quando usá-la e destaca armadilhas comuns.

Operadores Aritméticos

Operadores aritméticos realizam cálculos matemáticos. Python disponibiliza sete deles:

Dois operadores merecem atenção especial:

• / sempre retorna um float no Python 3, mesmo ao dividir dois inteiros (4 / 2 retorna 2.0, não 2).
• // (divisão inteira) arredonda o resultado em direção ao infinito negativo, não em direção ao zero. Portanto, -7 // 2 é -4, não -3.

Uso comum: verificar par ou ímpar

O operador módulo (%) é a maneira padrão de testar divisibilidade:

number = 42
if number % 2 == 0:
    print("even")
else:
    print("odd")
# Output: even

Operadores de Comparação

Operadores de comparação comparam dois valores e sempre retornam True ou False. Eles são usados em condições, laços while e em qualquer lugar onde um resultado booleano seja necessário.

Encadeamento de comparações

Python permite encadear múltiplas comparações em uma única expressão, o que é lido de forma mais natural do que na maioria das outras linguagens:

x = 7
print(1 < x < 10)   # True  — equivalent to (1 < x) and (x < 10)
print(0 < x < 5)    # False

Armadilha: == vs =

= é o operador de atribuição; == testa igualdade. Usar = dentro de uma condição é um SyntaxError em Python (ao contrário de algumas outras linguagens onde a atribuição ocorre silenciosamente).

Operadores de Atribuição

Operadores de atribuição armazenam valores em variáveis. As formas compostas (+=, -=, …) combinam uma operação aritmética ou bit a bit com a atribuição, tornando o código mais conciso.

O operador walrus := (Python 3.8+)

O operador walrus atribui um valor dentro de uma expressão. É útil quando você quer avaliar e armazenar um resultado sem escrever a expressão duas vezes:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Without walrus: compute length twice
if len(numbers) > 5:
    print(f"Long list: {len(numbers)} items")

# With walrus: assign once, use in condition and body
if (n := len(numbers)) > 5:
    print(f"Long list: {n} items")
# Output: Long list: 10 items

Operadores Lógicos

Operadores lógicos combinam ou invertem expressões booleanas. Python usa palavras-chave em inglês em vez de símbolos (&&, ||, !).

Avaliação de curto-circuito

Python avalia and e or de forma lazy (da esquerda para a direita) e para assim que o resultado é determinado:

• False and <anything> — o lado direito nunca é avaliado.
• True or <anything> — o lado direito nunca é avaliado.

Isso importa quando o lado direito tem um efeito colateral ou pode gerar um erro:

user_input = ""
name = user_input or "Anonymous"
print(name)   # Anonymous  (empty string is falsy, so "Anonymous" is returned)

Valores truthy e falsy

Operadores lógicos funcionam com qualquer valor, não apenas True/False. Python trata 0, "", None, [], {} e () como falsy; todo o resto é truthy.

Consulte o capítulo Python Data Types para uma lista completa de valores falsy por tipo.

Operadores de Identidade

Operadores de identidade testam se duas variáveis apontam para o mesmo objeto na memória, não apenas se contêm valores iguais.

Quando usar is vs ==

Use is apenas quando você intencionalmente quer verificar a identidade do objeto — mais comumente ao comparar com singletons:

value = None
if value is None:       # correct idiom
    print("No value provided")

# Never do: if value == None — works but is considered bad style

Python armazena em cache inteiros pequenos (tipicamente de -5 a 256) e strings internadas, portanto a is b pode retornar True para dois inteiros pequenos criados separadamente. Nunca confie nesse comportamento para inteiros ou strings — use == para igualdade de valores.

Operadores de Pertencimento

Operadores de pertencimento testam se um valor existe dentro de uma sequência (lista, tupla, string, conjunto ou dicionário).

Nota sobre desempenho

Para listas e tuplas, in verifica cada elemento sequencialmente (O(n)). Para conjuntos e chaves de dicionário, in usa uma tabela hash e executa em tempo constante (O(1)). Prefira um set quando precisar realizar muitos testes de pertencimento em uma coleção grande.

Operadores Bit a Bit

Operadores bit a bit trabalham sobre a representação binária dos inteiros, manipulando bits individuais.

Por que os operadores bit a bit importam

Na maioria do código Python cotidiano, você não usará operadores bit a bit diretamente, mas eles aparecem com frequência em:

• Flags e permissões — combinando bitmasks para representar múltiplas opções em um único inteiro.
• Criptografia e hashing — XOR é um bloco de construção básico.
• Matemática eficiente — n << 1 é mais rápido que n * 2 em laços de alto desempenho.
• Trabalho com protocolos binários — análise de pacotes de rede ou cabeçalhos de arquivo.

Precedência de Operadores

Quando uma expressão mistura vários operadores, Python os avalia em uma ordem fixa (maior precedência primeiro):

# Multiplication before addition (standard math rules apply)
print(2 + 3 * 4)      # 14, not 20

# Use parentheses to override
print((2 + 3) * 4)    # 20

# ** is right-associative: 2 ** 3 ** 2 = 2 ** (3**2) = 2**9
print(2 ** 3 ** 2)    # 512, not 64

# Comparisons before logical operators
print(2 + 3 > 4 and 10 % 3 == 1)  # True and True → True

Em caso de dúvida, use parênteses. Eles tornam a precedência explícita e melhoram a legibilidade.

Resumo

Para tópicos relacionados, consulte Python Variables, Python If...Else e Python Data Types.

Prática