Tratamento de Erros ⚠️

Você já teve aquele momento de pânico quando seu código quebrou em produção? Como desenvolvedor sênior, sei que erros são inevitáveis, mas a forma como lidamos com eles é o que diferencia um código amador de um profissional.

Muitos desenvolvedores ignoram o tratamento de erros, esperando que “tudo vai dar certo”. Confesso que já passei noites em claro corrigindo bugs que poderiam ter sido evitados com um bom tratamento de exceções.

Estrutura Básica de Tratamento 🛡️

pythonCopytry:
    # Código que pode gerar erro
    numero = int(input("Digite um número: "))
    resultado = 10 / numero
    
except ValueError as e:
    # Erro de conversão de tipo
    print(f"Por favor, digite apenas números! Erro: {e}")
    
except ZeroDivisionError as e:
    # Erro de divisão por zero
    print(f"Não é possível dividir por zero! Erro: {e}")
    
except Exception as e:
    # Qualquer outro erro não previsto
    print(f"Ops, algo inesperado aconteceu: {e}")
    
else:
    # Executado apenas se nenhum erro ocorrer
    print(f"O resultado é: {resultado}")
    
finally:
    # Sempre executado, independente de erro
    print("Operação finalizada!")

Criando Exceções Personalizadas 🎯

pythonCopyclass IdadeInvalidaError(Exception):
    """Exceção levantada quando a idade é inválida"""
    pass

class UsuarioError(Exception):
    """Exceção base para erros relacionados a usuários"""
    def __init__(self, message, codigo=None):
        self.message = message
        self.codigo = codigo
        super().__init__(self.message)

def validar_idade(idade):
    if idade < 0:
        raise IdadeInvalidaError("A idade não pode ser negativa!")
    if idade > 150:
        raise IdadeInvalidaError("Idade improvável!")
    return idade

# Usando as exceções personalizadas
try:
    idade = validar_idade(-5)
except IdadeInvalidaError as e:
    print(f"Erro de validação: {e}")

Padrões Profissionais de Tratamento de Erros 🔧

1. Contextualização de Erros

# python
def processar_arquivo(caminho):
    try:
        with open(caminho, 'r') as arquivo:
            return arquivo.read()
    except FileNotFoundError:
        raise FileNotFoundError(
            f"O arquivo '{caminho}' não foi encontrado. "
            "Verifique se o caminho está correto."
        )
    except PermissionError:
        raise PermissionError(
            f"Sem permissão para ler '{caminho}'. "
            "Verifique as permissões do arquivo."
        )

2. Logging de Erros

# python
import logging

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)

def operacao_critica():
    try:
        # Código perigoso aqui
        resultado = 1 / 0
    except Exception as e:
        logging.error(f"Erro na operação: {str(e)}", exc_info=True)
        raise  # Re-lança o erro após logging

3. Limpeza de Recursos

# python
class BancoDeDados:
    def __init__(self):
        self.conexao = None
    
    def conectar(self):
        print("Conectando ao banco...")
        self.conexao = True
    
    def desconectar(self):
        print("Desconectando do banco...")
        self.conexao = None
    
    def executar_query(self):
        try:
            self.conectar()
            # Simula um erro
            raise Exception("Erro na query!")
        finally:
            # Garantir que a conexão seja fechada
            self.desconectar()

4. Hierarquia de Exceções

# python
class APIError(Exception):
    """Exceção base para erros da API"""
    pass

class ValidacaoError(APIError):
    """Erro de validação de dados"""
    pass

class AutorizacaoError(APIError):
    """Erro de autorização"""
    pass

def processar_requisicao():
    try:
        # Código que pode gerar diferentes erros
        pass
    except ValidacaoError:
        # Trata erro de validação
        pass
    except AutorizacaoError:
        # Trata erro de autorização
        pass

Dicas de Boas Práticas 💡

1. Seja Específico

# python
# Ruim
try:
    fazer_algo()
except Exception:
    pass  # Nunca faça isso!

# Bom
try:
    fazer_algo()
except ValueError as e:
    logging.error(f"Erro de valor: {e}")
    raise  # Re-lança se não puder tratar

2. Use Context Managers

# python
# Bom - Gerencia recursos automaticamente
with open('arquivo.txt') as f:
    dados = f.read()

# Melhor - Tratamento de erro específico
from contextlib import contextmanager

@contextmanager
def gerenciar_arquivo(caminho):
    try:
        f = open(caminho)
        yield f
    finally:
        f.close()

3. Documente Exceções

# python
def transferir_dinheiro(valor, conta):
    """
    Transfere dinheiro entre contas.
    
    Args:
        valor (float): Valor a transferir
        conta (Conta): Conta destino
    
    Raises:
        SaldoInsuficienteError: Se não houver saldo suficiente
        ContaBloqueadaError: Se a conta estiver bloqueada
    """
    pass

E você, como está tratando os erros em seus projetos? Já teve alguma experiência onde um bom tratamento de erro salvou seu dia? Compartilhe nos comentários suas experiências com tratamento de exceções!

Lembre-se: tratar erros adequadamente não é opcional em código profissional. É uma necessidade que separa aplicações robustas de aplicações frágeis!