Las excepciones definidas por el usuario se crean definiendo una nueva clase que hereda de Excepción incorporada de Python clase o una de sus subclases. Al hacer esto, podemos crear mensajes de error personalizados y manejar errores específicos de una manera que tenga sentido para nuestra aplicación.

Pasos para crear y utilizar excepciones definidas por el usuario

Siga estos pasos para crear y utilizar excepciones definidas por el usuario en Python:

• Defina una nueva clase de excepción: Cree una nueva clase que herede de Exception o cualquiera de sus subclases.
• Plantear la excepción: Utilice la declaración de aumento para generar la excepción definida por el usuario cuando ocurre una condición específica.
• Manejar la excepción: Utilice bloques try-except para manejar la excepción definida por el usuario.

Ejemplo: En este ejemplo, creamos una excepción personalizada InvalidAgeError para garantizar que los valores de edad se encuentren dentro de un rango válido (0–120).

# Step 1: Define a custom exception class class InvalidAgeError(Exception): def __init__(self age msg='Age must be between 0 and 120'): self.age = age self.msg = msg super().__init__(self.msg) def __str__(self): return f'{self.age} -> {self.msg}' # Step 2: Use the custom exception in your code def set_age(age): if age < 0 or age > 120: raise InvalidAgeError(age) else: print(f'Age set to: {age}') # Step 3: Handling the custom exception try: set_age(150) # This will raise the custom exception except InvalidAgeError as e: print(e) 

150 -> Age must be between 0 and 120 

Explicación:

• La clase InvalidAgeError hereda de Exception. Define un __caliente__ Método para aceptar edad y mensaje.
• El método __str__ devuelve una representación de cadena legible del error.
• En set_age(), si la edad está fuera del rango válido (0–120), se genera la excepción.
• El bloque try-except detecta la excepción e imprime el mensaje de error.

Personalización de clases de excepción

Cuando creamos una excepción personalizada, subclasificamos la clase Exception incorporada de Python (o una subclase como ValueError TypeError, etc.). Luego podemos agregar nuestros propios métodos de atributos o lógica personalizada para que nuestra excepción sea más informativa.

También podemos mejorar las excepciones personalizadas agregando atributos adicionales o anulando métodos.

comando de creación de linux

Ejemplo: Aquí mejoramos InvalidAgeError agregando un código de error y personalizando el mensaje de error.

class InvalidAgeError(Exception): def __init__(self age msg='Age must be between 0 and 120' error_code=1001): self.age = age self.msg = msg self.error_code = error_code super().__init__(self.msg) def __str__(self): return f'[Error Code {self.error_code}] {self.age} -> {self.msg}' try: set_age(150) # This will raise the custom exception except InvalidAgeError as e: print(e) 

[Error Code 1001] 150 -> Age must be between 0 and 120 

Explicación:

• InvalidAgeError ahora tiene un atributo adicional código_error.
• El método __str__ se anula para mostrar tanto el código de error como la edad.
• Cuando se ejecuta set_age(150), la excepción se genera y se captura en el bloque try-except.
• El mensaje de error personalizado se imprime haciendo que el error sea más descriptivo.

Usar excepciones estándar como clase base

A veces, en lugar de heredar directamente de Exception, podemos crear una excepción personalizada subclasificando una excepción estándar como RuntimeError ValueError, etc. Esto es útil cuando su excepción personalizada debe tratarse como un tipo específico de error.

Ejemplo: Este ejemplo muestra cómo crear una excepción personalizada NetworkError heredando de RuntimeError, que es una excepción estándar incorporada.

# NetworkError has base RuntimeError and not Exception class NetworkError(RuntimeError): def __init__(self arg): self.args = (arg) # store as tuple try: raise NetworkError('Connection failed') except NetworkError as e: print(e.args) 

('Connection failed') 

Explicación:

• NetworkError hereda de RuntimeError, que es un tipo de excepción integrado.
• Cuando se genera, el mensaje se almacena en el atributo args como una tupla.
• Se detecta la excepción y se muestran sus argumentos almacenados.

Ejemplo del mundo real: error de correo electrónico no válido

A continuación se muestra un ejemplo sencillo en el que generamos una excepción personalizada si la dirección de correo electrónico no es válida:

class InvalidEmailError(Exception): def __init__(self email msg='Invalid email format'): self.email = email self.msg = msg super().__init__(self.msg) def __str__(self): return f'{self.email} -> {self.msg}' def set_email(email): if '@' not in email: raise InvalidEmailError(email) print(f'Email set to: {email}') try: set_email('userexample.com') except InvalidEmailError as e: print(e) 

userexample.com -> Invalid email format 

Explicación:

• Se define una nueva clase de excepción InvalidEmailError para validar direcciones de correo electrónico.
• Si el correo electrónico proporcionado no contiene '@', se genera la excepción.
• El bloque try-except detecta el error e imprime el mensaje formateado.

¿Cuándo utilizar excepciones definidas por el usuario?

Las excepciones definidas por el usuario se deben considerar en los siguientes escenarios:

• Representar errores específicos en una aplicación (por ejemplo, InvalidAgeError DatabaseConnectionError).
• Proporcionar mensajes de error más claros y descriptivos.
• Manejar un grupo de errores relacionados por separado usando excepto.

Al utilizar excepciones definidas por el usuario, los programas se vuelven más legibles, fáciles de mantener y más fáciles de depurar.