POO: Excepciones en Python
Las excepciones en Python son un mecanismo para manejar errores y otros eventos inesperados que pueden ocurrir durante la ejecución de un programa. En la programación orientada a objetos (POO), las excepciones permiten que los objetos manejen errores de manera más estructurada y controlada
Teoría Básica de Excepciones Clásicas
Una excepción es un evento que interrumpe el flujo normal de un programa. Esto puede ocurrir debido a errores como:
- Intentar dividir entre cero.
- Acceder a un índice fuera de rango en una lista.
- Operar sobre un archivo que no existe.
En Python, las excepciones son objetos derivados de la clase base BaseException, lo que refuerza su integración con la POO.
Las excepciones pueden ser manejadas utilizando bloques try, except, else y finally. A continuación, se explica cada uno de estos bloques con un ejemplo:
-
try: Este bloque contiene el código que puede generar una excepción. -
except: Este bloque maneja la excepción que se genera en el bloquetry. Puedes tener múltiples bloquesexceptpara manejar diferentes tipos de excepciones. -
else: Este bloque se ejecuta si no se genera ninguna excepción en el bloquetry. -
finally: Este bloque se ejecuta siempre, independientemente de si se generó una excepción o no.
Ejemplo que ilustra el uso de estos bloques:
def dividir_numeros(a, b):
try:
# Intentamos dividir a entre b
resultado = a / b
except ZeroDivisionError as e:
# Manejamos la excepción de división por cero
print(f"Error: {e}")
return None
except TypeError as e:
# Manejamos la excepción de tipo incorrecto
print(f"Error: {e}")
return None
else:
# Este bloque se ejecuta si no hay excepciones
print("La división se realizó con éxito.")
return resultado
finally:
# Este bloque se ejecuta siempre
print("Ejecución del bloque finally.")
# Ejemplos de uso
print(dividir_numeros(10, 2)) # Debería imprimir "La división se realizó con éxito." y luego "Ejecución del bloque finally."
print(dividir_numeros(10, 0)) # Debería imprimir "Error: division by zero" y luego "Ejecución del bloque finally."
print(dividir_numeros(10, 'a')) # Debería imprimir "Error: unsupported operand type(s) for /: 'int' and 'str'" y luego "Ejecución del bloque finally."
Las Excepciones Son Clases
Jerarquía de Excepciones
Las excepciones en Python son implementadas como clases, y todas las excepciones derivan de la clase base BaseException. La mayoría de las excepciones que se encuentran en el uso diario derivan de la clase Exception, que a su vez es una subclase de BaseException.
Aquí hay una vista general de la jerarquía de excepciones en Python:
BaseException
├── Exception
│ ├── ArithmeticError
│ │ ├── FloatingPointError
│ │ ├── OverflowError
│ │ └── ZeroDivisionError
│ ├── AssertionError
│ ├── AttributeError
│ ├── BufferError
│ ├── EOFError
│ ├── ImportError
│ │ └── ModuleNotFoundError
│ ├── LookupError
│ │ ├── IndexError
│ │ └── KeyError
│ ├── MemoryError
│ ├── NameError
│ │ └── UnboundLocalError
│ ├── OSError
│ │ ├── BlockingIOError
│ │ ├── ChildProcessError
│ │ ├── ConnectionError
│ │ │ ├── BrokenPipeError
│ │ │ ├── ConnectionAbortedError
│ │ │ ├── ConnectionRefusedError
│ │ │ └── ConnectionResetError
│ │ ├── FileExistsError
│ │ ├── FileNotFoundError
│ │ ├── IsADirectoryError
│ │ ├── NotADirectoryError
│ │ ├── InterruptedError
│ │ ├── PermissionError
│ │ ├── ProcessLookupError
│ │ └── TimeoutError
│ ├── ReferenceError
│ ├── RuntimeError
│ │ ├── NotImplementedError
│ │ └── RecursionError
│ ├── StopIteration
│ ├── StopAsyncIteration
│ ├── SyntaxError
│ │ └── IndentationError
│ │ └── TabError
│ ├── SystemError
│ ├── TypeError
│ ├── ValueError
│ │ └── UnicodeError
│ │ ├── UnicodeDecodeError
│ │ ├── UnicodeEncodeError
│ │ └── UnicodeTranslateError
│ └── Warning
│ └── DeprecationWarning
│ └── PendingDeprecationWarning
│ └── RuntimeWarning
│ └── SyntaxWarning
│ └── UserWarning
│ └── FutureWarning
│ └── ImportWarning
│ └── UnicodeWarning
│ └── BytesWarning
│ └── ResourceWarning
├── GeneratorExit
├── KeyboardInterrupt
├── SystemExit
Acceso a Atributos en Excepciones
En Python, la palabra clave as se utiliza en el contexto de manejo de excepciones para asignar una excepción capturada a una variable. Esto permite acceder a la información de la excepción, como su mensaje de error y otros atributos, dentro del bloque except.
Sintaxis Básica:
try:
# Código que puede generar una excepción
except ExceptionType as variable:
# Manejo de la excepción utilizando la variable
Ejemplo básico:
try:
resultado = 10 / 0 # Esto genera un ZeroDivisionError
except ZeroDivisionError as e:
print(f"Ha ocurrido un error: {e}")
# Salida: Ha ocurrido un error: division by zero
Desglose del código:
-
try: Se intenta ejecutar el código que podría generar un error. -
except ZeroDivisionError as e:- Captura la excepción del tipo
ZeroDivisionError. - Asigna la instancia de la excepción capturada a la variable
e.
- Captura la excepción del tipo
-
e: Es una instancia deZeroDivisionErrory contiene información adicional sobre el error, como el mensaje de error.
Acceso a Otros Atributos de la Excepción
Algunas excepciones tienen atributos adicionales que puedes acceder. Por ejemplo, la excepción OSError tiene un atributo errno que contiene el número de error del sistema operativo:
try:
with open('archivo_inexistente.txt', 'r') as file:
contenido = file.read()
except FileNotFoundError as e:
print(f"Error al abrir el archivo: {e}")
print(f"Número de error: {e.errno}")
Cómo Crear una Excepción Propia
Para crear una excepción propia en Python, se debe definir una nueva clase que herede de la clase base Exception. Esta clase personalizada puede incluir métodos y atributos adicionales según sea necesario. A continuación, se presenta un ejemplo de cómo redactar una excepción propia en tercera persona.
Primero, se define la clase de la excepción personalizada. En este ejemplo, se creará una excepción llamada MiExcepcionPersonalizada:
# Definición de la excepción personalizada
class MiExcepcionPersonalizada(Exception):
"""
Esta clase representa una excepción personalizada que se puede lanzar
cuando ocurre un error específico en el programa.
"""
def __init__(self, mensaje):
"""
Inicializa la excepción con un mensaje descriptivo del error.
:param mensaje: Un mensaje descriptivo del error.
"""
super().__init__(mensaje)
# Función que puede lanzar la excepción personalizada
def funcion_que_puede_fallar(condicion):
"""
Esta función lanza una excepción personalizada si se cumple una condición específica.
:param condicion: Una condición booleana que determina si se lanza la excepción.
:raises MiExcepcionPersonalizada: Si la condición es verdadera.
"""
if condicion:
raise MiExcepcionPersonalizada("Ha ocurrido un error específico.")
# Uso de la excepción personalizada en un bloque try-except
try:
funcion_que_puede_fallar(True)
except MiExcepcionPersonalizada as e:
print(f"Se ha capturado una excepción: {e}")
En este ejemplo:
- Definición de la Excepción Personalizada:
- Se define una clase
MiExcepcionPersonalizadaque hereda de Exception. - El método
__init__se utiliza para inicializar la excepción con un mensaje descriptivo.
- Se define una clase
- Función que Puede Fallar:
- Se define una función
funcion_que_puede_fallarque toma una condición booleana como argumento. - Si la condición es verdadera, la función lanza la excepción personalizada con un mensaje específico.
- Se define una función
- Uso de la Excepción Personalizada:
- Se utiliza un bloque
try-except para llamar a la funciónfuncion_que_puede_fallarcon una condición verdadera. - Si la excepción personalizada es lanzada, se captura y se imprime un mensaje indicando que se ha capturado la excepción.
- Se utiliza un bloque