O que é tratamento de exceções?

Um programa que pergunta a idade das pessoas vai, mais cedo ou mais tarde, receber "twenty" em vez de 20. Converter esse texto é um erro de tempo de execução: int("twenty") lança ValueError, e sem um plano para isso o programa para. Tratamento de exceções é esse plano. Você marca o código que pode falhar e escreve o código que executa se ele falhar.

answers = ["34", "twenty", "19"]

for text in answers:
    try:
        age = int(text)
        print("Next year you will be", age + 1)
    except ValueError:
        print("Not a number:", text)

print("Done")

Next year you will be 35
Not a number: twenty
Next year you will be 20
Done

A resposta inválida é informada, e o loop continua com a próxima. Sem o try, o programa teria impresso uma linha e depois um traceback.

Como o tratamento de exceções funciona

1. O código dentro do try executa normalmente.
2. Uma operação falha, e o runtime lança uma exceção: um objeto com um tipo (ValueError) e uma mensagem (invalid literal for int() with base 10: 'twenty').
3. O bloco try para naquela linha. As linhas restantes dele são puladas, e é por isso que "Next year you will be" não é impresso para "twenty".
4. O runtime compara o tipo da exceção com cada cláusula except, de cima para baixo, e executa a primeira que corresponder.
5. Depois que o tratador termina, o programa continua na primeira linha depois de toda a instrução try.
6. Se nenhuma cláusula corresponde, a exceção sai da função atual e a busca continua na função que a chamou, depois em quem chamou essa função. Isso se chama desenrolar a pilha de chamadas. Se a busca chega ao topo do programa sem encontrar correspondência, o programa termina com um traceback.

O passo 6 significa que o tratador não precisa estar na função onde o erro acontece. Aqui a falha está duas chamadas abaixo, e o tratador no final ainda a captura:

def parse_price(text):
    print("parsing", text)
    return float(text)

def total(prices):
    result = 0
    for p in prices:
        result += parse_price(p)
    return result

try:
    print(total(["4.50", "free", "3.20"]))
except ValueError as error:
    print("Could not add the prices:", error)

parsing 4.50
parsing free
Could not add the prices: could not convert string to float: 'free'

float("free") falhou dentro de parse_price. Nem parse_price nem total tinham um tratador, então as duas foram abandonadas, e "3.20" nunca foi convertido. Essa é a principal escolha de projeto que o tratamento de exceções oferece: tratar um erro onde você sabe o que fazer com ele, o que muitas vezes fica longe de onde ele aconteceu.

try, except, else e finally

A instrução try do Python tem mais duas partes opcionais. else executa só quando o bloco try terminou sem exceção. finally executa em todos os casos: depois do sucesso, depois de uma exceção tratada e até quando a função retorna de dentro do try.

def divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        print("b was zero")
        return None
    else:
        print("no error")
        return result
    finally:
        print("finally runs either way")

print(divide(6, 3))
print(divide(6, 0))

no error
finally runs either way
2.0
b was zero
finally runs either way
None

O finally é o lugar da limpeza: fechar um arquivo, liberar um lock, fechar uma conexão com o banco de dados. Em Python a instrução with faz essa limpeza para arquivos automaticamente, e ela é a escolha habitual para eles.

Lançando suas próprias exceções

Exceções não servem só para erros que a linguagem detecta. Quando a sua própria função recebe uma entrada com que não consegue trabalhar, ela pode lançar uma exceção para recusá-la, e quem chamou decide o que acontece em seguida. Definir uma pequena classe de exceção dá ao erro um nome que o descreve.

class InsufficientFunds(Exception):
    pass

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFunds(f"cannot take {amount}, balance is {balance}")
    return balance - amount

print(withdraw(100, 30))

try:
    withdraw(100, 250)
except InsufficientFunds as error:
    print("Refused:", error)

70
Refused: cannot take 250, balance is 100

O Python usa raise. Java, C++ e JavaScript usam throw para a mesma coisa.

Tratamento de exceções em outras linguagens

O mesmo exemplo de conversão em Java fica assim:

try {
    int age = Integer.parseInt("twenty");
    System.out.println(age + 1);
} catch (NumberFormatException e) {
    System.out.println("Not a number: " + e.getMessage());
} finally {
    System.out.println("done");
}

O Java divide as exceções em dois grupos. As exceções verificadas (checked), como IOException, descrevem problemas fora do controle do programa, e o compilador se recusa a compilar código que nem as captura nem as declara. As exceções não verificadas (unchecked), subclasses de RuntimeException como NullPointerException, costumam indicar um bug, e o compilador não obriga você a tratá-las.

Erros comuns

• Capturar tudo. Um except: vazio em Python também captura KeyboardInterrupt, então o Ctrl+C para de funcionar, e except Exception: captura bugs que você nunca previu. Capture o tipo específico que você sabe tratar.
• Engolir o erro. except ValueError: pass esconde o problema. No mínimo, imprima ou registre em log o que deu errado.
• Um bloco try grande demais. Envolva só as linhas que podem lançar a exceção que você está capturando, para que um erro sem relação não seja tratado por engano.
• Capturar bugs em vez de corrigi-los. Um IndexError vindo de um loop que executa um passo a mais é um erro no código. Tratá-lo mantém vivo o código errado.
• Esperar que o catch impeça um travamento em C ou C++. Uma falha de segmentação é um sinal do sistema operacional, não uma exceção, e no Linux e no macOS um catch (...) do C++ nunca a vê.

Próximos passos

Os erros a que o tratamento de exceções responde estão descritos na página de erro de tempo de execução, e o travamento que ele não consegue capturar, na página de falha de segmentação. Para a sintaxe completa, leia os guias de exceções em Python, try e catch em Java, exceções em C++ e try e catch em JavaScript. O curso de Java e o curso de Python praticam os dois com exercícios reais.