Escrever um código eficaz de tratamento de exceções é essencial para criar aplicativos robustos e de fácil manutenção.
Abaixo estão algumas práticas recomendadas para escrever código de tratamento de exceções em Python:

1. Pegue apenas o que você pode controlar

Seja específico:

• Capture exceções específicas em vez de usar uma cláusula ampla de exceção.
• Isso garante que apenas as exceções que você espera e sabe como lidar sejam capturadas.

try:
    # Code that might raise an exception
except ValueError as e:
    print(f"Value error occurred: {e}")

2. Evite Nu, exceto: Cláusulas

Capturar exceções específicas:

• Evite usar exceto: sem especificar um tipo de exceção.
• Isso pode detectar erros inesperados e dificultar a depuração.

try:
    # Code that might raise an exception
except Exception as e:  # Catch all exceptions if necessary
    print(f"An error occurred: {e}")

3. Use blocos try-except-else-finally

• try: coloque o código que pode gerar uma exceção aqui.
• exceto: trata exceções neste bloco.
• else: Execute este bloco se nenhuma exceção foi levantada no bloco try.
• finalmente: Execute este bloco independentemente de uma exceção ter sido levantada, geralmente usada para limpeza.

try:
    # Code that might raise an exception
except ValueError as e:
    print(f"Value error: {e}")
else:
    print("No exceptions occurred.")
finally:
    print("This will always be executed.")

4. Exceções de registro

• Use o módulo de registro para registrar exceções.
• O registro ajuda a diagnosticar problemas na produção sem revelar erros aos usuários finais.

import logging

logging.basicConfig(level=logging.ERROR)

try:
    # Code that might raise an exception
except Exception as e:
    logging.error(f"An error occurred: {e}")

5. Aumente novamente as exceções quando necessário

• Se você capturar uma exceção, mas não conseguir tratá-la completamente, considere aumentá-la novamente para que ela possa ser tratada em outro lugar.

try:
    # Code that might raise an exception
except ValueError as e:
    logging.error(f"Value error: {e}")
    raise  # Re-raise the exception

6. Use gerenciadores de contexto para gerenciamento de recursos

• Use gerenciadores de contexto (com instrução) para gerenciar recursos como arquivos, soquetes ou conexões de banco de dados.
• Isso garante que os recursos sejam liberados adequadamente, mesmo que uma exceção seja gerada.

with open('file.txt', 'r') as file:
    content = file.read()

7. Degradação Graciosa

-Em vez de permitir que seu aplicativo trave, forneça mecanismos de fallback ou mensagens de erro fáceis de usar.

• Por exemplo, se um arquivo de configuração estiver faltando, você poderá usar as configurações padrão.

try:
    with open('config.json', 'r') as file:
        config = json.load(file)
except FileNotFoundError:
    print("Config file not found, using defaults.")
    config = {"default": "value"}

8. Evite engolir exceções

• Não capture exceções sem realizar nenhuma ação.
• Ignorar exceções pode ocultar bugs e fazer com que o aplicativo se comporte de maneira imprevisível.

try:
    # Code that might raise an exception
except Exception as e:
    pass  # Bad practice - you're ignoring the error

9. Exceções de documentos

• Use docstrings para documentar as exceções que suas funções podem gerar.
• Isso ajuda outros desenvolvedores a entender quais exceções esperar e como lidar com elas.

def divide(a, b):
    """
    Divides two numbers.

    :param a: Numerator.
    :param b: Denominator.
    :return: The result of the division.
    :raises ZeroDivisionError: If the denominator is zero.
    """
    if b == 0:
        raise ZeroDivisionError("Cannot divide by zero.")
    return a / b

10. Use exceções personalizadas quando apropriado

• Crie exceções personalizadas para representar condições de erro específicas em seu aplicativo.
• Isso pode tornar seu código mais legível e mais fácil de manter.

class InvalidInputError(Exception):
    """Exception raised for invalid inputs."""
    pass

def process_input(value):
    if not isinstance(value, int):
        raise InvalidInputError("Input must be an integer.")
    return value * 2

11. Teste o tratamento de exceções

• Escreva testes para garantir que o tratamento de exceções funcione conforme o esperado.
• Use estruturas como unittest ou pytest para testar casos normais e excepcionais.

def test_divide():
    assert divide(10, 2) == 5
    with pytest.raises(ZeroDivisionError):
        divide(10, 0)

12. Evite o uso excessivo de exceções

Use exceções para casos excepcionais:

• As exceções devem ser usadas para condições inesperadas, não como um mecanismo regular de fluxo de controle.
• Por exemplo, evite usar exceções para lidar com condições previsíveis, como o final de um loop.

# Bad practice: using exceptions for control flow
try:
    while True:
        value = next(iterator)
except StopIteration:
    pass  # End of iteration

13. Exceções de cadeia para contexto

• Python permite encadear exceções para preservar o contexto original ao gerar uma nova exceção.
• Use from para vincular exceções relacionadas.

try:
    result = process_input(input_value)
except InvalidInputError as e:
    raise ValueError("Failed to process input") from e

Seguindo essas práticas recomendadas, você pode escrever um código de tratamento de exceções mais robusto, fácil de manter e legível que gerencia erros com elegância e aumenta a confiabilidade do seu aplicativo.

Recursos

• Documentação oficial do Python sobre tratamento de exceções
• Documentação do módulo de registro do Python
• PEP 8 - Guia de estilo para código Python (para práticas gerais de codificação, incluindo exceções)
• Python real - Tratamento de exceções