Cómo crear excepciones personalizadas en Python

Las clases de excepción integradas de Python no abordan ciertas situaciones de error que pueden surgir en su código. En tales casos, deberá crear excepciones personalizadas para manejar estos errores de manera efectiva.

En Python, puede definir excepciones personalizadas y generarlas cuando ocurren situaciones de error específicas. Puede gestionar errores informativos específicos con excepciones personalizadas, mejorando la legibilidad y el mantenimiento de su código.

¿Por qué necesita excepciones personalizadas?

Durante el desarrollo de una aplicación, pueden surgir varios escenarios de error debido a cambios en el código, integración con otros paquetes o bibliotecas e interacciones con aplicaciones externas. Es fundamental manejar estos errores para recuperarse de ellos o manejar las fallas con elegancia.

Python ofrece una gama de

excepción incorporada clases que cubren errores como Error de valor, Error de tecleado, Error de archivo no encontrado, y más. Si bien estas excepciones integradas cumplen bien su propósito, es posible que solo en ocasiones representen con precisión los errores que pueden ocurrir en su aplicación.

Al crear excepciones personalizadas, puede adaptarlas específicamente para que se ajusten a los requisitos de su aplicación y proporcionar información a los desarrolladores que utilizan su código.

Cómo definir excepciones personalizadas

Para crear excepciones personalizadas, definir una clase de Python que hereda de la Clase de excepción. El Excepción La clase ofrece la funcionalidad básica que necesitará para manejar excepciones y puede personalizarla para agregar funciones según sus necesidades específicas.

Al crear clases de excepción personalizadas, manténgalas simples e incluya los atributos necesarios para almacenar información de error. Los manejadores de excepciones pueden luego acceder a estos atributos para manejar los errores de manera adecuada.

Aquí hay una clase de excepción personalizada, Mi error personalizado:

classMyCustomError(Exception):
def__init__(self, message=None):
 self.message = message
 super().__init__(message)

Esta clase acepta un argumento de mensaje opcional durante la inicialización. Utiliza el súper() método para llamar al constructor de la base Excepción clase, que es esencial para el manejo de excepciones.

Cómo generar excepciones personalizadas

Para generar un error, utilice el aumentar palabra clave seguida de una instancia de su clase de excepción personalizada, pasándole un mensaje de error como argumento:

ifTrue:
raise MyCustomError("A Custom Error Was Raised...")

También puedes generar el error sin pasar ningún argumento:

ifTrue:
raise MyCustomError # shorthand

Cualquiera de los formatos es adecuado para generar errores personalizados.

Cómo manejar excepciones personalizadas

El manejo de excepciones personalizadas sigue el mismo enfoque que manejo de excepciones integradas. Usar intentar, excepto, y finalmente bloques para detectar excepciones personalizadas y tomar las medidas adecuadas.

try:
 print("Hello, You're learning how to MakeUseOf Custom Errors")
raise MyCustomError("Opps, Something Went Wrong...")
except MyCustomError as err:
 print(f"Error: {err}")
finally:
 print("Done Handling Custom Error")

De esta manera, puede manejar todas las formas de excepciones personalizadas planteadas.

Si ocurre una excepción durante la ejecución de un intentar bloque, un correspondiente excepto El bloque puede atraparlo y manipularlo. Si no hay apropiado excepto bloque para manejar la excepción, cualquier finalmente El bloque se ejecutará, seguido por la excepción que se genera nuevamente. Usar una finalmente bloquear principalmente para realizar tareas de limpieza que deben ejecutarse en cualquier circunstancia, ya sea que ocurra una excepción o no.

try:
raise KeyboardInterrupt
except MyCustomError as err:
 print(f"Error: {err}")
finally:
 print("Did not Handle the KeyboardInterrupt Error. \
Can Only Handle MyCustomError")

En esta muestra, un Interrupción del teclado ocurre una excepción, pero el excepto bloquear solo manijas Mi error personalizado excepciones. En este caso, el finalmente El bloque se ejecuta y luego se genera nuevamente la excepción no controlada.

Heredar clases de error personalizadas

Basado en el concepto de programación orientada a objetos (OOP), también puedes heredar de clases de excepción personalizadas, al igual que las clases normales. Al heredar de una clase de excepción personalizada, puede crear clases de error que proporcionen un contexto más específico a una excepción. Este enfoque le permite manejar errores en diferentes niveles de su código y proporciona una mejor comprensión de la causa del error.

Supongamos que está desarrollando una aplicación web que interactúa con una API externa. Esta API puede tener diferentes escenarios de error. Querrá manejar estos errores de manera consistente y clara en todo su código. Para lograr esto, cree una clase de excepción personalizada, Excepción API base:

classBaseAPIException(Exception):
Base class for API-related exceptions.
def__init__(self, message):
 super().__init__(message)
 self.message = message

Una vez que tenga esta clase de excepción personalizada base, puede crear clases de excepción secundarias que hereden de ella:

classAPINotFoundError(BaseAPIException):
Raised when the requested resource is not found in the API.
pass
classAPIAuthenticationError(BaseAPIException):
Raised when there's an issue with authentication to the API.
pass
classAPIRateLimitExceeded(BaseAPIException):
Raised when the rate limit for API requests is exceeded.
pass

Genere y detecte estas excepciones personalizadas al realizar llamadas a la API dentro de su aplicación web. Manéjelos en consecuencia utilizando la lógica adecuada en su código.

defrequest_api():
try:
# Simulate an API error for demonstration purposes
raise APINotFoundError("Requested resource not found.")
except APINotFoundError as err:
# Log or handle the 'Not Found' error case
 print(f"API Not Found Error: {err}")
except APIAuthenticationError:
# Take appropriate actions for authentication error
 print(f"API Authentication Error: {err}")
except APIRateLimitExceeded:
# Handle the rate limit exceeded scenario
 print(f"API Rate Limit Exceeded: {err}")
except BaseAPIException:
# Handle other unknown API exceptions
 print(f"Unknown API Exception: {err}")

La cláusula final de excepción se compara con la clase principal y actúa como un todo para cualquier otro error relacionado con la API.

Cuando heredas clases de excepción personalizadas, puedes manejar eficazmente los errores dentro de la API. Este enfoque le permite separar el manejo de errores de los detalles de implementación de la API. haciendo que sea más fácil agregar excepciones personalizadas o realizar cambios a medida que la API evoluciona o encuentra nuevos errores casos.

Envolver excepciones personalizadas

Envolver excepciones significa detectar una excepción, encapsularla dentro de una excepción personalizada y luego generar esa excepción personalizada mientras se hace referencia a la excepción original como su causa. Esta técnica ayuda a proporcionar contexto a los mensajes de error y mantiene los detalles de implementación ocultos del código de llamada.

Considere el escenario en el que su aplicación web interactúa con una API. Si la API genera un Error de búsqueda, puedes capturarlo y luego crear un personalizado APINotFoundError excepción que hace referencia a LookupError como su causa:

defrequest_api():
try:
# Simulate an API error for demonstration purposes
# Assuming the external API raised a LookupError
raise LookupError("Sorry, You Encountered A LookUpError !!!")
except LookupError as original_exception:
try:
# Wrap the original exception with a custom exception
raise APINotFoundError \
 ("Requested resource not found.") from original_exception
except APINotFoundError as wrapped_exception:
# Handle the wrapped exception here 
 print(f"Caught wrapped API exception: {wrapped_exception}")
# or re-raise it if necessary
raise
try:
 request_api()
except APINotFoundError as err:
 print(f"Caught API exception: {err.__cause__}")

Usar una de cláusula con la aumentar declaración para hacer referencia a la excepción original dentro de su excepción personalizada.

Cuando se produce la excepción personalizada, incluye la excepción original como __causa__ atributo, que proporciona un vínculo entre la excepción personalizada y el original. Esto le permite rastrear el origen de una excepción.

Al incluir excepciones, puede proporcionar un contexto más significativo y enviar mensajes de error más apropiados a los usuarios, sin revelar detalles de implementación interna de su código o la API. También le permite gestionar y abordar tipos de errores de forma estructurada y uniforme.

Personalizando el comportamiento de la clase en Python

Al heredar la clase de excepción base que proporciona Python, puede crear excepciones simples y útiles que puede generar cuando ocurren errores específicos en su código. También puedes implementar un comportamiento personalizado para tus clases de excepción con la ayuda de métodos mágicos o dunder.