Os operadores são fundamentais em qualquer linguagem de programação, pois permitem realizar operações sobre valores e variáveis. Em Python, eles são divididos em várias categorias, como aritméticos, de comparação, lógicos, de identidade e de associação. Compreender como cada um funciona e como eles interagem é essencial para escrever código expressivo e correto.

Nesta aula, vamos explorar cada tipo de operador com exemplos práticos, entender a precedência que define a ordem de avaliação em expressões complexas e discutir boas práticas para evitar erros comuns.

Aritméticos, comparação, lógicos

Os operadores aritméticos são usados para realizar operações matemáticas. Python oferece os tradicionais: + (adição), - (subtração), * (multiplicação), / (divisão flutuante), // (divisão inteira), % (módulo) e ** (exponenciação). Eles funcionam com números, mas também podem ser sobrecarregados para outros tipos, como strings com + e *.

Os operadores de comparação comparam dois valores e retornam um booleano (True ou False). São eles: == (igual), != (diferente), < (menor), > (maior), <= (menor ou igual) e >= (maior ou igual). Eles podem ser usados em estruturas condicionais e loops.

Os operadores lógicos combinam expressões booleanas: and (E lógico), or (OU lógico) e not (negação). Eles seguem as regras da lógica booleana, mas com um comportamento de curto-circuito: em a and b, se a for falso, b não é avaliado; em a or b, se a for verdadeiro, b não é avaliado.

# Aritméticos
soma = 10 + 5
subtracao = 10 - 5
multiplicacao = 10 * 5
divisao = 10 / 3
divisao_inteira = 10 // 3
modulo = 10 % 3
potencia = 2 ** 3

print(soma, subtracao, multiplicacao)  # 15 5 50
print(divisao, divisao_inteira, modulo, potencia)  # 3.3333333333333335 3 1 8

# Comparação
print(10 == 10)  # True
print(10 != 5)   # True
print(10 < 5)    # False
print(10 >= 10)  # True

# Lógicos
idade = 25
renda = 3000
print(idade >= 18 and renda > 2000)  # True
print(idade < 18 or renda > 5000)    # False
print(not idade < 18)                # True

Operadores de identidade (is)

Os operadores de identidade is e is not verificam se duas variáveis referenciam o mesmo objeto na memória. Isso é diferente do operador ==, que compara se os valores são iguais. Para números pequenos e strings curtas, o Python pode reutilizar objetos (internamento), mas para objetos mutáveis como listas, cada criação gera um novo objeto.

O uso de is é comum para comparar com None, pois existe apenas um objeto None no programa. É uma boa prática usar is None em vez de == None.

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)  # True (valores iguais)
print(a is b)  # False (objetos diferentes)
print(a is c)  # True (mesmo objeto)

x = None
print(x is None)  # True
print(x is not None)  # False

Operadores de associação (in)

Os operadores de associação in e not in verificam se um valor está presente em uma sequência (como strings, listas, tuplas) ou em um conjunto/dicionário (nas chaves). Eles retornam um booleano.

Para strings, in verifica substrings. Para listas e tuplas, verifica se o elemento está presente. Para dicionários, verifica se a chave existe. Esses operadores são muito úteis em condições e loops.

frutas = ['maçã', 'banana', 'laranja']
print('banana' in frutas)  # True
print('uva' not in frutas) # True

nome = 'Python'
print('Py' in nome)  # True
print('xyz' in nome) # False

pessoa = {'nome': 'Ana', 'idade': 30}
print('nome' in pessoa)  # True
print('email' in pessoa) # False

Precedência

A precedência de operadores define a ordem em que as expressões são avaliadas. Em Python, a precedência segue uma hierarquia: primeiro os parênteses, depois exponenciação, multiplicação/divisão/módulo, adição/subtração, comparações, operadores lógicos (not, and, or) e por último atribuições. Quando há empate, a associatividade é da esquerda para a direita (exceto para exponenciação, que é da direita para a esquerda).

É recomendado usar parênteses para tornar a intenção explícita, mesmo que você conheça a precedência, pois melhora a legibilidade e evita erros sutis. Vamos ver um exemplo com várias operações.

# Sem parênteses
resultado = 2 + 3 * 4 ** 2 - 1
print(resultado)  # 49 (2 + 3*16 - 1 = 2 + 48 - 1)

# Com parênteses para clareza
resultado2 = (2 + 3) * (4 ** 2) - 1
print(resultado2)  # 79 (5*16 - 1)

# Precedência lógica
x = True or False and False
print(x)  # True (and tem precedência sobre or)

# Associatividade da exponenciação
print(2 ** 3 ** 2)  # 512 (2 ** (3**2) = 2**9)

Boas Práticas e Observações Finais

Ao usar operadores, prefira sempre parênteses em expressões complexas para evitar ambiguidades. Use is para comparar com None e == para comparar valores. Lembre-se de que in pode ser usado em strings, listas e dicionários, mas para dicionários verifica chaves, não valores.

Evite encadear muitas comparações sem parênteses. Em Python, é possível comparar em cadeia, como 1 < x < 10, o que é equivalente a 1 < x and x < 10. Isso é uma feature elegante.

# Comparação encadeada
x = 5
print(1 < x < 10)  # True

Referências

Exercícios

  1. Qual é o resultado de 7 // 2 e 7 % 2? Explique a diferença entre divisão inteira e módulo.

    2. ✓ Resposta: 7 // 2 é 3, pois a divisão inteira retorna o quociente sem a parte fracionária. 7 % 2 é 1, pois o módulo retorna o resto da divisão. Em Python, 7 // 2 é 3 e 7 % 2 é 1.
  2. Considere as variáveis a = [1, 2] e b = [1, 2]. O que retorna a is b? E a == b? Por quê?

    3. ✓ Resposta: a is b é False, pois são listas diferentes criadas separadamente, mesmo com valores iguais. a == b é True, pois o operador == compara os valores dos elementos, não a identidade do objeto.
  3. Escreva uma expressão que verifique se a string "casa" contém a letra "s" e não contém a letra "z". Use operadores de associação e lógicos.

    4. ✓ Resposta: 
    palavra = "casa"
resultado = ('s' in palavra) and ('z' not in palavra)
print(resultado)  # True
  4. Qual é a ordem de avaliação da expressão 2 + 3 * 4 ** 2? Mostre os passos.

    5. ✓ Resposta: Primeiro é avaliada a exponenciação: 4 ** 2 = 16. Depois a multiplicação: 3 * 16 = 48. Por fim, a adição: 2 + 48 = 50. O resultado é 50.
  5. Escreva um código que verifique se uma variável x é None e também se a lista [1, 2, 3] contém o número 2. Use operadores de identidade e associação.

    6. ✓ Resposta: 
    x = None
lista = [1, 2, 3]
if x is None and 2 in lista:
    print("x é None e 2 está na lista")
else:
    print("Condição não atendida")