Python de Cero a Pro - Cap. 16 - Procesamiento de Fechas

Serie: Arquitectura de Sistemas 🏗️

Este capítulo es el paso 2 de nuestra práctica secuencial.

Módulo de Persistencia JSON 🗄️
Módulo de Procesamiento de Fechas (Estás aquí) 📍
Módulo de Seguridad y Ofuscación 🛡️
Arquitectura de Modelos de Datos 🧩
Interfaz de Usuario TUI Profesional 🎮

Módulo de Procesamiento de Fechas (`date_parser.py`) 🗓️

Cuando un usuario escribe una fecha en una terminal, Python la recibe como un simple string (texto). Sin embargo, con texto no puedes hacer matemáticas: no puedes saber cuántos años han pasado ni si la fecha es válida. Usaremos el módulo datetime para convertir “letras” en objetos de tiempo.

El Código Completo

import datetime

# Definición global de formatos que permitiremos (Soportamos varios estilos)
DATE_FORMATS = (
    "%Y-%m-%d %H:%M:%S", # 1990-01-01 00:00:00 (Estándar ISO)
    "%Y/%m/%d %H:%M:%S", # 1995/12/03 00:31:56
    "%Y-%m-%d",          # 1990-01-01
    "%d/%m/%Y",          # 01/01/1990 (Latinoamérica)
    "%m-%d-%Y",          # 01-01-1990 (Estados Unidos)
    "%Y%m%d",            # 19900101   (Compacto)
)

def parse_date(date_str):
    """Convierte texto en un objeto datetime probando varios formatos."""
    try:
        # 1. Validación de Entrada: No podemos trabajar con algo que no sea texto
        if not date_str or not isinstance(date_str, str):
            print("=== Error: La fecha debe ser una cadena de texto ===")
            return None

        fecha_str = date_str.strip() # Limpiamos espacios accidentales
        if not fecha_str:
            print("=== Error: La fecha no puede estar vacía ===")
            return None

        # 2. El Ciclo de Intento: Probamos cada formato de la lista
        for formato in DATE_FORMATS:
            try:
                # strptime: String Parse Time (Texto a Fecha)
                fecha = datetime.datetime.strptime(fecha_str, formato)
                return fecha
            except ValueError:
                # Si este formato no funcionó, simplemente seguimos al siguiente
                continue

        # Si llegamos aquí, es que ningún formato funcionó
        print(f"=== Error: No se reconoció el formato de '{fecha_str}' ===")
        return None

    except Exception as e:
        print(f"=== Error inesperado al procesar fecha: {e} ===")
        return None

def parse_date_to_string(date):
    """Convierte un objeto datetime de vuelta a texto para guardarlo."""
    try:
        if not date or not isinstance(date, datetime.datetime):
            return "N/A"
        # strftime: String Format Time (Fecha a Texto)
        return date.strftime("%Y-%m-%d %H:%M:%S")
    except:
        return "N/A"

# --- Ejemplo de Ejecución Directa (Para Pruebas) ---
if __name__ == "__main__":
    print("--- Validador de Fechas Qué Pasa Linux ---")
    fecha_input = input("Introduce una fecha (ej: 01/01/1990): ")

    try:
        resultado = parse_date(fecha_input)
        if resultado:
            print(f"✅ Fecha válida interpretada: {resultado}")
            print(f"📅 Año: {resultado.year}, Mes: {resultado.month}, Día: {resultado.day}")
            # Probamos la conversión de vuelta a texto
            print(f"🔄 Texto formateado: {parse_date_to_string(resultado)}")
        else:
            print("⚠️ Formato no reconocido. Intenta con AAAA-MM-DD o DD/MM/AAAA.")
    except Exception as e:
        print(f"❌ Error al procesar la entrada: {e}")

🧠 Conceptos Detallados para Principiantes 🔍

1. ¿Qué es un “Objeto” de Fecha?

En Python, una “letra” es solo un dibujo. Un objeto de fecha es una estructura con “inteligencia”. Si tienes un objeto fecha, puedes hacer fecha.year y Python te dará solo el año, o fecha + 7 dias y te dará la fecha exacta de la próxima semana. ¡Eso es poder!

2. El Diccionario de Formatos (`%Y`, `%m`, `%d`)

Estos son códigos secretos para que Python aprenda a leer los textos:

%Y: Año con 4 dígitos (1995).
%m: Mes (01 al 12).
%d: Día (01 al 31).
%H, %M, %S: Horas, Minutos y Segundos.

3. `strptime` vs `strftime` (La Regla Mnemotécnica)

strptime: ¡Piensa en la ‘p’ de Parse! Significa convertir el texto sucio en una fecha limpia.
strftime: ¡Piensa en la ‘f’ de Format! Significa tomar la fecha limpia y ponerle un formato “bonito” para el humano.

4. La Lógica de Robustez

¿Por qué usamos un ciclo for? Porque los usuarios cometen errores. Si alguien escribe 01/01/90 o 1990-01-01, nuestro programa es lo suficientemente inteligente para entender ambos estilos sin cerrarse. Esto es lo que hace que tu software sea estable.

¿Por qué esto es vital para la Escalabilidad? 📈

Un sistema que no entiende el tiempo, no puede calcular intereses bancarios, no puede asegurar que un paciente es mayor de edad y no puede organizar eventos. Al separar esto en un módulo aparte, garantizas que todo tu sistema (desde Usuarios hasta Reservaciones) hable el mismo “idioma de tiempo”.

Ejercicios de Práctica 📝

Prueba formatos: Usa la función parse_date con la fecha de tu cumpleaños en diferentes formatos (con barras, con guiones, solo números) y observa cómo los reconoce.
Cálculo Simple: Intenta restar la fecha de hoy (datetime.datetime.now()) menos tu fecha de nacimiento parseada y observa los segundos de vida que tienes.
Manejo de Errores: Escribe una fecha que no exista (ej. 32/01/2024) y observa cómo el programa te avisa que el formato es incorrecto mediante el bloque try/except.

Siguiente: Módulo de Seguridad y Ofuscación