4. Operadores e expressões¶

Nesta aula

Ideia central: o Python calcula na ordem da matemática, não na ordem em que você leu a frase. Quando as duas ordens diferem, o programa roda e entrega o número errado.

Ao fim você vai conseguir: usar os sete operadores aritméticos; escolher entre /, // e %; usar parênteses para forçar a ordem que você quer; e fechar a Unidade 1 escrevendo sozinho um programa completo.

Os operadores¶

a = 17
b = 5

print("soma:", a + b)
print("subtracao:", a - b)
print("multiplicacao:", a * b)
print("divisao:", a / b)
print("divisao inteira:", a // b)
print("resto:", a % b)
print("potencia:", a ** 2)

soma: 22
subtracao: 12
multiplicacao: 85
divisao: 3.4
divisao inteira: 3
resto: 2
potencia: 289

Operador	O que faz	`17` e `5`
`+`	soma	22
`-`	subtração	12
`*`	multiplicação	85
`/`	divisão	3.4
`//`	divisão inteira	3
`%`	resto da divisão	2
`**`	potência	289 (`17 ** 2`)

Os três primeiros não têm surpresa. Os quatro outros merecem atenção.

`/`, `//` e `%`¶

# A divisao comum sempre devolve float, mesmo quando da exato.
print(10 / 2)
print(type(10 / 2))

# A divisao inteira joga fora a parte quebrada.
print(10 // 3)
print(7 // 2)

5.0
<class 'float'>
3
3

Repare: 10 / 2 deu 5.0, e não 5. A divisão comum devolve sempre um float, mesmo quando o resultado é exato. É o motivo de médias saírem com .0 no fim.

// e % são duas metades da mesma conta — a divisão que você aprendeu no primário, com quociente e resto:

// devolve quantas vezes cabe (o quociente), jogando fora a sobra;
% devolve quanto sobrou (o resto).

💡 Pense assim: dividir cartelas de ovos

37 ovos em cartelas de 12. 37 // 12 dá 3 cartelas cheias; 37 % 12 dá 1 ovo sobrando. Juntos, os dois descrevem a divisão inteira.

O % parece exótico e é um dos operadores mais úteis que existem. Duas aplicações que voltam o semestre inteiro:

converter unidades: segundos em minutos, minutos em horas;
testar se um número é múltiplo de outro: n % 2 dá zero exatamente quando n é par. Você vai usar isso muito a partir do capítulo 5.

# O resto responde "quanto sobra".
minutos_totais = 137

horas = minutos_totais // 60
minutos = minutos_totais % 60

print(f"{minutos_totais} minutos sao {horas}h{minutos:02d}")

137 minutos sao 2h17

({minutos:02d} formata o inteiro com dois dígitos, completando com zero à esquerda — é o que faz 2h17 sair certo mesmo quando o valor é 2h07.)

A ordem das contas¶

Esta é a parte do capítulo que custa nota em prova.

nota1 = 6
nota2 = 8
nota3 = 10

# Errado: a divisao acontece antes da soma.
print(nota1 + nota2 + nota3 / 3)

# Certo: os parenteses forcam a soma primeiro.
print((nota1 + nota2 + nota3) / 3)

17.333333333333332
8.0

As duas linhas parecem dizer a mesma coisa em português — "a média das três notas" — e devolvem números completamente diferentes. A primeira está errada.

O Python segue a ordem da matemática:

o que está entre parênteses;
potência (**);
multiplicação e divisão (*, /, //, %), da esquerda para a direita;
soma e subtração (+, -), da esquerda para a direita.

Então nota1 + nota2 + nota3 / 3 divide só a nota3 por 3, e depois soma tudo. O programa roda, não dá erro nenhum, e imprime 17.33 como se fosse uma média de notas de 0 a 10.

O erro que não se denuncia

Este é o mesmo modo de falha do capítulo anterior, e o mais importante da Unidade 1: um programa que roda não é um programa que está certo.

O único jeito de pegar um erro desses é olhar o resultado e perguntar "este número faz sentido?". Média de notas entre 0 e 10 não pode dar 17. Se você não souber qual resultado esperar, nenhum computador vai te avisar.

Na dúvida, use parênteses. Eles não deixam o programa mais lento e deixam a sua intenção explícita para quem lê — inclusive para você, depois.

Fechando a Unidade 1¶

Com o que você já tem, dá para escrever um programa inteiro e útil:

franquia_gb = 20
usado_gb = 13.5

restante = franquia_gb - usado_gb
percentual = usado_gb / franquia_gb * 100

print(f"Usado: {usado_gb} GB de {franquia_gb} GB ({percentual:.1f}%)")
print(f"Restam {restante:.1f} GB")

Usado: 13.5 GB de 20 GB (67.5%)
Restam 6.5 GB

Entrada, processamento e saída; variáveis com nomes que dizem o que são; parênteses onde a ordem importa; f-string com formato. É o repertório das quatro primeiras semanas, e ele já resolve uma boa quantidade de problemas reais.

O que ainda não dá para fazer é decidir. Este programa avisa quanto restou da franquia, mas não consegue dizer "atenção, você já passou de 80%" — porque, para isso, ele precisaria olhar o valor e escolher o que fazer. Todo programa que você escreveu até aqui executa todas as linhas, sempre, na mesma ordem.

É exatamente aí que começa a Unidade 2.

Erros comuns deste capítulo¶

Mensagem ou sintoma	Causa provável
a média deu maior que a maior nota	faltaram parênteses: a divisão veio antes da soma
`10 / 2` deu `5.0` e você esperava `5`	`/` sempre devolve `float`; use `//` se quiser inteiro
`ZeroDivisionError: division by zero`	o divisor é zero — quase sempre uma variável que ficou em 0
`TypeError: unsupported operand type(s)`	um dos valores ainda é texto: faltou converter
a porcentagem deu `0.675` em vez de `67.5`	faltou multiplicar por 100
o horário saiu `2h7` em vez de `2h07`	faltou `:02d` na f-string

Resumo¶

Sete operadores: + - * / // % **.
/ devolve sempre float; // dá o quociente inteiro e % dá o resto.
n % 2 == 0 é o teste de "é par" — guarde para o próximo capítulo.
A ordem é a da matemática: parênteses, potência, multiplicação e divisão, soma e subtração. Na dúvida, use parênteses.
Um erro de precedência não dá mensagem de erro. Olhe o resultado e pergunte se ele faz sentido.

Para praticar¶

Lista 04 · Operadores. Depois dela vem a Unidade 2, em que o programa finalmente aprende a decidir.