Cuando ocurre un error durante la ejecución de un programa, el intérprete puede detenerse y mostrar un mensaje de error. Esto se conoce como una excepción. Python ofrece mecainsmos robustos para detectar y manejar estos errores, permitiendo depurar y controlar el flujo de ejecución.

Tipos Comunes de Excepciones en Python

¿Qué es una Excepción?

• Una excepción es un evento que ocurre durante la ejecución de un programa y que altera su flujo normal.
• Ocurren cuando Python no puede procesar una instrucción correctamente.
• Son objetos en Python que representan errores.
• Si no se capturan, las excepciones provocan la terminación del programa.

Manejo de Excepciones con try/except

El bloque try permite ejecutar código que podría generar una excepción. Si ocurre un error, el bloque except correspondiente se ejecuta para manejarlo.

try:
    # Código que podría generar un error
    pass
except TipoDeError:
    # Código a ejecutar si ocurre el error especificado
    pass

Ejemplo Rápido

try:
    print(variable_no_definida)
except NameError:
    print("Se ha producido un error: la variable no está definida.")

Nota: Si el tipo de excepción que ocurre no coincide con el tipo especificado en el bloque except, la excepción no será capturada y el programa podría terminar.

Captura de Múltiples Excepciones

Se pueden capturar varios tipos de excepciones especificándolos en una tupla:

try:
     resultado = 1 / 0
except (NameError, ZeroDivisionError):
     print("Se ha producido un error de nombre o división por cero.")

Bloque else en try/except

El bloque else se ejecuta si el código dentro del bloque try se completa sin generar ninguna excepción.

try:
    resultado = 10 + 5
except TypeError:
    print("Error de tipo.")
else:
    print(f"La operación se completó con éxito. Resultado: {resultado}")

Bloque finally en try/except

El bloque finally se ejecuta siempre, independientemente de si ocurrió una excepción o no. Es útil para tareas de limpieza, como cerrar archivos.

archivo = None
try:
    archivo = open("mi_archivo.txt", "r")
    print("Archivo abierto para lectura.")
    # Realizar operaciones con el archivo
except FileNotFoundError:
    print("El archivo no se encontró. Creando uno nuevo.")
    archivo = open("mi_archivo.txt", "w")
finally:
    if archivo:
        archivo.close()
        print("El archivo se ha cerrado.")

Creación de Excepciones Personalizadas

Es posible definir tus propias clases de excepción. Estas deben heredar de la clase base Exception e idealmente implementar los métodos __init__ y __str__ para proporcionar detalles sobre el error.

Para lanzar una excepción personalizada, se utiliza la palabra clave raise seguida de una instancia de la clase de excepción.

Ejemplo: Validación de Contraseña

Requerimiento: Lanzar una excepción si la contraseña ingresada tiene menos de 6 craacteres.

class PasswordError(Exception):
    def __init__(self, password_length, min_length):
        self.password_length = password_length
        self.min_length = min_length

    def __str__(self):
        return (f"La contraseña ingresada tiene {self.password_length} caracteres, "
                f"pero debe tener al menos {self.min_length} caracteres.")

def crear_contrasena():
    try:
        contrasena = input("Por favor, ingrese una contraseña (mínimo 6 caracteres): ")
        if len(contrasena) < 6:
            raise PasswordError(len(contrasena), 6)
        else:
            print("Contraseña creada exitosamente.")
    except PasswordError as e:
        print(f"Error: {e}")
    except Exception as e:
        print(f"Ocurrió un error inesperado: {e}")

crear_contrasena()

Módulos en Python

Un módulo es simplemente un archivo Python que contiene definiciones y sentencias. Permite organizar el código y reutilizarlo.

Formas de Importar Módulos

• import nombre_modulo: Importa el módulo completo. Acceso a sus miembros: nombre_modulo.miembro.
• from nombre_modulo import miembro: Importa un miembro específico del módulo. Acceso directo: miembro.
• from nombre_modulo import *: Importa todos los miembros públicos del módulo (usar con precaución).
• import nombre_modulo as alias: Importa el módulo con un nombre abreviado (alias).
• from nombre_modulo import miembro as alias: Importa un miembro con un alias.

Módulo time

Proporciona funciones relacionadas con el tiempo.

Obtener la Hora Actual

import time

# Obtiene la hora actual como una tupla de tiempo
tiempo_actual_struct = time.localtime(time.time())
print(tiempo_actual_struct)
# Ejemplo de salida: time.struct_time(tm_year=2023, tm_mon=10, tm_mday=27, tm_hour=10, tm_min=30, tm_sec=0, tm_wday=4, tm_yday=300, tm_isdst=0)

Obtener Tiempo Formateado

import time

# Obtiene la hora actual como una cadena legible
tiempo_actual_legible = time.asctime(time.localtime(time.time()))
print(tiempo_actual_legible)
# Ejemplo de salida: 'Fri Oct 27 10:30:00 2023'

# Formatea la hora actual a un formato específico
tiempo_formateado = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
print(tiempo_formateado)
# Ejemplo de salida: '2023-10-27 10:30:00'

Símbolos de Formato de Fecha y Hora

• Año: %y (dos dígitos), %Y (cuatro dígitos)
• Mes: %m (01-12)
• Día: %d (01-31)
• Hora: %H (formato 24h, 00-23), %I (formato 12h, 01-12)
• Minuto: %M (00-59)
• Segundo: %S (00-59)

Módulo calendar

Ofrece funciones para generar calendarios.

Obtener el Calendario Mensual

import calendar

# Obtiene el calendario del mes de Septiembre de 2022
calendario_mes = calendar.month(2022, 9)
print(calendario_mes)

Creación de Módulos Propios

Cualquier archivo Python (.py) puede ser un módulo. El nombre del módulo es el nombre del archivo sin la extensión.

Archivo mi_modulo_demo.py

# -*- coding:utf-8 -*-

def sumar(a, b):
    print(f"La suma de {a} y {b} es: {a + b}")

class Calculadora:
    def __init__(self, a, b):
        self.a = a
        self.b = b

    def mostrar_suma(self):
        print(f"Suma de instancia: {self.a + self.b}")

# Ejemplo de __all__ para controlar la importación con 'from ... import *'
__all__ = ['sumar']

def funcion_privada_demo():
    print("Esta función no se importará con '*'.")

Uso de Módulos

# Importar el módulo completo
import mi_modulo_demo
mi_modulo_demo.sumar(5, 3)
calc = mi_modulo_demo.Calculadora(10, 20)
calc.mostrar_suma()

# Importar un miembro específico
from mi_modulo_demo import sumar
sumar(7, 2)

# Importar todos los miembros (usando __all__)
from mi_modulo_demo import *
sumar(9, 1)
# funcion_privada_demo() # Esto daría NameError si no está en __all__

Creación de Paquetes

Un paquete es una colección de módulos relacionados organizados en una estructura de directorios. Para que un directorio sea considerado un paquete, debe contener un archivo __init__.py (puede estar vacío).

Estructura de un Paquete

mi_paquete/
├── __init__.py
├── modulo_uno.py
└── modulo_dos.py

Importar desde un Paquete

# Método 1: Importar un módulo específico del paquete
import mi_paquete.modulo_uno
mi_paquete.modulo_uno.funcion_del_modulo_uno()

# Método 2: Importar un miembro específico del módulo
from mi_paquete.modulo_uno import funcion_del_modulo_uno
funcion_del_modulo_uno()

# Método 3: Importar todo desde el paquete (requiere __all__ en __init__.py)
# Contenido de mi_paquete/__init__.py:
# __all__ = ['modulo_uno', 'modulo_dos']

from mi_paquete import *
modulo_uno.otra_funcion() # Asumiendo que modulo_uno está en __all__

El bloque if __name__ == "__main__": se utiliza para asegurar que cierto código solo se ejecute cuando el script es ejecutado directamente, y no cuando es importado como módulo.