plano de voo

O que vamos aprender hoje

de onde paramos · 2 dias atrás

Sobrecarga — o que vimos na aula 11

• 🎚️ Simular sobrecarga de método: uma versão flexível com default, *args e **kwargs no lugar de várias versões fixas.
• ➕ Sobrecarga de operador: dunder methods (__add__, __eq__, __str__) ensinam seus objetos a responder a +, == e print.
• 🌉 A pendência: a classe Dinheiro devolvia None quando as moedas eram diferentes. Funcionou — mas a gente prometeu voltar nisso hoje.

memória muscular

O Dinheiro da aula 11 — e o seu defeito

Quando as moedas batiam, somava. Quando não batiam, imprimia um aviso e devolvia None. Parecia razoável. Não era.

class Dinheiro:
    def __init__(self, valor, moeda):
        self.valor = valor
        self.moeda = moeda

    def __add__(self, outro):
        if self.moeda != outro.moeda:
            print(f"⚠️  Não dá pra somar {self.moeda} com {outro.moeda}")
            return None          # ← o defeito mora aqui
        return Dinheiro(self.valor + outro.valor, self.moeda)

carteira = Dinheiro(10, "BRL")
total = carteira + Dinheiro(5, "USD")   # imprime o aviso...
print(total)                            # None  ← e segue como se nada fosse

pergunta pra turma · 2 minutos

Pra esquentar a cabeça

• ❓ Aquele total que virou None não fica parado — ele é usado mais pra frente no programa. O que acontece quando alguém escreve print(total.valor) três telas depois, achando que total é um Dinheiro de verdade?

a resposta · e por que ela importa

O erro estoura longe de onde nasceu

O None viaja silencioso pelo programa até alguém tentar usá-lo como se fosse um objeto. Aí, sim, trava — mas numa linha que não tem nada a ver com a soma.

carteira = Dinheiro(10, "BRL")
total = carteira + Dinheiro(5, "USD")   # aqui imprimiu o aviso e devolveu None

# ... 50 linhas depois, em outra função, outro arquivo ...
print(total.valor)
# AttributeError: 'NoneType' object has no attribute 'valor'

começando pelo problema

Duas reações ruins a um erro

• 🎭 Devolver um valor mágico (None, -1, False, ""): quem chama precisa adivinhar que aquele valor significa "deu errado" — e lembrar de checar toda vez.
• 🖨️ Imprimir e seguir em frente (print("erro!")): o aviso some no meio de mil outras linhas do terminal, e o programa continua como se estivesse tudo bem.

o problema em código

O Python já faz isso o tempo todo

Você já viu erros que param o programa na hora. Eles têm nome e sobrenome — e param exatamente na linha que causou o problema.

print(10 / 0)
# ZeroDivisionError: division by zero

idade = int("abc")
# ValueError: invalid literal for int() with base 10: 'abc'

lista = [1, 2, 3]
print(lista[10])
# IndexError: list index out of range

pessoa = {"nome": "Ana"}
print(pessoa["idade"])
# KeyError: 'idade'

a ideia da solução

Separe quem detecta de quem trata

• 🚨 Quem detecta (raise): a função que percebe o problema só dispara o alarme — "saldo insuficiente!" — e para ali mesmo. Não precisa saber o que fazer depois.
• 🧰 Quem trata (try/except): quem chamou a função decide a reação — mostrar mensagem pro usuário, tentar de novo, registrar num log. Cada contexto reage do seu jeito.

as peças que você vai encontrar

Antes do código, conhece quem entra em cena

• 🚨 raise: dispara uma exceção de propósito. raise ValueError("mensagem") para o programa ali e sobe o erro pra quem chamou.
• 🛡️ try: marca um bloco "arriscado" — código que pode dar erro. Você diz ao Python "tenta isso aqui, e fica de olho".
• 🪤 except: a rede de segurança. Se o bloco try levantar uma exceção, o except captura e roda um plano B em vez de deixar o programa morrer.

ferramenta 1 · capturar

try / except — a rede de segurança

Envolva o código arriscado num try. Se ele estourar, o except entra em ação — e o programa não morre.

try:
    idade = int(input("Digite sua idade: "))
    print(f"Ano que vem você faz {idade + 1}")
except ValueError:
    print("Isso não é um número válido!")

print("O programa continua rodando.")   # roda mesmo se deu erro

ferramenta 2 · disparar

raise — o alarme que você aciona

Quando sua função percebe uma situação inválida, ela mesma levanta a exceção. Não devolve None — dispara o alarme.

def sacar(saldo, valor):
    if valor > saldo:
        raise ValueError("Saldo insuficiente para o saque")
    return saldo - valor

print(sacar(100, 30))    # 70  ← deu certo
print(sacar(100, 150))   # para aqui:
# ValueError: Saldo insuficiente para o saque

capturar com pontaria

Um except para cada tipo de erro

Você pode ter vários except no mesmo try — cada um trata um tipo específico de exceção. O Python escolhe o que combina.

def dividir(a, b):
    return int(a) / int(b)

try:
    resultado = dividir("10", "0")
except ValueError:
    print("Digite apenas números!")
except ZeroDivisionError:
    print("Não dá pra dividir por zero!")
# saída: Não dá pra dividir por zero!

lendo o erro capturado

as erro — pegue a exceção pela mão

Com except ... as erro, você guarda a exceção numa variável e pode ler a mensagem que veio dentro dela.

try:
    numero = int("abc")
except ValueError as erro:
    print(f"Deu ruim: {erro}")
    # Deu ruim: invalid literal for int() with base 10: 'abc'

as duas peças que faltavam

else e finally — completando o quarteto

else roda só quando o try deu certo. finally roda sempre — deu certo ou não. Ideal pra limpeza (fechar arquivo, conexão).

try:
    numero = int("42")
except ValueError:
    print("Não era número")
else:
    print(f"Converteu certo: {numero}")   # roda só se NÃO deu erro
finally:
    print("Fim da tentativa")              # roda SEMPRE

# saída:
# Converteu certo: 42
# Fim da tentativa

agora podemos dar o nome

Isso se chama Exceção

• 📦 Exceção é um objeto — instância de uma classe como ValueError ou ZeroDivisionError. Carrega uma mensagem e pode carregar dados.
• 🆚 Erro vs. exceção: no dia a dia usamos como sinônimos. Tecnicamente, a exceção é o objeto; levantar/tratar é o que você faz com ele.

antes e depois · lado a lado

A diferença que as exceções fazem

analogia do cotidiano

O disjuntor da casa

• ⚡ O raise é o disjuntor desarmando: na primeira sobrecarga, corta tudo. Melhor parar agora do que deixar a fiação esquentar em silêncio.
• 🔧 O try/except é você no quadro de luz: percebe que desarmou, entende qual circuito foi e decide o que fazer — religar, chamar o eletricista, isolar o problema.

toda exceção tem família

A hierarquia de exceções do Python

Exceções são classes — e classes têm herança (aulas 07-10). Toda exceção desce de Exception. Isso significa que capturar uma classe-mãe captura também as filhas.

# BaseException
#  └── Exception              ← capture a partir daqui
#       ├── ArithmeticError
#       │    └── ZeroDivisionError
#       ├── LookupError
#       │    ├── IndexError
#       │    └── KeyError
#       ├── ValueError
#       └── TypeError

try:
    resultado = 10 / 0
except ArithmeticError:        # pai de ZeroDivisionError
    print("Capturado pela classe-mãe!")
# saída: Capturado pela classe-mãe!

panorama · as exceções nativas mais comuns

Os erros que você mais vai encontrar

parte 2 · seus próprios erros

E quando o erro é do seu domínio?

• 🏷️ A ideia: uma exceção com nome próprio (SaldoInsuficienteError) conta a história sem precisar ler a mensagem. O tipo do erro já é a documentação.
• 🧬 Como se faz: é só uma classe que herda de Exception. Toda a maquinaria de raise e except já funciona de graça — herança da aula 07.

a solução em código

Criar uma exceção é criar uma classe

Uma linha. Herda de Exception, ganha um nome que fala a língua do seu sistema, e já pode ser levantada e capturada.

class SaldoInsuficienteError(Exception):
    pass

def sacar(saldo, valor):
    if valor > saldo:
        raise SaldoInsuficienteError("Você não tem saldo suficiente")
    return saldo - valor

try:
    sacar(100, 150)
except SaldoInsuficienteError as erro:
    print(f"Operação negada: {erro}")
# saída: Operação negada: Você não tem saldo suficiente

exceção que carrega dados

Sua exceção pode levar informação junto

Defina um __init__ (aula 02!) e a exceção carrega os dados do problema. Quem captura lê esses dados pra reagir com precisão.

class SaldoInsuficienteError(Exception):
    def __init__(self, saldo, valor):
        self.saldo = saldo
        self.valor = valor
        self.falta = valor - saldo
        # super() monta a mensagem que aparece no print do erro
        super().__init__(f"Faltam R$ {self.falta:.2f} para sacar R$ {valor:.2f}")

try:
    raise SaldoInsuficienteError(saldo=100, valor=150)
except SaldoInsuficienteError as erro:
    print(erro)            # Faltam R$ 50.00 para sacar R$ 150.00
    print(erro.falta)      # 50  ← dá pra ler os dados do erro

anatomia

O bloco completo, parte por parte

try, except, else e finally têm uma ordem fixa e um papel cada. Decora essa sequência.

uso com critério

A regra de ouro: não engula erros

• 🙈 Engolir o erro (except: pass) é desligar o alarme de incêndio porque o barulho incomoda. O fogo continua — você só parou de ser avisado.
• 🎯 Capture específico: except ValueError em vez de except Exception. Capturar largo demais esconde até erros de digitação (um NameError que deveria estourar).

armadilha · não faça isso

O except que esconde tudo

Os dois blocos abaixo "funcionam" — nenhum trava o programa. Mas ambos transformam um erro real num mistério insolúvel.

# ❌ Engolir: o erro some, mas o problema continua
try:
    numero = int("abc")
except:
    pass            # ninguém nunca vai saber o que deu errado

# ❌ Genérico demais: mascara até bug de digitação
try:
    total = calcualr_preco(100)   # 'calcualr' está escrito errado
except Exception:
    total = 0                     # esconde o NameError de propósito

# ✅ Específico e honesto
try:
    numero = int("abc")
except ValueError as erro:
    print(f"Entrada inválida: {erro}")

por que isso importa

O que o tratamento de exceções entrega

glossário rápido

Os termos de hoje, em uma frase cada

laboratório em sala · duplas

Exercício ao Vivo: Conta Bancária

Em duplas. 30 minutos. Objetivo: uma ContaBancaria que se recusa a fazer operações inválidas — levantando exceções em vez de devolver valores mágicos.

resolução · passo 1

Começamos pela exceção

• 🏷️ Herdamos de Exception e damos o nome do domínio: SaldoInsuficienteError. Esse nome vai aparecer no except e contar a história sozinho.
• 📦 O __init__ guarda saldo e valor, calcula falta e monta a mensagem via super().__init__.

resolução · passo 1

A exceção SaldoInsuficienteError

Ela guarda o contexto do erro: quanto tinha, quanto se tentou sacar e quanto faltou.

class SaldoInsuficienteError(Exception):
    def __init__(self, saldo, valor_saque):
        self.saldo = saldo
        self.valor_saque = valor_saque
        self.falta = valor_saque - saldo
        super().__init__(
            f"Saldo de R$ {saldo:.2f} insuficiente para sacar "
            f"R$ {valor_saque:.2f} (faltam R$ {self.falta:.2f})"
        )

resolução · passos 2 e 3

A ContaBancaria que se defende

Cada método valida antes de agir. Valor inválido? ValueError. Saldo curto? SaldoInsuficienteError. Nenhuma operação errada passa.

class ContaBancaria:
    def __init__(self, titular, saldo=0):
        self.titular = titular
        self.saldo = saldo

    def depositar(self, valor):
        if valor <= 0:
            raise ValueError("O valor do depósito deve ser positivo")
        self.saldo += valor
        return self.saldo

    def sacar(self, valor):
        if valor <= 0:
            raise ValueError("O valor do saque deve ser positivo")
        if valor > self.saldo:
            raise SaldoInsuficienteError(self.saldo, valor)
        self.saldo -= valor
        return self.saldo

resolução · passo 4

Usando a conta com try/except/finally

Um saque válido, um que estoura. Cada erro tem seu except, e o finally mostra o saldo aconteça o que acontecer.

from banco import ContaBancaria, SaldoInsuficienteError

conta = ContaBancaria("Ana", saldo=100)

try:
    conta.sacar(30)
    print(f"Saque OK. Saldo: R$ {conta.saldo:.2f}")
    conta.sacar(500)   # 💥 estoura aqui
    print("Esta linha nunca roda")
except SaldoInsuficienteError as erro:
    print(f"❌ {erro}")
    print(f"   Deposite mais R$ {erro.falta:.2f} para conseguir sacar.")
except ValueError as erro:
    print(f"❌ Valor inválido: {erro}")
finally:
    print(f"Saldo final: R$ {conta.saldo:.2f}")

resolução · saída

Saída esperada no terminal

O saque válido passa, o inválido é barrado com mensagem clara, e o saldo final aparece intacto — o saque que falhou não tirou nada.

$ python main.py
Saque OK. Saldo: R$ 70.00
❌ Saldo de R$ 70.00 insuficiente para sacar R$ 500.00 (faltam R$ 430.00)
   Deposite mais R$ 430.00 para conseguir sacar.
Saldo final: R$ 70.00

encerramento

O que dominamos hoje

• ✓
  O problema: devolver None ou imprimir aviso deixa o erro escapar e explodir longe da causa.
• ✓
  A solução: raise dispara o erro na origem; try/except captura e trata onde faz sentido.
• ✓
  O quarteto: try (arriscado), except (plano B), else (deu certo), finally (sempre).
• ✓
  A família: exceções são classes com herança — capturar a mãe pega as filhas.
• ✓
  Erros próprios: herde de Exception pra criar exceções com nome e dados do seu domínio.
• ✓
  Na prática: conta bancária que se recusa a fazer operação inválida — e diz exatamente o que faltou.

exercícios · visão geral

Para praticar em casa

Sete exercícios em quatro níveis. Faça pelo menos um de cada nível antes da próxima aula.

exercícios · nível fácil

Para fixar try/except

exercícios · nível médio

Levantar e criar erros

exercícios · nível difícil

Para ir além

exercícios · nível avançado

O desafio que junta tudo

Um exercício só, que usa hierarquia de exceções e captura por classe-mãe.