Escribir código de manejo de excepciones eficaz es esencial para crear aplicaciones sólidas y fáciles de mantener.
A continuación se presentan algunas de las mejores prácticas para escribir código de manejo de excepciones en Python:

1. Capture sólo lo que pueda manejar

Sea específico:

• Capture excepciones específicas en lugar de utilizar una cláusula de excepción amplia.
• Esto garantiza que solo se detecten las excepciones que espera y sabe cómo manejar.

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

2. Evite las cláusulas desnudas excepto:

Capturar excepciones específicas:

• Evite usar excepto: sin especificar un tipo de excepción.
• Esto puede detectar errores inesperados y dificultar la depuración.

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

3. Utilice bloques try-except-else-finally

• Pruebe: coloque aquí el código que podría generar una excepción.
• excepto: Manejar excepciones en este bloque.
• else: Ejecute este bloque si no se generó ninguna excepción en el bloque try.
• finalmente: ejecute este bloque independientemente de si se generó una excepción, que a menudo se usa para limpieza.

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. Registrar excepciones

• Utilice el módulo de registro para registrar excepciones.
• El registro ayuda a diagnosticar problemas en producción sin revelar errores a los usuarios finales.

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. Volver a plantear excepciones cuando sea necesario

• Si detecta una excepción pero no puede manejarla por completo, considere volver a generarla para que pueda manejarse en otro lugar.

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

6. Utilice administradores de contexto para la gestión de recursos

• Utilice administradores de contexto (con declaración) para administrar recursos como archivos, sockets o conexiones de bases de datos.
• Esto garantiza que los recursos se liberen correctamente incluso si se genera una excepción.

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

7. Degradación elegante

-En lugar de permitir que su aplicación falle, proporcione mecanismos alternativos o mensajes de error fáciles de usar.

• Por ejemplo, si falta un archivo de configuración, puedes usar la configuración predeterminada.

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 las excepciones al tragar

• No detectes excepciones sin realizar ninguna acción.
• Ignorar las excepciones puede ocultar errores y hacer que la aplicación se comporte de manera impredecible.

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

9. Excepciones de documentos

• Utilice cadenas de documentación para documentar las excepciones que sus funciones pueden generar.
• Esto ayuda a otros desarrolladores a comprender qué excepciones esperar y cómo manejarlas.

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. Utilice excepciones personalizadas cuando sea apropiado

• Cree excepciones personalizadas para representar condiciones de error específicas en su aplicación.
• Esto puede hacer que su código sea más legible y más fácil de mantener.

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. Manejo de excepciones de prueba

• Escriba pruebas para garantizar que el manejo de excepciones funcione como se esperaba.
• Utilice marcos como unittest o pytest para probar casos normales y excepcionales.

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

12. Evite el uso excesivo de excepciones

Usar excepciones para casos excepcionales:

• Las excepciones deben usarse para condiciones inesperadas, no como un mecanismo de flujo de control regular.
• Por ejemplo, evite el uso de excepciones para manejar condiciones predecibles como el final de un bucle.

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

13. Excepciones en cadena por contexto

• Python le permite encadenar excepciones para preservar el contexto original al generar una nueva excepción.
• Utilice desde para vincular excepciones relacionadas.

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

Si sigue estas prácticas recomendadas, podrá escribir un código de manejo de excepciones más sólido, fácil de mantener y legible que administre los errores con elegancia y mejore la confiabilidad de su aplicación.

recursos

• Documentación oficial de Python sobre manejo de excepciones
• Documentación del módulo de registro de Python
• PEP 8 - Guía de estilo para código Python (para prácticas generales de codificación, incluidas excepciones)
• Python real: manejo de excepciones