Excepciones definidas por el usuario en Python con ejemplos

En este artículo, intentaremos cubrir cómo definir excepciones personalizadas en Python con ejemplos. 

Requisito previo: Este artículo es una extensión del Manejo de excepciones.

Ejemplo: 

class CustomError(Exception):
    pass

raise CustomError("Example of Custom Exceptions in Python")

Output: CustomError: Example of Custom Exceptions in Python

Python arroja errores y excepciones cuando hay un código que salió mal, lo que puede hacer que el programa se detenga abruptamente. Python también proporciona un método de manejo de excepciones con la ayuda de try-except. Algunas de las excepciones estándar que son más frecuentes incluyen IndexError, ImportError, IOError, ZeroDivisionError, TypeError y FileNotFoundError. Aquí, veremos la forma correcta de declarar excepciones personalizadas en Python moderno . Un usuario puede crear su propio error utilizando la clase de excepción.

Excepción definida por el usuario en Python

Los programadores pueden nombrar sus propias excepciones creando una nueva clase de excepción. Las excepciones deben derivarse de la clase Exception, ya sea directa o indirectamente. Aunque no es obligatorio, la mayoría de las excepciones se nombran como nombres que terminan en «Error» , de forma similar a la denominación de las excepciones estándar en python. Por ejemplo: 

# A python program to create user-defined exception
# class MyError is derived from super class Exception
class MyError(Exception):
 
    # Constructor or Initializer
    def __init__(self, value):
        self.value = value
 
    # __str__ is to print() the value
    def __str__(self):
        return(repr(self.value))
 
 
try:
    raise(MyError(3*2))
 
# Value of Exception is stored in error
except MyError as error:
    print('A New Exception occurred: ', error.value)

Producción

('A New Exception occurred: ', 6)

Personalización de clases de excepción

Para saber más sobre la excepción de clase, ejecute el siguiente código 

help(Exception)

Producción

Help on class Exception in module exceptions:

class Exception(BaseException)
 |  Common base class for all non-exit exceptions.
 |  
 |  Method resolution order:
 |      Exception
 |      BaseException
 |      __builtin__.object
 |  
 |  Methods defined here:
 |  
 |  __init__(...)
 |      x.__init__(...) initializes x; see help(type(x)) for signature
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __new__ = <built-in method __new__ of type object>
 |      T.__new__(S, ...) -> a new object with type S, a subtype of T
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from BaseException:
 |  
 |  __delattr__(...)
 |      x.__delattr__('name') <==> del x.name
 |  
 |  __getattribute__(...)
 |      x.__getattribute__('name') <==> x.name
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __getslice__(...)
 |      x.__getslice__(i, j) <==> x[i:j]
 |      
 |      Use of negative indices is not supported.
 |  
 |  __reduce__(...)
 |  
 |  __repr__(...)
 |      x.__repr__() <==> repr(x)
 |  
 |  __setattr__(...)
 |      x.__setattr__('name', value) <==> x.name = value
 |  
 |  __setstate__(...)
 |  
 |  __str__(...)
 |      x.__str__() <==> str(x)
 |  
 |  __unicode__(...)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from BaseException:
 |  
 |  __dict__
 |  
 |  args
 |  
 |  message

Ejemplo 1: Clase definida por el usuario con herencia múltiple

En el siguiente artículo, hemos creado una clase llamada «Error» derivada de la clase Exception. Esta clase base es heredada por varias clases definidas por el usuario para manejar diferentes tipos de python generar una excepción con el mensaje

# define Python user-defined exceptions
class Error(Exception):
    """Base class for other exceptions"""
    pass
 
class zerodivision(Error):
    """Raised when the input value is zero"""
    pass
 
try:
    i_num = int(input("Enter a number: "))
    if i_num == 0:
        raise zerodivision
except zerodivision:
    print("Input value is zero, try again!")
    print()

Producción

Enter a number: Input value is zero, try again!
()

Enter a number: Input value is zero, try again!

Ejemplo 2: Derivar el error de la excepción de superclase

Las excepciones de superclase se crean cuando un módulo necesita manejar varios errores distintos. Una de las formas comunes de hacer esto es crear una clase base para las excepciones definidas por ese módulo. Además, se definen varias subclases para crear clases de excepción específicas para diferentes condiciones de error.

# class Error is derived from super class Exception
class Error(Exception):
 
    # Error is derived class for Exception, but
    # Base class for exceptions in this module
    pass
 
class TransitionError(Error):
 
    # Raised when an operation attempts a state
    # transition that's not allowed.
    def __init__(self, prev, nex, msg):
        self.prev = prev
        self.next = nex
 
        # Error message thrown is saved in msg
        self.msg = msg
 
try:
    raise(TransitionError(2, 3*2, "Not Allowed"))
 
# Value of Exception is stored in error
except TransitionError as error:
    print('Exception occurred: ', error.msg)

Producción

('Exception occurred: ', 'Not Allowed')

¿Cómo usar Excepciones estándar como clase base?

Un error de tiempo de ejecución es una clase que es una excepción estándar que se genera cuando un error generado no pertenece a ninguna categoría. Este programa ilustra cómo utilizar el error de tiempo de ejecución como clase base y el error de red como clase derivada. De manera similar, se puede derivar una excepción de las excepciones estándar de Python.

# NetworkError has base RuntimeError
# and not Exception
class Networkerror(RuntimeError):
    def __init__(self, arg):
        self.args = arg
 
try:
    raise Networkerror("Error")
 
except Networkerror as e:
    print(e.args)

Producción

('E', 'r', 'r', 'o', 'r')