Python Experto: Técnicas Avanzadas y Metaprogramación

¡Bienvenido al nivel experto de Python! Este tutorial explora características avanzadas que te convertirán en un maestro del lenguaje. Prepárate para sumergirte en conceptos poderosos que harán tu código más elegante y eficiente.

1. Context Managers Personalizados

¡Descubre el poder de los context managers personalizados! Más allá del simple with para archivos, puedes crear tus propios gestores de contexto que controlan recursos de manera elegante y automática.

class TimerContext:
    """Context manager personalizado para medir tiempo de ejecución."""
    def __enter__(self):
        import time
        self.start_time = time.time()
        print("Iniciando temporizador...")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        import time
        self.end_time = time.time()
        self.elapsed = self.end_time - self.start_time
        print(f"Tiempo transcurrido: {self.elapsed:.4f} segundos")
        # Si retornamos True, cualquier excepción será suprimida
        return False

# Uso del context manager personalizado
with TimerContext():
    # Código cuyo tiempo queremos medir
    sumatoria = sum(range(1000000))
    print(f"Sumatoria: {sumatoria}")

# También podemos usar contextlib para crear context managers con decoradores
from contextlib import contextmanager

@contextmanager
def temporal_change(obj, **changes):
    """Context manager que realiza cambios temporales a un objeto."""
    original_values = {}
    try:
        for key, value in changes.items():
            if hasattr(obj, key):
                original_values[key] = getattr(obj, key)
                setattr(obj, key, value)
        yield obj  # El código se ejecuta aquí
    finally:
        # Restauramos los valores originales
        for key, value in original_values.items():
            setattr(obj, key, value)

class Configuracion:
    modo = "produccion"
    debug = False

config = Configuracion()
print(f"Antes: modo={config.modo}, debug={config.debug}")

with temporal_change(config, modo="desarrollo", debug=True):
    print(f"Dentro: modo={config.modo}, debug={config.debug}")

print(f"Después: modo={config.modo}, debug={config.debug}")

2. Metaprogramación con Metaclasses

¡Bienvenido al mundo de la metaprogramación! Las metaclasses son las "clases de clases" - controlan cómo se crean las clases mismas. Es como tener el poder de redefinir las reglas del juego de Python.

class MetaVerificacion(type):
    """Metaclass que verifica que las clases tengan ciertos atributos."""
    def __new__(cls, nombre, bases, attrs):
        # Verificar que la clase tenga una docstring
        if not attrs.get('__doc__'):
            raise TypeError(f"La clase {nombre} debe tener una docstring")

        # Verificar que ciertos métodos estén presentes
        métodos_requeridos = ['validar']
        for método in métodos_requeridos:
            if método not in attrs:
                raise TypeError(f"La clase {nombre} debe implementar {método}()")

        # Crear la clase normalmente
        return super().__new__(cls, nombre, bases, attrs)

# Usando la metaclass
class Usuario(metaclass=MetaVerificacion):
    """Clase que representa un usuario."""

    def __init__(self, nombre):
        self.nombre = nombre

    def validar(self):
        """Valida que el usuario sea correcto."""
        return len(self.nombre) > 0

# Esta clase fallaría al ser definida:
# class ProductoSinDocstring(metaclass=MetaVerificacion):
#     def validar(self):
#         pass

# Uso de __init_subclass__ para un enfoque más moderno
class Base:
    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        # Verificaciones automáticas cuando se hereda
        if not hasattr(cls, 'version'):
            cls.version = "1.0"
        print(f"Subclase {cls.__name__} creada con versión {cls.version}")

class MiClase(Base):
    pass  # Hereda automáticamente la versión

print(f"Versión de MiClase: {MiClase.version}")

3. Descriptores

¡Los descriptores son la joya oculta de Python! Son objetos que controlan cómo se accede a los atributos de otras clases. Imagina tener un guardia personal para cada atributo de tus objetos.

class DescriptorTemperatura:
    """Descriptor para gestionar temperaturas con validación."""
    def __init__(self, nombre=None):
        self.nombre = nombre

    def __get__(self, instancia, propietario):
        if instancia is None:
            return self
        return instancia.__dict__.get(self.nombre, 0)

    def __set__(self, instancia, valor):
        if not -273.15 <= valor <= 1000:  # Rango razonable de temperatura
            raise ValueError("Temperatura fuera de rango válido")
        instancia.__dict__[self.nombre] = valor

    def __delete__(self, instancia):
        del instancia.__dict__[self.nombre]

class Clima:
    temperatura = DescriptorTemperatura('temperatura')

    def __init__(self, temp):
        self.temperatura = temp  # Usa el descriptor

# Uso del descriptor
clima = Clima(25)
print(f"Temperatura: {clima.temperatura}°C")

try:
    clima.temperatura = -300  # Esto fallará
except ValueError as e:
    print(f"Error: {e}")

# Property es una forma built-in de crear descriptores
class Persona:
    def __init__(self, nombre, edad):
        self._nombre = nombre
        self._edad = edad

    @property
    def edad(self):
        """La edad de la persona."""
        return self._edad

    @edad.setter
    def edad(self, valor):
        if valor < 0:
            raise ValueError("La edad no puede ser negativa")
        self._edad = valor

    @edad.deleter
    def edad(self):
        print("Eliminando edad...")
        del self._edad

persona = Persona("Ana", 25)
print(f"Edad: {persona.edad}")
persona.edad = 30
print(f"Nueva edad: {persona.edad}")

try:
    persona.edad = -5
except ValueError as e:
    print(f"Error: {e}")

4. Programación Asíncrona con Async/Await

¡Descubre el futuro de la programación en Python! Con async y await, puedes escribir código concurrente que parece síncrono. Es como tener superpoderes para manejar múltiples tareas simultáneamente.

import asyncio
import aiohttp  # Necesitarás instalarlo: pip install aiohttp

async def descargar_url(url):
    """Descarga el contenido de una URL de forma asíncrona."""
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            contenido = await response.text()
            return f"Descargados {len(contenido)} bytes de {url}"

async def main():
    """Función principal asíncrona."""
    urls = [
        "https://httpbin.org/html",
        "https://httpbin.org/json",
        "https://httpbin.org/xml"
    ]

    # Crear tareas para descargar todas las URLs concurrentemente
    tareas = [descargar_url(url) for url in urls]

    # Esperar a que todas las tareas terminen
    resultados = await asyncio.gather(*tareas)

    for resultado in resultados:
        print(resultado)

# Ejecutar el código asíncrono
# asyncio.run(main())

# Para entornos con event loop ya existente (como Jupyter)
# await main()

# Ejemplo más simple con sleep asíncrono
async decir_hola_cada_segundo(veces):
    for i in range(veces):
        await asyncio.sleep(1)
        print(f"Hola por {i+1}ª vez")

async def decir_adios_cada_dos_segundos(veces):
    for i in range(veces):
        await asyncio.sleep(2)
        print(f"Adiós por {i+1}ª vez")

async def ejecutar_concurrentemente():
    await asyncio.gather(
        decir_hola_cada_segundo(5),
        decir_adios_cada_dos_segundos(3)
    )

# Ejecutar
# asyncio.run(ejecutar_concurrentemente())

5. Type Hints y Anotaciones de Tipos

¡Añade superpoderes de documentación a tu código! Las anotaciones de tipo hacen que tu código sea más legible, mantenible y permiten detectar errores antes de que ocurran.

from typing import List, Dict, Tuple, Optional, Union, Callable

# Anotaciones básicas de tipo
def saludar(nombre: str) -> str:
    """Saluda a una persona."""
    return f"Hola, {nombre}!"

# Tipos compuestos
def procesar_datos(datos: List[Dict[str, Union[str, int]]]) -> Tuple[bool, Optional[str]]:
    """Procesa una lista de diccionarios con datos."""
    if not datos:
        return False, "No hay datos"

    for item in datos:
        if not isinstance(item, dict):
            return False, f"Item inválido: {item}"

    return True, None

# Type aliases
UserId = int
UserDict = Dict[str, Union[str, int, List[str]]]

def obtener_usuario(usuario_id: UserId) -> Optional[UserDict]:
    """Obtiene un usuario por su ID."""
    # Simulamos una base de datos
    usuarios = {
        1: {"nombre": "Ana", "edad": 25, "roles": ["admin", "usuario"]},
        2: {"nombre": "Carlos", "edad": 30, "roles": ["usuario"]}
    }
    return usuarios.get(usuario_id)

# Callable types
def aplicar_funcion(func: Callable[[int, int], int], a: int, b: int) -> int:
    """Aplica una función a dos números."""
    return func(a, b)

# Usando las funciones con type hints
resultado = aplicar_funcion(lambda x, y: x + y, 5, 3)
print(f"Resultado: {resultado}")

# Podemos usar mypy para verificar tipos estáticamente
# pip install mypy
# mypy mi_script.py

# Type hints en clases
class Producto:
    def __init__(self, nombre: str, precio: float, stock: int = 0):
        self.nombre = nombre
        self.precio = precio
        self.stock = stock

    def actualizar_stock(self, cantidad: int) -> None:
        """Actualiza el stock del producto."""
        self.stock += cantidad
        if self.stock < 0:
            self.stock = 0

# Uso de la clase
producto = Producto("Laptop", 999.99, 10)
producto.actualizar_stock(-5)
print(f"Stock actual: {producto.stock}")

6. Internacionalización (i18n) y Localización (l10n)

¡Haz que tu aplicación hable todos los idiomas! La internacionalización y localización permiten que tu software se adapte a diferentes idiomas, formatos de fecha y costumbres culturales.

import gettext
import locale
from datetime import datetime, date

# Configuración básica de gettext
es = gettext.translation('base', localedir='locales', languages=['es'])
es.install()

# _ es ahora la función de traducción
print(_("Hello, World!"))  # Mostrará "¡Hola, Mundo!" si existe la traducción

# Formateo de fechas y números según la localización
def mostrar_fechas_y_numeros():
    # Configurar la localización
    try:
        locale.setlocale(locale.LC_ALL, 'es_ES.UTF-8')
    except locale.Error:
        print("Localización española no disponible")
        return

    # Formatear números
    numero = 1234567.89
    numero_formateado = locale.format_string("%.2f", numero, grouping=True)
    print(f"Número formateado: {numero_formateado}")

    # Formatear fechas
    hoy = date.today()
    print(f"Fecha: {hoy.strftime('%A, %d de %B de %Y')}")

    # Formatear moneda
    precio = 19.99
    moneda_formateada = locale.currency(precio, grouping=True)
    print(f"Precio: {moneda_formateada}")

# Ejemplo de diccionario de traducciones manual
traducciones = {
    'en': {
        'welcome': 'Welcome!',
        'goodbye': 'Goodbye!',
        'items': 'You have {count} items'
    },
    'es': {
        'welcome': '¡Bienvenido!',
        'goodbye': '¡Adiós!',
        'items': 'Tienes {count} elementos'
    }
}

class TraductorSimple:
    def __init__(self, idioma='en'):
        self.idioma = idioma
        self.traducciones = traducciones

    def traducir(self, clave, **kwargs):
        """Traduce una clave con posible formateo."""
        if self.idioma in self.traducciones and clave in self.traducciones[self.idioma]:
            texto = self.traducciones[self.idioma][clave]
            return texto.format(**kwargs) if kwargs else texto
        return clave  # Devuelve la clave si no encuentra traducción

# Uso del traductor manual
traductor = TraductorSimple('es')
print(traductor.traducir('welcome'))
print(traductor.traducir('items', count=5))

7. C Extensiones con Cython

¡Turbo-carga tu código Python! Cython te permite escribir extensiones en C para Python, llevando el rendimiento de tu código crítico a velocidades increíbles.

# Este código necesitaría ser compilado con Cython
# Guardar como modulo_optimizado.pyx

"""
# modulo_optimizado.pyx
def calcular_primos(int n):
    # Devuelve una lista de números primos hasta n
    cdef int i, j
    cdef list primos = []
    cdef int es_primo

    for i in range(2, n + 1):
        es_primo = 1
        for j in range(2, int(i**0.5) + 1):
            if i % j == 0:
                es_primo = 0
                break
        if es_primo:
            primos.append(i)

    return primos
"""

# setup.py para compilar la extensión
"""
from setuptools import setup
from Cython.Build import cythonize

setup(
    ext_modules=cythonize("modulo_optimizado.pyx")
)
"""

# Para compilar:
# python setup.py build_ext --inplace

# Uso desde Python
try:
    from modulo_optimizado import calcular_primos
    primos = calcular_primos(100)
    print(f"Primos hasta 100: {primos}")
except ImportError:
    print("El módulo optimizado no está disponible, usando versión Python")

    # Versión Python pura como fallback
    def calcular_primos(n):
        primos = []
        for i in range(2, n + 1):
            es_primo = True
            for j in range(2, int(i**0.5) + 1):
                if i % j == 0:
                    es_primo = False
                    break
            if es_primo:
                primos.append(i)
        return primos

    primos = calcular_primos(100)
    print(f"Primos hasta 100 (Python puro): {primos}")

8. Patrones de Diseño en Python

¡Conoce las recetas secretas de los programadores expertos! Los patrones de diseño son soluciones probadas y reutilizables para problemas comunes que encontrarás una y otra vez.

from abc import ABC, abstractmethod
from typing import List

# PATRÓN OBSERVER
class Observador(ABC):
    @abstractmethod
    def actualizar(self, sujeto):
        pass

class Sujeto:
    def __init__(self):
        self._observadores: List[Observador] = []
        self._estado = None

    def agregar_observador(self, observador: Observador):
        self._observadores.append(observador)

    def eliminar_observador(self, observador: Observador):
        self._observadores.remove(observador)

    def notificar(self):
        for observador in self._observadores:
            observador.actualizar(self)

    @property
    def estado(self):
        return self._estado

    @estado.setter
    def estado(self, valor):
        self._estado = valor
        self.notificar()

class ObservadorConcreto(Observador):
    def __init__(self, nombre):
        self.nombre = nombre

    def actualizar(self, sujeto):
        print(f"{self.nombre} recibió actualización. Nuevo estado: {sujeto.estado}")

# Uso del patrón Observer
sujeto = Sujeto()
obs1 = ObservadorConcreto("Observador 1")
obs2 = ObservadorConcreto("Observador 2")

sujeto.agregar_observador(obs1)
sujeto.agregar_observador(obs2)

sujeto.estado = "Nuevo estado"  # Esto notificará a todos los observadores

# PATRÓN SINGLETON
class Singleton:
    _instancia = None

    def __new__(cls):
        if cls._instancia is None:
            cls._instancia = super().__new__(cls)
            cls._instancia.inicializado = False
        return cls._instancia

    def inicializar(self):
        if not self.inicializado:
            self.inicializado = True
            print("Singleton inicializado")

# Uso del patrón Singleton
s1 = Singleton()
s2 = Singleton()

print(f"s1 es s2: {s1 is s2}")  # True - ambas variables apuntan a la misma instancia

s1.inicializar()
s2.inicializar()  # No se inicializará de nuevo

9. Proyecto Integrador: Sistema de Plugins

¡Construye tu propio ecosistema extensible! Vamos a crear un sistema de plugins que se carga dinámicamente, permitiendo que tu aplicación crezca y evolucione sin límites.

import importlib
import inspect
from pathlib import Path
from abc import ABC, abstractmethod

# Interface para plugins
class Plugin(ABC):
    @abstractmethod
    def ejecutar(self, *args, **kwargs):
        pass

    @property
    @abstractmethod
    def nombre(self):
        pass

# Cargador de plugins
class CargadorPlugins:
    def __init__(self, directorio_plugins="plugins"):
        self.directorio = Path(directorio_plugins)
        self.plugins = {}

    def cargar_plugins(self):
        """Carga todos los plugins del directorio especificado."""
        if not self.directorio.exists():
            self.directorio.mkdir()
            print(f"Directorio {self.directorio} creado")
            return

        for archivo in self.directorio.glob("*.py"):
            if archivo.name == "__init__.py":
                continue

            nombre_modulo = archivo.stem
            try:
                modulo = importlib.import_module(f"{self.directorio.name}.{nombre_modulo}")
                self._registrar_plugins_desde_modulo(modulo, nombre_modulo)
            except ImportError as e:
                print(f"Error cargando plugin {nombre_modulo}: {e}")

    def _registrar_plugins_desde_modulo(self, modulo, nombre_modulo):
        """Registra todas las clases Plugin encontradas en un módulo."""
        for nombre, clase in inspect.getmembers(modulo, inspect.isclass):
            if (issubclass(clase, Plugin) and clase is not Plugin):
                plugin = clase()
                self.plugins[plugin.nombre] = plugin
                print(f"Plugin cargado: {plugin.nombre}")

    def ejecutar_plugin(self, nombre_plugin, *args, **kwargs):
        """Ejecuta un plugin por nombre."""
        if nombre_plugin in self.plugins:
            return self.plugins[nombre_plugin].ejecutar(*args, **kwargs)
        else:
            raise ValueError(f"Plugin '{nombre_plugin}' no encontrado")

    def listar_plugins(self):
        """Lista todos los plugins cargados."""
        return list(self.plugins.keys())

# Ejemplo de plugin (debería estar en el directorio plugins/)
"""
# plugins/saludador.py
from sistema_plugins import Plugin

class PluginSaludador(Plugin):
    @property
    def nombre(self):
        return "saludador"

    def ejecutar(self, nombre="Mundo"):
        return f"Hola, {nombre}!"

class PluginDespedidor(Plugin):
    @property
    def nombre(self):
        return "despedidor"

    def ejecutar(self, nombre="Mundo"):
        return f"Adiós, {nombre}!"
"""

# Uso del sistema de plugins
def main():
    cargador = CargadorPlugins()
    cargador.cargar_plugins()

    print("Plugins disponibles:", cargador.listar_plugins())

    # Ejecutar plugins
    try:
        resultado = cargador.ejecutar_plugin("saludador", "Pythonista")
        print(resultado)

        resultado = cargador.ejecutar_plugin("despedidor", "Pythonista")
        print(resultado)
    except ValueError as e:
        print(f"Error: {e}. ¿Creaste los plugins en el directorio plugins/?")

if __name__ == "__main__":
    main()

10. Recursos para Profundizar

¡Tu viaje apenas comienza! Aquí tienes recursos excepcionales para continuar dominando estos temas avanzados y convertirte en un verdadero maestro de Python:

1. Documentación Oficial:

   • Python Data Model
   • asyncio
   • typing

2. Libros Especializados:

   • "Python in a Nutshell" de Alex Martelli
   • "Expert Python Programming" de Michał Jaworski y Tarek Ziadé

3. Proyectos Prácticos:

   • Crea tu propio framework de plugins
   • Implementa un servidor asíncrono
   • Desarrolla una biblioteca con type hints completos

4. Comunidades:

   • Python Discord
   • Real Python
   • PyCoders Weekly

Este tutorial ha cubierto temas avanzados que te permitirán llevar tus habilidades de Python al siguiente nivel. ¡Sigue explorando y practicando!