Características modernas de Python

Python ha evolucionado significativamente desde sus primeras versiones, incorporando características modernas que mejoran tanto la legibilidad del código como su rendimiento. Estas funcionalidades representan la dirección hacia la que se mueve el lenguaje, priorizando la claridad, la eficiencia y la facilidad de mantenimiento.

Type hints y tipado estático

Una de las innovaciones más importantes en Python moderno es la introducción del sistema de type hints. Esta característica permite especificar los tipos de datos esperados en funciones y variables, mejorando la documentación del código y facilitando la detección temprana de errores.

def calcular_precio_total(precio: float, descuento: float = 0.0) -> float:
    """Calcula el precio final aplicando un descuento."""
    return precio * (1 - descuento)

# Uso con tipos claros
precio_final: float = calcular_precio_total(100.0, 0.15)

Los type hints no afectan la ejecución del programa, pero proporcionan información valiosa para herramientas de análisis estático y editores de código. Python moderno incluye el módulo typing que ofrece tipos más complejos:

from typing import List, Dict, Optional, Union

def procesar_datos(usuarios: List[Dict[str, Union[str, int]]]) -> Optional[str]:
    """Procesa una lista de diccionarios con información de usuarios."""
    if not usuarios:
        return None
    
    return f"Procesados {len(usuarios)} usuarios"

F-strings y formateo avanzado

Las f-strings (formatted string literals) representan la forma más moderna y eficiente de formatear cadenas en Python. Introducidas para reemplazar métodos anteriores como % formatting y str.format(), ofrecen una sintaxis más limpia y mejor rendimiento.

nombre = "Ana"
edad = 28
salario = 45000.50

# F-string básica
mensaje = f"Hola {nombre}, tienes {edad} años"

# Con formateo numérico
informe = f"Salario: {salario:,.2f}€"

# Con expresiones
estado = f"Estado: {'Adulto' if edad >= 18 else 'Menor'}"

Las f-strings permiten expresiones complejas directamente dentro de las llaves, incluyendo llamadas a funciones y operaciones matemáticas:

import datetime

productos = [{"nombre": "Laptop", "precio": 899.99}, {"nombre": "Mouse", "precio": 25.50}]

reporte = f"""
Reporte generado: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M')}
Total productos: {len(productos)}
Precio promedio: {sum(p['precio'] for p in productos) / len(productos):.2f}€
"""

Walrus operator y expresiones de asignación

El walrus operator (:=) permite asignar valores a variables dentro de expresiones, reduciendo la duplicación de código y mejorando la eficiencia en ciertos casos:

# Sin walrus operator
datos = input("Introduce datos: ")
if len(datos) > 10:
    print(f"Datos largos: {datos}")

# Con walrus operator
if (longitud := len(datos := input("Introduce datos: "))) > 10:
    print(f"Datos largos ({longitud} caracteres): {datos}")

Esta característica es especialmente útil en bucles y comprensiones donde necesitas usar el resultado de una función múltiples veces:

# Procesamiento eficiente de archivos
import re

def procesar_lineas(archivo):
    with open(archivo, 'r') as f:
        return [match.group(1) for linea in f 
                if (match := re.search(r'ERROR: (.+)', linea))]

Pattern matching con match-case

Python moderno incluye pattern matching a través de la declaración match-case, que proporciona una alternativa más expresiva a las cadenas de if-elif:

def procesar_comando(comando):
    match comando:
        case {"accion": "crear", "tipo": "usuario", "nombre": str(nombre)}:
            return f"Creando usuario: {nombre}"
        
        case {"accion": "eliminar", "id": int(user_id)} if user_id > 0:
            return f"Eliminando usuario ID: {user_id}"
        
        case {"accion": "listar", "filtro": filtros} if isinstance(filtros, list):
            return f"Listando con filtros: {', '.join(filtros)}"
        
        case _:
            return "Comando no reconocido"

# Uso del pattern matching
resultado = procesar_comando({
    "accion": "crear", 
    "tipo": "usuario", 
    "nombre": "Carlos"
})

El pattern matching es especialmente útil para trabajar con estructuras de datos complejas y APIs que devuelven diferentes formatos de respuesta:

def manejar_respuesta_api(respuesta):
    match respuesta:
        case {"status": "success", "data": list(items)} if len(items) > 0:
            return f"Recibidos {len(items)} elementos"
        
        case {"status": "error", "message": str(error), "code": int(code)}:
            return f"Error {code}: {error}"
        
        case {"status": "empty"}:
            return "No hay datos disponibles"

Dataclasses y estructuras de datos modernas

Las dataclasses simplifican la creación de clases que principalmente almacenan datos, generando automáticamente métodos especiales como __init__, __repr__ y __eq__:

from dataclasses import dataclass, field
from typing import List

@dataclass
class Producto:
    nombre: str
    precio: float
    categoria: str
    tags: List[str] = field(default_factory=list)
    
    def precio_con_iva(self, iva: float = 0.21) -> float:
        return self.precio * (1 + iva)

# Uso simple y claro
producto = Producto("Smartphone", 599.99, "Electrónicos", ["móvil", "android"])
print(f"Precio final: {producto.precio_con_iva():.2f}€")

Las dataclasses pueden incluir validación y procesamiento automático de datos:

from dataclasses import dataclass, field
from datetime import datetime

@dataclass
class Pedido:
    id: int
    cliente: str
    productos: List[Producto] = field(default_factory=list)
    fecha: datetime = field(default_factory=datetime.now)
    
    @property
    def total(self) -> float:
        return sum(p.precio for p in self.productos)
    
    def agregar_producto(self, producto: Producto):
        self.productos.append(producto)

Estas características modernas de Python no solo mejoran la legibilidad del código, sino que también facilitan el mantenimiento y la colaboración en proyectos de desarrollo. Su adopción representa las mejores prácticas actuales en el ecosistema Python.