Módulo de Registro (logging)

El sistema de registro de Python permite generar mensajes de diagnóstico durante la ejecución. Los niveles de severidad se ordenan numéricamente, donde valores más altos indican mayor gravedad.

# Definición de niveles de severidad
NIVEL_CRITICO = 50
NIVEL_ERROR = 40
NIVEL_ADVERTENCIA = 30
NIVEL_INFORMATIVO = 20
NIVEL_DEPURACION = 10
NIVEL_NO_CONFIGURADO = 0

Por defecto, el módulo muestra mensajes de nivel ADVERTENCIA o superior en la consola. La configuración inicial se puede modificar usando basicConfig() con diferentes parámetros para personalizar el comportamiento.

import logging

# Configuración básica para escribir en archivo
logging.basicConfig(
    filename='registro_actividades.log',
    format='%(asctime)s - %(process)d - %(levelname)s - %(message)s',
    datefmt='%Y/%m/%d %H:%M:%S',
    level=logging.INFO
)

logging.info('Inicio del proceso de carga')
logging.error('Error en el módulo de validación')
logging.critical('Fallo en la conexión a base de datos')

Para configuraciones más avanzadas, se recomienda utilizar un diccionario de configuración que permita definir múltiples manejadores con formatos y niveles diferentes.

import logging.config

CONFIGURACION_REGISTRO = {
    'version': 1,
    'formateadores': {
        'detallado': {
            'format': '%(asctime)s [%(levelname)s] %(module)s:%(lineno)d - %(message)s'
        }
    },
    'manejadores': {
        'consola': {
            'clase': 'logging.StreamHandler',
            'nivel': 'DEBUG',
            'formateador': 'detallado'
        },
        'archivo': {
            'clase': 'logging.handlers.RotatingFileHandler',
            'nivel': 'WARNING',
            'filename': 'errores.log',
            'maxBytes': 10485760,  # 10 MB
            'backupCount': 5
        }
    },
    'raiz': {
        'nivel': 'DEBUG',
        'manejadores': ['consola', 'archivo']
    }
}

logging.config.dictConfig(CONFIGURACION_REGISTRO)

Módulo de Expresiones Regulares (re)

Las expresiones regulares proporcionan un mecanismo flexible para buscar y manipular patrones en texto. El módulo re implementa operaciones de coincidencia de patrones usando sintaxis estándar.

import re

texto_ejemplo = "La fecha actual es 2024-03-15 y la hora es 14:30"

# Buscar patrones de fecha
patron_fecha = r'\d{4}-\d{2}-\d{2}'
coincidencias = re.findall(patron_fecha, texto_ejemplo)
print(f"Fechas encontradas: {coincidencias}")  # ['2024-03-15']

# Validar formato de correo electrónico
correo = "usuario@ejemplo.com"
es_valido = bool(re.match(r'^[\w.-]+@[\w.-]+\.\w+$', correo))
print(f"Correo válido: {es_valido}")

Las banderas de compilación modifican el comportamiento de las expresiones. Por ejemplo, re.IGNORECASE hace que la búsqueda no distinga mayúsculas de minúsculas, mientras que re.DOTALL permite que el punto coincida con caracteres de nueva línea.

# Reemplazo de patrones en texto
texto_original = "Contactar a info@example.com o soporte@ejemplo.org"
texto_modificado = re.sub(r'@[\w.-]+', '@dominio-filtrado.com', texto_original)
print(texto_modificado)

# Dividir texto usando múltiples delimitadores
cadena_datos = "nombre:Juan;edad:30;ciudad:Madrid"
campos = re.split(r'[;:]', cadena_datos)
print(campos)  # ['nombre', 'Juan', 'edad', '30', 'ciudad', 'Madrid']

Módulos de Manejo del Tiempo (time y datetime)

Estos módulos proporcionan funcionalidades para manipular fechas, horas y realizar cálculos temporales. Las tres representaciones principales son marcas temporales (timestamp), objetos de fecha/hora y cadenas con formato.

import time
from datetime import datetime, timedelta

# Obtener marca temporal actual
marca_temporal = time.time()
print(f"Marca temporal: {marca_temporal}")

# Crear objeto datetime
ahora = datetime.now()
print(f"Fecha y hora actual: {ahora}")

# Operaciones con timedelta
hace_una_semana = ahora - timedelta(weeks=1)
en_tres_horas = ahora + timedelta(hours=3)
print(f"Hace una semana: {hace_una_semana}")
print(f"En tres horas: {en_tres_horas}")

La conversión entre formatos se realiza mediante métodos específicos. Las cadenas de formato utilizan directivas que representan componentes temporales como año (%Y), mes (%m), día (%d), hora (%H), minuto (%M) y segundo (%S).

# Formatear fecha como cadena
formato_personalizado = ahora.strftime("%d/%m/%Y %H:%M:%S")
print(f"Formato personalizado: {formato_personalizado}")

# Convertir cadena a objeto datetime
cadena_fecha = "2024/03/15 09:30:00"
fecha_objeto = datetime.strptime(cadena_fecha, "%Y/%m/%d %H:%M:%S")
print(f"Fecha convertida: {fecha_objeto}")

# Calcular diferencia entre fechas
fecha_inicio = datetime(2024, 1, 1)
diferencia = ahora - fecha_inicio
print(f"Días transcurridos: {diferencia.days}")

Módulo de Números Aleatorios (random)

El módulo random implementa generadores de números pseudoaleatorios para diversas distribuciones. Es fundamental para aplicaciones como simulaciones, juegos y procesamiento estocástico.

import random

# Generar números en diferentes rangos
decimal_aleatorio = random.random()  # [0.0, 1.0)
entero_en_rango = random.randint(1, 100)  # [1, 100]
seleccion_lista = random.choice(['A', 'B', 'C', 'D'])

# Generar secuencias aleatorias
muestra = random.sample(range(1000), 10)  # 10 elementos únicos
lista_original = [1, 2, 3, 4, 5]
random.shuffle(lista_original)  # Reordenar in-place
print(f"Lista mezclada: {lista_original}")

Para aplicaciones que requieren reproducibilidad, se puede establecer una semilla con random.seed(). Esto garantiza que la misma secuencia de números se genere en ejecuciones diferentes.

# Función para generar código de verificación
def generar_codigo_verificacion(longitud=8):
    caracteres = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"
    semilla = random.Random(42)  # Generador con semilla fija
    codigo = ''.join(semilla.choice(caracteres) for _ in range(longitud))
    return codigo

print(f"Código de verificación: {generar_codigo_verificacion()}")

Módulo del Sistema Operativo (os)

El módulo os proporciona una interfaz portable para funcionalidades dependientes del sistema operativo. Permite interactuar con el sistema de archivos, variables de entorno y procesos.

import os

# Navegación en el sistema de archivos
directorio_actual = os.getcwd()
print(f"Directorio actual: {directorio_actual}")

# Listar contenido de directorios
contenido = os.listdir('.')
print(f"Archivos y carpetas: {contenido}")

# Crear y eliminar directorios
os.makedirs('nuevo/subdirectorio', exist_ok=True)
os.rmdir('nuevo/subdirectorio')

El submódulo os.path ofrece operaciones específicas para rutas de archivos, incluyendo unión, división y verificación de existencia.

# Operaciones con rutas
ruta_completa = os.path.join('/home', 'usuario', 'documentos', 'archivo.txt')
directorio, nombre_archivo = os.path.split(ruta_completa)
extension = os.path.splitext(nombre_archivo)[1]

# Verificaciones de rutas
print(f"Ruta absoluta: {os.path.abspath('.')}") 
print(f"¿Es archivo? {os.path.isfile('ejemplo.py')}")
print(f"Espacio usado: {os.path.getsize('ejemplo.py')} bytes")

Módulo de Utilidades del Sistema (sys)

El módulo sys proporciona acceso a variables y funciones que interactúa con el intérprete de Python. Es esencial para configurar el entorno de ejecución y manejar argumentos de línea de comandos.

import sys

# Acceder a argumentos de línea de comandos
argumentos = sys.argv
script = argumentos[0] if argumentos else "script_desconocido"

# Información del intérprete
version_python = sys.version
ruta_modulos = sys.path
print(f"Python {version_python}")
print(f"Rutas de módulos: {ruta_modulos[:3]}...")

# Salida controlada
sys.exit(0)  # Terminación exitosa

Para aplicaciones con progreso visible, se pueden implementar barras de progreso usando caracteres de control como \r para actualizar la misma línea.

def mostrar_progreso(porcentaje, ancho=50):
    completado = int(ancho * porcentaje)
    barra = '[' + '#' * completado + '-' * (ancho - completado) + ']'
    sys.stdout.write(f"\r{barra} {porcentaje*100:.1f}%")
    sys.stdout.flush()

# Simulación de progreso
for i in range(101):
    mostrar_progreso(i/100)
    time.sleep(0.05)
print()  # Nueva línea al finalizar

Módulo de Operaciones de Alto Nivel (shutil)

El módulo shutil ofrece operaciones de alto nivel para copiar, mover y eliminar archivos y árboles de directorios. Proporciona funcionalidades que el módulo os no ofrece de manera directa.

import shutil
import os

# Operaciones con archivos
origen = 'documento_original.txt'
destino = 'copia_seguridad.txt'
shutil.copy2(origen, destino)  # Copia con metadatos

# Mover archivos
shutil.move('temp/archivo.log', 'logs/archivo.log')

# Eliminar directorios recursivamente
directorio_temp = '/tmp/archivos_temporales'
if os.path.exists(directorio_temp):
    shutil.rmtree(directorio_temp)

Para crear archivos comprimidos, shutil proporciona funciones que abstraen las diferencias entre formatos como ZIP, TAR y GZIP.

# Crear archivo comprimido
archivos_a_comprimir = ['datos.csv', 'config.json']
shutil.make_archive(
    'backup_2024',
    'zip',
    root_dir='/proyecto/datos',
    base_dir='.'
)

# Extraer archivo comprimido
shutil.unpack_archive('backup_2024.zip', '/restauracion')

Módulos de Serialización (json y pickle)

La serialización convierte objetos de Python en formatos almacenables o transmisibles. JSON es ideal para intercambio de datos entre sistemas heterogéneos, mientras que pickle es específico de Python.

import json
import pickle

# Serialización con JSON
datos_configuracion = {
    'servidor': '192.168.1.100',
    'puerto': 8080,
    'activar_ssl': True
}

# Guardar en archivo JSON
with open('config.json', 'w') as archivo_json:
    json.dump(datos_configuracion, archivo_json, indent=2)

# Cargar desde archivo JSON
with open('config.json', 'r') as archivo_json:
    config_cargada = json.load(archivo_json)

Pickle maneja tipos de datos nativos de Python, incluyendo funciones y clases, pero tiene implicaciones de seguridad ya que puede ejecutar código arbitrario durante la deserialización.

# Serialización con pickle
objeto_complejo = {
    'lista': [1, 2, 3],
    'funcion': lambda x: x ** 2,
    'fecha': datetime.now()
}

# Guardar estado de aplicación
with open('estado.pkl', 'wb') as archivo_pkl:
    pickle.dump(objeto_complejo, archivo_pkl)

# Cargar estado
with open('estado.pkl', 'rb') as archivo_pkl:
    estado_restaurado = pickle.load(archivo_pkl)

Módulo de Configuración (configparser)

El módulo configparser permite trabajar con archivos de configuración en formato INI. Es comúnmente utilizado para almacenar parámetros de aplicaciones y configuraciones de usuario.

import configparser

# Crear archivo de configuración
config = configparser.ConfigParser()
config['BASE_DATOS'] = {
    'host': 'localhost',
    'puerto': '5432',
    'nombre': 'aplicacion_db',
    'usuario': 'admin'
}

config['SERVIDOR'] = {
    'ip': '0.0.0.0',
    'puerto': '8080',
    'debug': 'True'
}

# Guardar configuración
with open('aplicacion.ini', 'w') as configfile:
    config.write(configfile)

# Leer configuración
config_lectura = configparser.ConfigParser()
config_lectura.read('aplicacion.ini')

# Acceder a valores
host_db = config_lectura.get('BASE_DATOS', 'host')
debug = config_lectura.getboolean('SERVIDOR', 'debug')

Módulo de Hashing (hashlib)

El módulo hashlib implementa algoritmos hash seguros para calcular resúmenes de mensajes. Estos algoritmos generan una huella digital única para datos de cualquier tamaño.

import hashlib

# Calcular hash de texto
texto = "Datos importantes para verificar"
hash_sha256 = hashlib.sha256(texto.encode('utf-8')).hexdigest()
print(f"SHA-256: {hash_sha256}")

# Verificar integridad de archivos
def calcular_hash_archivo(ruta_algoritmo='sha256'):
    hasher = hashlib.new(ruta_algoritmo)
    with open('documento.txt', 'rb') as archivo:
        for bloque in iter(lambda: archivo.read(4096), b""):
            hasher.update(bloque)
    return hasher.hexdigest()

# Uso con sal para mayor seguridad
password = "contraseña_segura123"
salt = os.urandom(32)
hash_password = hashlib.pbkdf2_hmac('sha256', password.encode(), salt, 100000)

Módulo de Subprocesos (subprocess)

El módulo subprocess permite ejecutar nuevos procesos, conectarse a sus canales de entrada/salida/error y obtener sus códigos de retorno. Proporciona un reemplazo seguro para funciones como os.system().

import subprocess

# Ejecutar comando simple
resultado = subprocess.run(['ls', '-l'], capture_output=True, text=True)
print(f"Salida estándar:\n{resultado.stdout}")

# Ejecutar con pipeline
comando = "cat archivo.log | grep 'ERROR' | wc -l"
proceso = subprocess.Popen(comando, shell=True, stdout=subprocess.PIPE)
salida, _ = proceso.communicate()
print(f"Número de errores: {salida.decode().strip()}")

Módulo de Procesamiento XML (xml.etree.ElementTree)

El módulo ElementTree proporciona una API simple y eficiente para procesar documentos XML. Permite navegar, buscar y modificar la estructura del árbol XML.

import xml.etree.ElementTree as ET

# Parsear documento XML
arbol = ET.parse('configuracion.xml')
raiz = arbol.getroot()

# Recorrer elementos
for elemento in raiz:
    print(f"Etiqueta: {elemento.tag}")
    for hijo in elemento:
        print(f"  {hijo.tag}: {hijo.text}")

# Buscar elementos específicos
servidores = raiz.findall('.//servidor[@activo="true"]')
for servidor in servidores:
    nombre = servidor.find('nombre').text
    direccion = servidor.find('direccion').text
    print(f"Servidor activo: {nombre} ({direccion})")

# Modificar documento
for servidor in raiz.iter('servidor'):
    puerto = servidor.find('puerto')
    if puerto is not None:
        puerto.text = str(int(puerto.text) + 100)

# Guardar cambios
arbol.write('configuracion_actualizada.xml')