Operadores aritméticos e ordem de precedência

1. Introdução aos Operadores Aritméticos em Python

Operadores aritméticos são símbolos especiais que realizam operações matemáticas em valores numéricos. Em Python, eles são fundamentais para qualquer cálculo, desde operações simples até expressões complexas.

Python oferece sete operadores aritméticos principais:

  • + (adição)
  • - (subtração)
  • * (multiplicação)
  • / (divisão real)
  • // (divisão inteira)
  • % (módulo/resto)
  • ** (exponenciação)

É importante distinguir entre operadores binários (que atuam sobre dois operandos, como 5 + 3) e unários (que atuam sobre um único operando, como -x). Os operadores + e - podem funcionar de ambas as formas.

2. Operadores Básicos: Adição, Subtração e Multiplicação

Adição (+)

O operador + soma dois números e também pode concatenar strings:

# Adição numérica
print(10 + 5)      # 15
print(3.14 + 2.86) # 6.0

# Concatenação de strings (apenas entre strings)
print("Olá, " + "mundo!")  # "Olá, mundo!"

Atenção: Python não permite somar números com strings diretamente — isso gera TypeError.

Subtração (-)

Além da subtração binária, o - pode ser usado como operador unário de negação:

# Subtração
print(20 - 8)   # 12

# Operador unário de negação
x = 10
print(-x)       # -10
print(-(-5))    # 5 (dupla negação)

Multiplicação (*)

Multiplica números e também repete sequências:

# Multiplicação numérica
print(7 * 6)    # 42
print(2.5 * 4)  # 10.0

# Repetição de strings e listas
print("Ha" * 3)   # "HaHaHa"
print([1, 2] * 3) # [1, 2, 1, 2, 1, 2]

3. Divisão: Comportamentos Distintos

Python oferece dois operadores de divisão com comportamentos diferentes.

Divisão Real (/)

Sempre retorna um float, mesmo com operandos inteiros:

print(10 / 3)   # 3.3333333333333335
print(8 / 2)    # 4.0 (note o ponto decimal)
print(7 / 1)    # 7.0

Divisão Inteira (//)

Retorna o resultado truncado para o piso (floor division):

print(10 // 3)   # 3
print(20 // 6)   # 3
print(-10 // 3)  # -4 (cuidado! vai para o menor inteiro)
print(10 // -3)  # -4

Armadilha comum: Com números negativos, // sempre arredonda para baixo (em direção a -∞), diferente do truncamento em direção a zero:

print(-10 // 3)   # -4 (não -3!)
print(int(-10/3)) # -3 (truncamento em direção a zero)

4. Operadores de Módulo e Exponenciação

Módulo (%)

Retorna o resto da divisão inteira:

# Paridade
print(10 % 2)  # 0 (par)
print(7 % 2)   # 1 (ímpar)

# Rotações circulares
dias_semana = 7
dia_atual = 3  # quarta-feira
dias_para_adicionar = 10
novo_dia = (dia_atual + dias_para_adicionar) % dias_semana
print(novo_dia)  # 6 (sábado)

# Com números negativos
print(-7 % 3)   # 2 (Python sempre retorna resultado com sinal do divisor)
print(7 % -3)   # -2

Exponenciação (**)

Calcula potências e raízes com expoentes fracionários:

# Potências
print(2 ** 3)      # 8
print(5 ** 2)      # 25
print(10 ** 0)     # 1

# Raiz quadrada (expoente 0.5)
print(16 ** 0.5)   # 4.0
print(9 ** 0.5)    # 3.0

# Raiz cúbica
print(27 ** (1/3)) # 3.0

5. Ordem de Precedência (Operator Precedence)

A ordem de precedência determina qual operador é avaliado primeiro em uma expressão. Em Python, a hierarquia completa dos operadores aritméticos é:

Precedência Operadores Descrição
1 (maior) ** Exponenciação
2 +x, -x Operadores unários
3 *, /, //, % Multiplicação, divisões e módulo
4 (menor) +, - Adição e subtração binárias

Regra importante: Operadores de mesma precedência são avaliados da esquerda para a direita, exceto **, que é avaliado da direita para a esquerda.

# Exemplos práticos
print(2 + 3 * 4)      # 14 (multiplicação primeiro)
print((2 + 3) * 4)    # 20 (parênteses alteram)

# Exponenciação é associativa à direita
print(2 ** 3 ** 2)    # 512 (equivale a 2 ** (3 ** 2))
print((2 ** 3) ** 2)  # 64

# Expressão ambígua resolvida pela precedência
print(10 - 4 + 2)     # 8 (esquerda para direita: (10-4)+2)
print(10 - (4 + 2))   # 4 (parênteses alteram)

6. Uso de Parênteses para Sobrescrever a Precedência

Parênteses são a ferramenta mais segura para controlar explicitamente a ordem de avaliação:

# Fórmula de Bhaskara
a, b, c = 1, -5, 6
delta = b**2 - 4*a*c
x1 = (-b + delta**0.5) / (2*a)
x2 = (-b - delta**0.5) / (2*a)
print(x1, x2)  # 3.0 2.0

# Cálculo financeiro: juros compostos
capital = 1000
taxa = 0.05
periodos = 12
montante = capital * (1 + taxa) ** periodos
print(f"Montante: R$ {montante:.2f}")  # R$ 1795.86

# Expressão complexa com múltiplos parênteses
resultado = ((3 + 5) * (10 - 2)) / (4 ** 2)
print(resultado)  # 2.0

Boas práticas: Use parênteses mesmo quando não forem estritamente necessários, se eles tornarem o código mais legível:

# Ruim (difícil de ler rapidamente)
media = a + b + c / 3

# Bom (claro e explícito)
media = (a + b + c) / 3

7. Operadores de Atribuição Combinada (Augmented Assignment)

Estes operadores combinam uma operação aritmética com atribuição:

x = 10
x += 5      # x = x + 5 → 15
x -= 3      # x = x - 3 → 12
x *= 2      # x = x * 2 → 24
x /= 4      # x = x / 4 → 6.0
x //= 2     # x = x // 2 → 3.0
x %= 2      # x = x % 2 → 1.0
x **= 3     # x = x ** 3 → 1.0

# Exemplo prático em loop
total = 0
for i in range(1, 6):
    total += i  # acumulador
print(total)  # 15

# Cuidado com tipos mutáveis
lista = [1, 2]
lista *= 3
print(lista)  # [1, 2, 1, 2, 1, 2]

Atenção com imutáveis: Strings e tuplas também suportam += e *=, mas criam novos objetos:

s = "Python"
s += " é legal"  # Cria nova string
print(s)  # "Python é legal"

8. Resumo e Boas Práticas

Tabela de precedência resumida (do maior para o menor):
1. ** (exponenciação)
2. +x, -x (unários)
3. *, /, //, % (multiplicação, divisão, módulo)
4. +, - (binários)

Dicas para evitar erros comuns:

  • Divisão por zero: Sempre verifique antes de dividir
if divisor != 0:
    resultado = dividendo / divisor
  • Precisão de float: Use round() ou Decimal para cálculos financeiros
print(0.1 + 0.2)           # 0.30000000000000004
print(round(0.1 + 0.2, 1)) # 0.3
  • Exercício mental: Avalie a expressão abaixo passo a passo:
resultado = 2 ** 3 ** 2 + 10 // 3 * 2 - 4
# Passo 1: 3 ** 2 → 9 (exponenciação direita→esquerda)
# Passo 2: 2 ** 9 → 512
# Passo 3: 10 // 3 → 3 (divisão inteira)
# Passo 4: 3 * 2 → 6 (multiplicação)
# Passo 5: 512 + 6 → 518 (adição)
# Passo 6: 518 - 4 → 514 (subtração)
print(resultado)  # 514

Recomendação final: Em expressões não triviais, sempre use parênteses para tornar explícita sua intenção. Código claro é melhor que código "inteligente".

Referências