Potência e a ordem das operações

Potência com dois asteriscos

Elevar um número a uma potência é multiplicá-lo por ele mesmo repetidas vezes, e o Python tem um operador dedicado para isso: os dois asteriscos. A expressão 5 ** 2 lê-se cinco elevado a dois e vale 25. Funciona com qualquer expoente, inclusive decimal: 2 ** 0.5 calcula a raiz quadrada de 2, porque raiz é potência de expoente meio.

print(5 ** 2)    # 25   (5 ao quadrado)
print(2 ** 3)    # 8    (2 ao cubo)
print(2 ** 10)   # 1024 (o famoso kilo da computação)
print(2 ** 0.5)  # 1.4142135623730951 (raiz quadrada de 2)

O operador ** aceita expoentes inteiros e decimais. O resultado com expoente decimal sai como float.

Onde potência aparece na prática? Em crescimento: juros compostos, população de bactérias, dobras de papel. Em áreas e volumes: lado ** 2 e lado ** 3. E na própria computação: 2 ** 10 é 1024, o motivo de um kilobyte não ser mil bytes redondos. Neste módulo ficamos nos juros simples, que usam só multiplicação, mas o ** já fica no seu cinto de ferramentas para os compostos, mais adiante na trilha.

Quem calcula primeiro: a tabela de precedência

Quanto vale 2 + 3 * 4? Se você respondeu 14, a escola fez efeito: a multiplicação resolve antes da soma, então a conta é 2 + 12. O Python segue exatamente essa convenção, conhecida no ensino como PEMDAS ou ordem das operações. A tabela abaixo mostra a prioridade dos operadores que você já conhece, do que calcula primeiro para o que calcula por último.

Duas linhas da tabela merecem lupa. Na linha 2, a expressão 2 * 3 ** 2 dá 18, e não 36, porque a potência resolve antes da multiplicação: primeiro 3 ** 2 vira 9, depois 2 * 9. E a linha 3 esconde a pegadinha mais famosa da precedência: como o ** tem prioridade sobre o sinal negativo, a expressão -2 ** 2 vale -4. O Python calcula 2 ** 2 primeiro e aplica o sinal depois.

print(2 + 3 * 4)    # 14, e não 20: o * resolve antes do +
print(2 * 3 ** 2)   # 18, e não 36: o ** resolve antes do *
print(-2 ** 2)      # -4: o ** resolve antes do sinal negativo
print((-2) ** 2)    # 4: os parênteses protegem o sinal

Quatro expressões que separam quem decorou a tabela de quem chuta. A última linha mostra a solução: parênteses.

Parênteses como ferramenta e o exemplo dos juros simples

Parênteses têm dois empregos. O primeiro é mudar a conta: (2 + 3) * 4 força a soma a acontecer antes. O segundo é mais sutil e igualmente valioso: deixar a intenção visível mesmo quando a precedência já faria a coisa certa. Escrever (preco * quantidade) - desconto não muda o resultado, mas poupa o leitor de recitar a tabela de precedência de cabeça. Código se escreve uma vez e se lê muitas; parênteses de clareza são um presente para o próximo leitor, que costuma ser você daqui a um mês.

Vamos aplicar num cálculo de verdade: juros simples, a fórmula em que o juro é sempre calculado sobre o valor inicial. O juro total é capital vezes taxa vezes tempo, e o montante final é o capital mais esse juro. Guardando R$ 1.000,00 a 2% ao mês por 12 meses, o código fica assim.

capital = 1000
taxa = 0.02      # 2% ao mês, escrito como 2 / 100
meses = 12

juros = capital * taxa * meses
montante = capital * (1 + taxa * meses)

print("Juros do período:", juros)      # Juros do período: 240.0
print("Montante final:", montante)     # Montante final: 1240.0

Juros simples em cinco linhas. Nos parênteses do montante, a precedência resolve taxa * meses antes do 1 +, e o parêntese externo garante que a soma aconteça antes de multiplicar pelo capital.

Olhe a linha do montante com atenção, porque ela usa a tabela inteira desta aula: dentro dos parênteses, taxa * meses calcula primeiro (0.24), depois soma com 1 (1.24), e só então multiplica pelo capital. Sem os parênteses, capital * 1 + taxa * meses daria 1000.24, um resultado absurdo e silencioso. E aqui vai um gancho honesto: a calculadora de juros simples do ValorFinal, que atende leitores todos os dias, executa exatamente essa expressão em produção. A distância entre o seu código de hoje e uma ferramenta pública é menor do que parece.