Python 3.12+ Mastery 2026

# Variables
nombre = "AutoNovations"
módulos = 14
tasa_éxito = 0.985

# f-string moderno con especificaciones de formato
mensaje = f"Curso {nombre.upper()} | Módulos: {módulos} | Éxito: {tasa_éxito:.1%}"
print(mensaje)
# Output: Curso AUTONOVATIONS | Módulos: 14 | Éxito: 98.5%

# Operador de autodocumentación (=) disponible desde Python 3.8+
x = 10
y = 25
print(f"{x=}, {y=}, {x+y=}")
# Output: x=10, y=25, x+y=35

# Casting explícito
edad_str = "28"
edad_num = int(edad_str)

# Divisibilidad entera (//) y exponenciación (**)
cuadrado = 5 ** 2   # 25
div_entera = 17 // 5 # 3
modulo = 17 % 5     # 2

# Operadores Lógicos (and, or, not) y de Pertenencia (in, not in)
es_valido = 18 <= edad_num and "Auto" in nombre

# Condicionales con asignación expresión ternaria
estado = "Activo" if limite > 0 else "Inactivo"

# Bucle for con enumerate y range
usuarios = ["Alice", "Bob", "Charlie"]
for indice, usuario in enumerate(usuarios, start=1):
    print(f"[{indice}] Procesando usuario: {usuario}")

# Bucle while con cláusula else (se ejecuta si NO hubo break)
intentos = 0
while intentos < 3:
    if conectar_servidor():
        print("Conexión exitosa")
        break
    intentos += 1
else:
    print("Error: Máximo número de reintentos alcanzado")

def procesar_comando(comando):
    match comando.split():
        case ["QUIT" | "EXIT"]:
            return "Saliendo del programa..."
        case ["MOVE", ("NORTH" | "SOUTH" | "EAST" | "WEST") as direccion]:
            return f"Moviéndose hacia {direccion}"
        case ["GET", item, "COUNT", int(cantidad)] if cantidad > 0:
            return f"Obteniendo {cantidad} unidades de {item}"
        case _:
            return "Comando no reconocido"

# List Comprehension
numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
cuadrados_pares = [x**2 for x in numeros if x % 2 == 0]
# Result: [4, 16, 36, 64, 100]

# Dict Comprehension
estudiantes = ["Ana", "Pedro", "Maria"]
notas = [95, 88, 92]
mapa_notas = {est: nota for est, nota in zip(estudiantes, notas)}
# Result: {'Ana': 95, 'Pedro': 88, 'Maria': 92}

# Set Comprehension (Elimina duplicados automáticamente)
tags = ["PYTHON", "python", "AI", "ai", "FASTAPI"]
tags_limpios = {t.lower() for t in tags}
# Result: {'python', 'ai', 'fastapi'}

items = [0, 10, 20, 30, 40, 50, 60, 70]

# Sintaxis: lista[inicio:fin:paso]
sub_lista = items[2:6]    # [20, 30, 40, 50]
invertida = items[::-1]   # [70, 60, 50, 40, 30, 20, 10, 0]
saltos = items[::2]       # [0, 20, 40, 60]

def crear_usuario(
    nombre: str,
    /,  # Todo antes de '/' DEBE ser posicional únicamente
    *,  # Todo después de '*' DEBE ser mediante keyword explícito
    email: str,
    rol: str = "developer",
    *habilidades: str,
    **metadatos: any
) -> dict:
    return {
        "nombre": nombre,
        "email": email,
        "rol": rol,
        "habilidades": habilidades,
        "metadatos": metadatos
    }

# Uso correcto
usr = crear_usuario("Carlos", email="carlos@autonovations.com", "Python", "Docker", departamento="AI")

class CuentaBancaria:
    # Atributo de Clase
    banco = "AutoNovations Bank"

    def __init__(self, titular: str, saldo_inicial: float = 0.0):
        self.titular = titular
        self._saldo = saldo_inicial  # Atributo protegido por convención

    @property
    def saldo(self) -> float:
        """Getter idiomático para saldo"""
        return self._saldo

    @saldo.setter
    def saldo(self, nuevo_monto: float):
        """Setter con validación de negocio"""
        if nuevo_monto < 0:
            raise ValueError("El saldo no puede ser negativo")
        self._saldo = nuevo_monto

    # Dunder Methods
    def __repr__(self) -> str:
        return f"CuentaBancaria(titular='{self.titular}', saldo={self._saldo})"

    def __eq__(self, otro) -> bool:
        return isinstance(otro, CuentaBancaria) and self._saldo == otro._saldo

from dataclasses import dataclass, field
from datetime import datetime

@dataclass(frozen=True, order=True)
class Transaccion:
    id: str
    monto: float
    timestamp: datetime = field(default_factory=datetime.now)

# Inmutable y auto-comparable
tx1 = Transaccion(id="TX-101", monto=250.0)
print(tx1)
# Output: Transaccion(id='TX-101', monto=250.0, timestamp=datetime.datetime(...))

class APIError(Exception):
    """Excepción personalizada para servicios web"""
    def __init__(self, codigo: int, mensaje: str):
        self.codigo = codigo
        super().__init__(f"[{codigo}] {mensaje}")

def realizar_peticion(url: str):
    try:
        # Simulación de llamada
        res = conectar(url)
    except ConnectionError as err:
        raise APIError(503, "Servicio no disponible") from err
    else:
        # Se ejecuta SOLO si NO hubo excepciones
        print("Petición procesada correctamente")
        return res.json()
    finally:
        # Se ejecuta SIEMPRE para liberar recursos
        cerrar_socket()

from pathlib import Path
import json

# Rutas orientadas a objetos multiplataforma
directorio_base = Path(__file__).resolve().parent
archivo_config = directorio_base / "config" / "settings.json"

# Crear directorio si no existe
archivo_config.parent.mkdir(parents=True, exist_ok=True)

# Escritura directa
datos = {"app": "AutoNovations", "version": "2026.1"}
archivo_config.write_text(json.dumps(datos, indent=2), encoding="utf-8")

# Lectura directa
contenido = json.loads(archivo_config.read_text(encoding="utf-8"))

from contextlib import contextmanager
import time

@contextmanager
def temporizador(etiqueta: str):
    inicio = time.perf_counter()
    try:
        yield
    finally:
        duracion = time.perf_counter() - inicio
        print(f"⏱️ [{etiqueta}] Ejecutado en {duracion:.4f}s")

# Uso práctico
with temporizador("Carga masiva de datos"):
    matriz = [i**2 for i in range(1_000_000)]

[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"

[project]
name = "autonovations-core"
version = "1.0.0"
description = "Librería core de utilidades para sistemas autónomos"
readme = "README.md"
requires-python = ">=3.12"
dependencies = [
    "pydantic>=2.7.0",
    "httpx>=0.27.0",
]

[project.scripts]
auto-cli = "autonovations_core.cli:main"

from functools import wraps
import time

def reintentar(max_intentos: int = 3, retardo: float = 1.0):
    def decorador(func):
        @wraps(func)  # Preserva el __name__ y __doc__ original
        def wrapper(*args, **kwargs):
            for intento in range(1, max_intentos + 1):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    print(f"⚠️ Intento {intento}/{max_intentos} falló: {e}")
                    if intento == max_intentos:
                        raise
                    time.sleep(retardo)
        return wrapper
    return decorador

@reintentar(max_intentos=3, retardo=0.5)
def conectar_sensor_iot():
    """Simula conexión a microcontrolador"""
    raise ConnectionResetError("Sensor no responde")

def stream_telemetria_gigante(total_registros: int):
    for i in range(total_registros):
        # Genera un dato a la vez en RAM constante O(1)
        yield {"timestamp": time.time(), "lectura": i * 0.42}

# Procesamiento streaming de 10 millones de items consumiendo < 5MB RAM
for lectura in stream_telemetria_gigante(10_000_000):
    if lectura["lectura"] > 100:
        print("Alerta detectada:", lectura)
        break

import asyncio
import time

async def consultar_servicio(id_servicio: int, retardo: float) -> dict:
    await asyncio.sleep(retardo)  # Cede el control al Event Loop
    return {"id": id_servicio, "status": "OK", "tiempo": retardo}

async def main():
    inicio = time.perf_counter()
    
    # Concurrencia estructurada con TaskGroup
    async with asyncio.TaskGroup() as tg:
        t1 = tg.create_task(consultar_servicio(1, 1.5))
        t2 = tg.create_task(consultar_servicio(2, 0.8))
        t3 = tg.create_task(consultar_servicio(3, 1.2))
        
    # Todas las tareas finalizan aquí
    resultados = [t1.result(), t2.result(), t3.result()]
    duracion = time.perf_counter() - inicio
    print(f"⚡ 3 peticiones completadas en {duracion:.2f}s (en paralelo)")

# Iniciar el Event Loop de asyncio
asyncio.run(main())

# Definición de alias de tipo genérico conciso con la palabra clave type
type Vector[T] = list[T]
type RespuestaAPI[D] = dict[str, D | None]

# Función genérica moderna sin TypeVar verboso
def primero_o_defecto[T](elementos: list[T], defecto: T) -> T:
    return elementos[0] if elementos else defecto

class PluginBase:
    registro_plugins = {}

    def __init_subclass__(cls, nombre_plugin: str, **kwargs):
        super().__init_subclass__(**kwargs)
        cls.registro_plugins[nombre_plugin] = cls

class PluginSQL(PluginBase, nombre_plugin="sql"):
    pass

class PluginMongo(PluginBase, nombre_plugin="mongodb"):
    pass

print(PluginBase.registro_plugins)
# Output: {'sql': , 'mongodb': }

import pytest

# Fixture reutilizable
@pytest.fixture
def cliente_base_datos():
    db = {"estado": "conectado", "registros": []}
    yield db  # Setup finalizado, entrega el objeto
    db["registros"].clear()  # Teardown de limpieza

# Test parametrizado (evalúa múltiples entradas)
@pytest.mark.parametrize("entrada,esperado", [
    (2, 4),
    (5, 25),
    (10, 100),
])
def test_calcular_cuadrado(entrada, esperado):
    assert entrada ** 2 == esperado

def test_insercion_db(cliente_base_datos):
    cliente_base_datos["registros"].append("Item 1")
    assert len(cliente_base_datos["registros"]) == 1

uv pip install ruff pytest pytest-cov
ruff check . --fix     # Revisa y auto-corrige errores de código
ruff format .          # Formateo automático de código
pytest --cov=src       # Ejecuta tests con reporte de cobertura

import typer
from rich.console import Console
from rich.table import Table

app = typer.Typer(help="AutoNovations CLI Tool 2026")
console = Console()

@app.command()
def listar_servicios(region: str = "us-east-1"):
    """Muestra el estado de microservicios en una región"""
    table = Table(title=f"Estado de Servicios - {region}")
    table.add_column("ID", style="cyan")
    table.add_column("Servicio", style="white")
    table.add_column("Estado", style="green")

    table.add_row("SRV-01", "Auth Service", "HEALTHY")
    table.add_row("SRV-02", "AI Pipeline Engine", "HEALTHY")
    console.print(table)

if __name__ == "__main__":
    app()

from fastapi import FastAPI, HTTPException, status
from pydantic import BaseModel, EmailStr

app = FastAPI(title="AutoNovations Core API", version="2026.1")

class UsuarioCrear(BaseModel):
    nombre: str
    email: EmailStr
    edad: int

@app.post("/api/v1/usuarios", status_code=status.HTTP_201_CREATED)
async def crear_nuevo_usuario(usuario: UsuarioCrear):
    # Simulación de persistencia asíncrona
    if usuario.edad < 18:
        raise HTTPException(status_code=400, detail="Debe ser mayor de edad")
    return {"status": "creado", "datos": usuario}