🧠 Python Avanzado

---

🔹 Introducción

En este nivel aprenderás características avanzadas de Python que te permiten escribir código más optimizado, legible y escalable. Veremos temas como iteradores y generadores, decoradores, context managers, testing, y hasta metaprogramación. Estos conocimientos son los que diferencian a un programador intermedio de un profesional. —

⚡ Listas y Diccionarios por Comprensión

Ya vimos las comprensiones en nivel intermedio. En avanzado se pueden anidar y aplicar también a diccionarios y conjuntos.

# Lista de pares y su cuadrado
pares_cuadrados = [(x, x**2) for x in range(10) if x % 2 == 0]
print(pares_cuadrados)

# Diccionario con letras y su código ASCII
ascii_map = {letra: ord(letra) for letra in "Python"}
print(ascii_map)

—

🔄 Iteradores y Generadores

Un iterador es un objeto que implementa los métodos __iter__() y __next__(). Los generadores permiten crear iteradores de forma más sencilla usando yield.

class Contador:
    def __init__(self, limite):
        self.limite = limite
        self.valor = 0
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.valor < self.limite:
            self.valor += 1
            return self.valor
        else:
            raise StopIteration

for numero in Contador(5):
    print(numero)

# Generador equivalente
def generador_pares(n):
    for i in range(n):
        if i % 2 == 0:
            yield i

print(list(generador_pares(10)))

—

🎭 Decoradores

Un decorador es una función que recibe otra función y devuelve una nueva con funcionalidad extendida. Son muy usados en frameworks (Flask, Django, FastAPI).

def log(func):
    def wrapper(*args, **kwargs):
        print(f"Llamando a {func.__name__}")
        resultado = func(*args, **kwargs)
        print(f"{func.__name__} finalizó")
        return resultado
    return wrapper

@log
def suma(a, b):
    return a + b

print(suma(5, 3))

—

📂 Context Managers

Con with puedes manejar recursos como archivos o conexiones de forma automática. También puedes crear tus propios context managers.

# Uso normal con archivo
with open("archivo.txt", "w") as f:
    f.write("Hola mundo")

# Crear un context manager personalizado
class GestorRecursos:
    def __enter__(self):
        print("Recurso abierto")
        return self
    
    def __exit__(self, tipo, valor, traza):
        print("Recurso cerrado")

with GestorRecursos():
    print("Usando el recurso")

—

🧪 Testing y Buenas Prácticas

Escribir pruebas unitarias es clave para proyectos profesionales. Python trae unittest y frameworks como pytest.

# test_math.py
import unittest

def suma(a, b):
    return a + b

class TestMath(unittest.TestCase):
    def test_suma(self):
        self.assertEqual(suma(2, 3), 5)
        self.assertNotEqual(suma(2, 2), 5)

if __name__ == "__main__":
    unittest.main()

—

🔧 Metaprogramación (Funciones y Clases Dinámicas)

Python permite crear funciones y clases de forma dinámica, y modificar su comportamiento en tiempo de ejecución.

# Creación dinámica de funciones
def crear_funcion(mensaje):
    def interna():
        print(mensaje)
    return interna

f = crear_funcion("Hola dinámico!")
f()

# type() para crear clases dinámicamente
MiClase = type("MiClase", (), {"saludo": lambda self: "Hola desde clase dinámica"})
obj = MiClase()
print(obj.saludo())

—

⚙️ Multiprocesamiento y Concurrencia

Python permite ejecutar tareas en paralelo con multiprocessing y manejar concurrencia con asyncio.

# Ejemplo con multiprocessing
from multiprocessing import Process

def tarea(nombre):
    print(f"Ejecutando tarea {nombre}")

if __name__ == "__main__":
    p1 = Process(target=tarea, args=("A",))
    p2 = Process(target=tarea, args=("B",))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

# Ejemplo con asyncio
import asyncio

async def saludar():
    print("Hola async")
    await asyncio.sleep(1)
    print("Adiós async")

asyncio.run(saludar())

—

📝 Ejercicio práctico

“Crea un decorador que mida el tiempo de ejecución de funciones, luego úsalo en una función que procese una lista muy grande con comprensión de listas y otra con bucles normales. Compara los tiempos de ejecución.”

import time

def medir_tiempo(func):
    def wrapper(*args, **kwargs):
        inicio = time.time()
        resultado = func(*args, **kwargs)
        fin = time.time()
        print(f"{func.__name__} tardó {fin - inicio:.4f} segundos")
        return resultado
    return wrapper

@medir_tiempo
def con_comprension(n):
    return [i**2 for i in range(n)]

@medir_tiempo
def con_bucle(n):
    lista = []
    for i in range(n):
        lista.append(i**2)
    return lista

con_comprension(10**6)
con_bucle(10**6)