Try/Except: Como Tratar Erros em Python

Erros acontecem — o segredo é como lidar com eles

Imagine que seu programa pede um número ao usuário e ele digita "banana". Sem tratamento de erro, o programa simplesmente quebra. Com try/except, você decide o que acontece.

# Sem tratamento — o programa morre
idade = int(input("Sua idade: "))  # ValueError se digitar "abc"

# Com tratamento — o programa sobrevive
try:
    idade = int(input("Sua idade: "))
except ValueError:
    print("Isso não é um número válido!")

A estrutura básica

try:
    # código que pode dar erro
    resultado = 10 / 0
except ZeroDivisionError:
    # o que fazer quando der erro
    print("Não é possível dividir por zero!")

O Python tenta executar o bloco try. Se der erro, ele pula para o except correspondente.

Capturando erros específicos

Sempre que possível, capture o erro específico:

try:
    numero = int(input("Digite um número: "))
    resultado = 100 / numero
except ValueError:
    print("Você não digitou um número!")
except ZeroDivisionError:
    print("Não dá para dividir por zero!")

Cada tipo de erro tem seu tratamento. Isso é muito melhor do que um except genérico.

Os erros mais comuns

Acessando a mensagem do erro

Use as para capturar o objeto do erro:

try:
    arquivo = open("dados.txt")
except FileNotFoundError as e:
    print(f"Erro: {e}")
    # Erro: [Errno 2] No such file or directory: 'dados.txt'

O bloco else

O else executa somente se não houve erro:

try:
    numero = int(input("Digite um número: "))
except ValueError:
    print("Valor inválido!")
else:
    print(f"Você digitou {numero}")  # só roda se não deu erro

É mais limpo do que colocar tudo dentro do try.

O bloco finally

O finally sempre executa, deu erro ou não:

try:
    arquivo = open("dados.txt")
    conteudo = arquivo.read()
except FileNotFoundError:
    print("Arquivo não encontrado!")
finally:
    print("Operação finalizada.")  # sempre executa

Útil para limpar recursos (fechar arquivos, conexões, etc.).

A estrutura completa

try:
    # tenta executar
    resultado = operacao_arriscada()
except TipoDoErro as e:
    # trata o erro
    print(f"Deu ruim: {e}")
else:
    # só roda se NÃO deu erro
    print(f"Resultado: {resultado}")
finally:
    # SEMPRE roda
    print("Finalizando...")

Exemplo prático: input validado

def pedir_numero(mensagem):
    while True:
        try:
            return float(input(mensagem))
        except ValueError:
            print("Por favor, digite um número válido.")

nota = pedir_numero("Sua nota: ")
print(f"Nota registrada: {nota}")

O programa fica pedindo até o usuário digitar algo válido. Sem crash, sem frustração.

Exemplo prático: leitura de arquivo

def ler_config(caminho):
    try:
        with open(caminho) as f:
            return f.read()
    except FileNotFoundError:
        print(f"Arquivo {caminho} não encontrado. Usando padrão.")
        return "{}"

config = ler_config("config.json")

Levantando seus próprios erros

Você pode criar erros com raise:

def sacar(saldo, valor):
    if valor > saldo:
        raise ValueError(f"Saldo insuficiente! Saldo: {saldo}, Saque: {valor}")
    return saldo - valor

try:
    novo_saldo = sacar(100, 150)
except ValueError as e:
    print(e)  # Saldo insuficiente! Saldo: 100, Saque: 150

O que NÃO fazer

Nunca use except genérico sem motivo

# Ruim — esconde bugs
try:
    resultado = funcao_complexa()
except:
    pass  # ignora TUDO, até erros de programação

# Melhor — capture erros específicos
try:
    resultado = funcao_complexa()
except ValueError:
    resultado = valor_padrao

O except: genérico (sem especificar o tipo) captura tudo, inclusive erros de programação que você deveria corrigir.

Não use try/except para controle de fluxo normal

# Ruim
try:
    valor = dicionario["chave"]
except KeyError:
    valor = "padrão"

# Melhor
valor = dicionario.get("chave", "padrão")

Se existe uma forma mais direta de fazer algo, prefira ela.

Conclusão

Tratamento de erros não é frescura — é o que separa um programa amador de um programa robusto. Com try/except, seu código fica mais resiliente e a experiência do usuário muito melhor.

A regra é simples: trate os erros que você espera, deixe os que você não espera estourarem (para que você possa corrigi-los).