Erros são inevitáveis em qualquer programa, e o Python oferece várias maneiras de lidar com eles.
O tratamento de erros é crucial para garantir que seu programa continue rodando de forma segura e eficiente, mesmo quando algo inesperado acontece.

Nesta lição, vamos explorar os diferentes tipos de erros, como tratá-los, como gerar seus próprios erros e como garantir que tarefas importantes de limpeza sejam sempre executadas.

Tipos de Erros no Python

Antes de aprendermos a tratar erros, precisamos entender as duas categorias principais:

• Erros de Sintaxe: Ocorrem quando o código Python não está sintaticamente correto. Eles são detectados pelo interpretador Python antes do programa rodar.
  Exemplo: esquecer um dois-pontos após uma declaração if.

• Exceções: Acontecem enquanto o programa está rodando quando algo inesperado ocorre — por exemplo, dividir um número por zero ou tentar acessar um índice inválido em uma lista.

Tratando Exceções com try e except

A forma mais comum de tratar exceções em Python é com blocos try/except:

• O bloco try contém o código que pode causar uma exceção.
• O bloco except contém o código a ser executado se uma exceção for levantada.

Exemplo:

try:
    file = open("file.txt", "r")
    content = file.read()
    print(content)
except IOError:
    print("O arquivo não pôde ser aberto.")

Aqui:

• Se "file.txt" não existir ou não puder ser aberto, o Python levanta um IOError.
• O bloco except o captura e imprime uma mensagem amigável ao invés de fazer o programa travar.

DICA: Mantenha o bloco try o menor possível — inclua apenas o código que pode falhar, não lógica não relacionada.

Tratando Vários Tipos de Exceções

Você pode tratar diferentes tipos de exceções separadamente usando múltiplos blocos except:

try:
    # código que pode levantar exceções
except TypeError:
    # trata erros de tipo
except ValueError:
    # trata erros de valor
except:
    # trata quaisquer outras exceções

O último except sem especificação captura qualquer exceção não tratada — mas use com cuidado, pois pode esconder bugs inesperados.

Levantando Suas Próprias Exceções

Às vezes, seu programa precisa sinalizar que algo deu errado — mesmo que o Python normalmente não considerasse um erro. Você pode levantar exceções usando a instrução raise.

Exemplo:

def divide(a, b):
    if b == 0:
        raise ValueError("O segundo argumento não pode ser zero")
    return a / b

print(divide(10, 2))  # 5.0
print(divide(10, 0))  # ValueError: O segundo argumento não pode ser zero

Isso permite definir mensagens claras de erro e interromper a execução quando dados inválidos são encontrados.

O bloco finally

O bloco finally define código que sempre será executado — quer tenha ocorrido uma exceção ou não. É frequentemente usado para liberar recursos como arquivos ou conexões com banco de dados.

Exemplo:

try:
    file = open("file.txt", "r")
    content = file.read()
    print(content)
finally:
    file.close()

Mesmo que a leitura do arquivo tenha causado um erro, o bloco finally garante que o arquivo seja fechado.

IMPORTANTE!: Sempre feche arquivos e libere recursos em um bloco finally (ou use a instrução "with") para evitar vazamentos.

Entendido — aqui está uma seção adicional que você pode adicionar à lição Tratamento de Erros, explicando por que "try/except para tudo" é uma má prática e quando o tratamento direcionado é a escolha certa.

Evite Capturar Todas as Exceções Sem Motivo

Um erro comum de iniciantes é envolver grandes blocos de código em um único bloco try/except que captura tudo — ou pior, usar um except: sem especificar o tipo de erro.

Exemplo de má prática:

try:
    # muito código não relacionado aqui
except:
    pass  # ignora silenciosamente todos os erros

Por que isso é perigoso:

• Esconde bugs: erros reais no seu código serão ignorados, dificultando encontrá-los.
• Mascarar a causa: você perde informações sobre o que realmente falhou.
• Pode causar comportamento inesperado: o programa continua rodando em um estado inválido.

Quando Usar o Tratamento Abrangente de Exceções

Capturar todas as exceções (except Exception:) deve ser raro e intencional. Exemplos onde pode ser apropriado:

• Logging de erro no nível mais alto de um programa, para evitar que ele trave e registrar o erro em um arquivo de log.
• Laços tolerantes a falhas em serviços que precisam continuar rodando (mas ainda assim registrando/reportando o erro antes de continuar).
• Depuração temporária para verificar rapidamente se algo está dando errado — mas apenas como uma ferramenta de curto prazo.

Boas Práticas

• Seja específico: capture apenas as exceções que espera e sabe como tratar.
• Mantenha blocos try pequenos: envolva apenas o código que pode falhar, não funções inteiras.
• Sempre registre ou trate a exceção de forma significativa — não apenas ignore com um "pass".

Sendo seletivo, seu código ficará mais fácil de depurar, mais seguro para rodar e muito mais previsível.

Conclusão

O tratamento de erros é uma parte fundamental da programação em Python:

• Evita falhas inesperadas.
• Permite lidar com problemas de forma elegante.
• Torna seu código mais robusto, confiável e seguro.

Dominando exceções, levantando erros personalizados e usando finally, você escreverá programas melhor preparados para o mundo real.