Python Intermedio: Técnicas Avanzadas y Mejores Prácticas - Tutorial Completo

¡Domina Python a nivel intermedio con este tutorial completo! Aprenderás técnicas avanzadas como comprensiones, pathlib, decoradores, manejo de fechas, excepciones personalizadas, collections, programación funcional y JSON avanzado. Esta guía paso a paso te llevará desde los fundamentos básicos hasta conceptos intermedios esenciales para el desarrollo profesional en Python.

Objetivo: Aprender técnicas avanzadas de Python intermedio, incluyendo mejores prácticas y patrones de código eficientes.

Paso 1: Comprensiones Avanzadas y Expresiones Generadoras

Las comprensiones en Python van más allá de las listas simples. Aprende a crear diccionarios, conjuntos y expresiones generadoras de forma eficiente y elegante.

# Comprensión de listas con condiciones
numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
pares_al_cuadrado = [x**2 for x in numeros if x % 2 == 0]
print(f"Pares al cuadrado: {pares_al_cuadrado}")

# Comprensión de diccionarios
nombres = ["Ana", "Carlos", "Elena"]
edades = [25, 30, 28]
personas = {nombre: edad for nombre, edad in zip(nombres, edades)}
print(f"Diccionario personas: {personas}")

# Comprensión de conjuntos
palabras = ["python", "java", "python", "javascript", "java"]
lenguajes_unicos = {palabra.upper() for palabra in palabras}
print(f"Lenguajes únicos: {lenguajes_unicos}")

# Expresiones generadoras (consumen menos memoria)
suma_cuadrados = sum(x**2 for x in range(1000000))
print(f"Suma de cuadrados: {suma_cuadrados}")

# Comprensión anidada
matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
aplanada = [num for fila in matriz for num in fila]
print(f"Matriz aplanada: {aplanada}")

# Comprensión con condiciones múltiples
categorias = [
    "par" if x % 2 == 0 else "impar" 
    for x in range(10)
    if x > 0  # Filtramos el 0
]
print(f"Categorías: {categorias}")

Paso 2: Manejo de Archivos y Directorios con pathlib

Descubre cómo usar pathlib para trabajar con archivos y directorios de manera más intuitiva y moderna en Python.

from pathlib import Path
import datetime

# Crear objetos Path
ruta_actual = Path.cwd()
print(f"Directorio actual: {ruta_actual}")

archivo = Path("mi_archivo.txt")
print(f"¿Existe el archivo? {archivo.exists()}")

# Operaciones con archivos
if not archivo.exists():
    archivo.write_text("Hola, este es un archivo de prueba\nCreado con pathlib")
    print("Archivo creado")

# Leer contenido
contenido = archivo.read_text()
print(f"Contenido del archivo:\n{contenido}")

# Trabajar con directorios
directorio = Path("mi_directorio")
directorio.mkdir(exist_ok=True)  # Crear si no existe

# Listar archivos
print("Archivos en el directorio actual:")
for archivo in ruta_actual.iterdir():
    if archivo.is_file():
        print(f"  - {archivo.name} ({archivo.stat().st_size} bytes)")

# Buscar archivos específicos
archivos_py = list(ruta_actual.glob("*.py"))
print(f"Archivos Python encontrados: {[f.name for f in archivos_py]}")

# Manipulación de rutas
ruta_completa = directorio / "subdir" / "archivo.txt"
print(f"Ruta completa: {ruta_completa}")
print(f"Nombre del archivo: {ruta_completa.name}")
print(f"Extensión: {ruta_completa.suffix}")
print(f"Directorio padre: {ruta_completa.parent}")

# Cambiar extensión
nueva_ruta = ruta_completa.with_suffix(".csv")
print(f"Nueva ruta: {nueva_ruta}")

Paso 3: Decoradores y Closures Intermedios

Aprende a usar decoradores y closures para crear código más modular y reutilizable en Python.

import time
from functools import wraps

# Decorador con parámetros
def repetir(n_veces):
    def decorador_repetir(func):
        @wraps(func)  # Preserva los metadatos de la función original
        def wrapper(*args, **kwargs):
            resultados = []
            for _ in range(n_veces):
                resultado = func(*args, **kwargs)
                resultados.append(resultado)
            return resultados
        return wrapper
    return decorador_repetir

@repetir(n_veces=3)
def saludar(nombre):
    """Saluda a una persona."""
    return f"Hola, {nombre}!"

print(saludar("Mundo"))
print(f"Nombre de la función: {saludar.__name__}")
print(f"Docstring: {saludar.__doc__}")

# Decorador para medir tiempo de ejecución
def medir_tiempo(func):
    @wraps(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 proceso_lento():
    """Simula un proceso que toma tiempo."""
    time.sleep(2)
    return "Proceso completado"

print(proceso_lento())

# Closure: función que recuerda variables de su ámbito de creación
def crear_contador():
    cuenta = 0  # Variable "recordada" por el closure

    def contador():
        nonlocal cuenta  # Permite modificar la variable del ámbito exterior
        cuenta += 1
        return cuenta

    return contador

mi_contador = crear_contador()
print(f"Contador: {mi_contador()}")
print(f"Contador: {mi_contador()}")
print(f"Contador: {mi_contador()}")

# Decorador con estado
def contador_llamadas(func):
    llamadas = 0

    @wraps(func)
    def wrapper(*args, **kwargs):
        nonlocal llamadas
        llamadas += 1
        print(f"{func.__name__} ha sido llamada {llamadas} veces")
        return func(*args, **kwargs)

    return wrapper

@contador_llamadas
def funcion_ejemplo():
    return "Función ejecutada"

print(funcion_ejemplo())
print(funcion_ejemplo())

Paso 4: Manejo de Fechas y Horas

Domina el manejo de fechas y horas en Python con el módulo datetime y aprende a trabajar con zonas horarias.

from datetime import datetime, date, time, timedelta
import locale

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

# Formateo de fechas
fecha_formateada = ahora.strftime("%A %d de %B de %Y - %H:%M:%S")
print(f"Fecha formateada: {fecha_formateada}")

# Configurar locale para español
try:
    locale.setlocale(locale.LC_TIME, 'es_ES.UTF-8')
    fecha_espanol = ahora.strftime("%A %d de %B de %Y")
    print(f"Fecha en español: {fecha_espanol}")
except locale.Error:
    print("Locale español no disponible")

# Crear fechas específicas
fecha_nacimiento = date(1990, 5, 15)
hora_reunion = time(14, 30, 0)
reunion = datetime.combine(date.today(), hora_reunion)

print(f"Fecha de nacimiento: {fecha_nacimiento}")
print(f"Hora de reunión: {hora_reunion}")
print(f"Reunión hoy: {reunion}")

# Operaciones con fechas
hoy = date.today()
ayer = hoy - timedelta(days=1)
manana = hoy + timedelta(days=1)

print(f"Ayer: {ayer}")
print(f"Hoy: {hoy}")
print(f"Mañana: {manana}")

# Diferencia entre fechas
diferencia = manana - ayer
print(f"Diferencia: {diferencia.days} días")

# Parsear fechas desde texto
fecha_texto = "2023-12-25 20:30:00"
fecha_parseada = datetime.strptime(fecha_texto, "%Y-%m-%d %H:%M:%S")
print(f"Fecha parseada: {fecha_parseada}")

# Zonas horarias (requiere pytz: pip install pytz)
try:
    import pytz

    # Crear datetime con zona horaria
    utc = pytz.UTC
    madrid = pytz.timezone('Europe/Madrid')

    ahora_utc = datetime.now(utc)
    ahora_madrid = datetime.now(madrid)

    print(f"UTC: {ahora_utc}")
    print(f"Madrid: {ahora_madrid}")

    # Convertir entre zonas horarias
    utc_a_madrid = ahora_utc.astimezone(madrid)
    print(f"UTC a Madrid: {utc_a_madrid}")

except ImportError:
    print("pytz no instalado. Usa 'pip install pytz' para soporte de zonas horarias")

Paso 5: Manejo de Excepciones Avanzado

Crea excepciones personalizadas y maneja errores de manera profesional en Python.

# Excepción personalizada
class SaldoInsuficienteError(Exception):
    """Excepción lanzada cuando no hay suficiente saldo."""
    def __init__(self, saldo_actual, cantidad_retiro):
        self.saldo_actual = saldo_actual
        self.cantidad_retiro = cantidad_retiro
        super().__init__(f"Saldo insuficiente: {saldo_actual}. Se intentó retirar: {cantidad_retiro}")

class CuentaBancaria:
    def __init__(self, saldo_inicial=0):
        self.saldo = saldo_inicial

    def retirar(self, cantidad):
        if cantidad > self.saldo:
            raise SaldoInsuficienteError(self.saldo, cantidad)
        self.saldo -= cantidad
        return self.saldo

# Uso de excepciones personalizadas
cuenta = CuentaBancaria(100)
try:
    cuenta.retirar(150)
except SaldoInsuficienteError as e:
    print(f"Error: {e}")
    print(f"Saldo actual: {e.saldo_actual}")
    print(f"Intento de retiro: {e.cantidad_retiro}")

# Múltiples excepciones y else/finally
def procesar_archivo(nombre_archivo):
    try:
        with open(nombre_archivo, 'r') as archivo:
            contenido = archivo.read()
            print("Archivo leído exitosamente")
    except FileNotFoundError:
        print(f"El archivo {nombre_archivo} no existe")
    except PermissionError:
        print(f"No tienes permisos para leer {nombre_archivo}")
    except UnicodeDecodeError:
        print(f"Error decodificando el archivo {nombre_archivo}")
    except Exception as e:
        print(f"Error inesperado: {e}")
    else:
        # Se ejecuta solo si no hubo excepciones
        print(f"Contenido del archivo:\n{contenido[:100]}...")
    finally:
        # Siempre se ejecuta, haya o no errores
        print("Procesamiento de archivo completado")

procesar_archivo("archivo_inexistente.txt")

# Capturar y relanzar excepciones
def proceso_complejo():
    try:
        # Código que puede fallar
        resultado = 10 / 0
    except ZeroDivisionError as e:
        print("Error capturado, agregando contexto y relanzando")
        # Podemos agregar contexto y relanzar
        raise RuntimeError("Error en proceso complejo") from e

try:
    proceso_complejo()
except RuntimeError as e:
    print(f"Error final: {e}")
    print(f"Causa original: {e.__cause__}")

Paso 6: Trabajo con Colecciones Avanzadas

Explora estructuras de datos especializadas del módulo collections para optimizar tu código Python.

from collections import defaultdict, Counter, deque, namedtuple

# defaultdict - diccionario con valor por defecto
frutas = ['manzana', 'banana', 'naranja', 'manzana', 'uva', 'banana']
conteo_frutas = defaultdict(int)

for fruta in frutas:
    conteo_frutas[fruta] += 1

print(f"Conteo de frutas: {dict(conteo_frutas)}")

# Uso con listas como valores por defecto
personas_ciudad = defaultdict(list)
datos = [('Madrid', 'Ana'), ('Barcelona', 'Carlos'), ('Madrid', 'Elena')]

for ciudad, persona in datos:
    personas_ciudad[ciudad].append(persona)

print(f"Personas por ciudad: {dict(personas_ciudad)}")

# Counter - conteo eficiente de elementos
conteo = Counter(frutas)
print(f"Conteo con Counter: {conteo}")
print(f"Tres frutas más comunes: {conteo.most_common(3)}")

# deque - lista eficiente para operaciones en ambos extremos
cola = deque([1, 2, 3])
cola.append(4)       # Añadir al final
cola.appendleft(0)   # Añadir al inicio
print(f"Deque: {cola}")

ultimo = cola.pop()  # Eliminar del final
primero = cola.popleft()  # Eliminar del inicio
print(f"Deque después de pop: {cola}")

# namedtuple - tuplas con campos nombrados
Persona = namedtuple('Persona', ['nombre', 'edad', 'ciudad'])
ana = Persona('Ana', 25, 'Madrid')
print(f"Persona: {ana}")
print(f"Nombre: {ana.nombre}, Edad: {ana.edad}")

# Convertir a diccionario
print(f"Como diccionario: {ana._asdict()}")

# Crear desde iterable
datos = ['Carlos', 30, 'Barcelona']
carlos = Persona._make(datos)
print(f"Otra persona: {carlos}")

Paso 7: Programación Funcional Intermedia

Descubre conceptos de programación funcional con functools e itertools para escribir código más elegante.

from functools import partial, reduce, lru_cache
from itertools import chain, cycle, permutations, combinations

# partial - función con argumentos predefinidos
def potencia(base, exponente):
    return base ** exponente

cuadrado = partial(potencia, exponente=2)
cubo = partial(potencia, exponente=3)

print(f"5 al cuadrado: {cuadrado(5)}")
print(f"5 al cubo: {cubo(5)}")

# reduce - aplicar función acumulativa
numeros = [1, 2, 3, 4, 5]
producto = reduce(lambda x, y: x * y, numeros)
print(f"Producto de {numeros}: {producto}")

# lru_cache - memoización automática
@lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(f"Fibonacci de 10: {fibonacci(10)}")
print(f"Info de cache: {fibonacci.cache_info()}")

# itertools.chain - combinar iterables
lista1 = [1, 2, 3]
lista2 = [4, 5, 6]
lista3 = [7, 8, 9]

combinada = list(chain(lista1, lista2, lista3))
print(f"Listas combinadas: {combinada}")

# itertools.cycle - ciclo infinito
contador = 0
for elemento in cycle(['A', 'B', 'C']):
    print(elemento, end=' ')
    contador += 1
    if contador >= 10:
        break
print()

# Permutaciones y combinaciones
letras = ['A', 'B', 'C']
print("Permutaciones de 2:")
for p in permutations(letras, 2):
    print(p)

print("Combinaciones de 2:")
for c in combinations(letras, 2):
    print(c)

Paso 8: Manejo de JSON Avanzado

Aprende técnicas avanzadas para trabajar con JSON, incluyendo serialización personalizada y manejo de archivos grandes.

import json
from datetime import datetime
from decimal import Decimal

# Clase personalizada para serialización
class Producto:
    def __init__(self, nombre, precio, stock):
        self.nombre = nombre
        self.precio = precio
        self.stock = stock
        self.fecha_actualizacion = datetime.now()

    def to_dict(self):
        return {
            'nombre': self.nombre,
            'precio': float(self.precio),  # Convertir Decimal a float
            'stock': self.stock,
            'fecha_actualizacion': self.fecha_actualizacion.isoformat()
        }

# Serializador personalizado
class EncoderPersonalizado(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.isoformat()
        if isinstance(obj, Decimal):
            return float(obj)
        if hasattr(obj, 'to_dict'):
            return obj.to_dict()
        return super().default(obj)

# Crear objetos complejos
productos = [
    Producto("Laptop", Decimal("999.99"), 10),
    Producto("Mouse", Decimal("25.50"), 50),
    Producto("Teclado", Decimal("75.00"), 25)
]

# Serializar con encoder personalizado
json_str = json.dumps({
    'fecha_consulta': datetime.now(),
    'productos': productos,
    'total_productos': len(productos)
}, cls=EncoderPersonalizado, indent=2)

print("JSON serializado:")
print(json_str)

# Deserializar con object_hook
def desde_json(dct):
    if 'fecha_consulta' in dct:
        dct['fecha_consulta'] = datetime.fromisoformat(dct['fecha_consulta'])
    return dct

datos_recuperados = json.loads(json_str, object_hook=desde_json)
print("\nDatos recuperados:")
print(datos_recuperados)

# Trabajar con archivos JSON grandes
def procesar_json_grande(archivo_json):
    """Procesa un archivo JSON grande sin cargarlo completo en memoria."""
    with open(archivo_json, 'r') as archivo:
        # Para JSON arrays grandes, podemos usar ijson (pip install ijson)
        # Aquí simulamos el procesamiento
        datos = json.load(archivo)
        return sum(item['precio'] * item['stock'] for item in datos['productos'])

# Crear archivo de ejemplo
with open('productos.json', 'w') as f:
    json.dump({
        'productos': [
            {'nombre': 'Producto1', 'precio': 10.0, 'stock': 5},
            {'nombre': 'Producto2', 'precio': 20.0, 'stock': 3}
        ]
    }, f)

valor_inventario = procesar_json_grande('productos.json')
print(f"Valor total del inventario: {valor_inventario}")

Paso 9: Proyecto Integrador - Sistema de Gestión de Tareas

Crea un sistema completo de gestión de tareas que integre todos los conceptos aprendidos en este tutorial.

import json
from datetime import datetime
from pathlib import Path
from collections import defaultdict
from typing import List, Dict, Optional

class Tarea:
    def __init__(self, descripcion: str, prioridad: str = "media", 
                 fecha_limite: Optional[datetime] = None):
        self.descripcion = descripcion
        self.prioridad = prioridad
        self.completada = False
        self.fecha_creacion = datetime.now()
        self.fecha_limite = fecha_limite
        self.id = hash(f"{descripcion}{self.fecha_creacion.timestamp()}")

    def __str__(self) -> str:
        estado = "✓" if self.completada else "✗"
        fecha_limite_str = self.fecha_limite.strftime("%d/%m/%Y") if self.fecha_limite else "Sin fecha"
        return f"[{estado}] {self.descripcion} (Prioridad: {self.prioridad}, Límite: {fecha_limite_str})"

    def to_dict(self) -> Dict:
        return {
            'id': self.id,
            'descripcion': self.descripcion,
            'prioridad': self.prioridad,
            'completada': self.completada,
            'fecha_creacion': self.fecha_creacion.isoformat(),
            'fecha_limite': self.fecha_limite.isoformat() if self.fecha_limite else None
        }

    @classmethod
    def desde_dict(cls, datos: Dict) -> 'Tarea':
        tarea = cls(datos['descripcion'], datos['prioridad'])
        tarea.id = datos['id']
        tarea.completada = datos['completada']
        tarea.fecha_creacion = datetime.fromisoformat(datos['fecha_creacion'])
        if datos['fecha_limite']:
            tarea.fecha_limite = datetime.fromisoformat(datos['fecha_limite'])
        return tarea

class GestorTareasAvanzado:
    def __init__(self, archivo: str = "tareas.json"):
        self.archivo = Path(archivo)
        self.tareas: Dict[int, Tarea] = {}
        self.cargar_tareas()

    def cargar_tareas(self) -> None:
        if self.archivo.exists():
            try:
                with open(self.archivo, 'r') as f:
                    datos = json.load(f)
                    self.tareas = {tarea_data['id']: Tarea.desde_dict(tarea_data) 
                                  for tarea_data in datos}
            except (json.JSONDecodeError, KeyError) as e:
                print(f"Error cargando tareas: {e}")
                self.tareas = {}

    def guardar_tareas(self) -> None:
        with open(self.archivo, 'w') as f:
            json.dump([tarea.to_dict() for tarea in self.tareas.values()], f, indent=2)

    def agregar_tarea(self, descripcion: str, **kwargs) -> int:
        tarea = Tarea(descripcion, **kwargs)
        self.tareas[tarea.id] = tarea
        self.guardar_tareas()
        return tarea.id

    def completar_tarea(self, id_tarea: int) -> bool:
        if id_tarea in self.tareas:
            self.tareas[id_tarea].completada = True
            self.guardar_tareas()
            return True
        return False

    def eliminar_tarea(self, id_tarea: int) -> bool:
        if id_tarea in self.tareas:
            del self.tareas[id_tarea]
            self.guardar_tareas()
            return True
        return False

    def filtrar_tareas(self, completadas: Optional[bool] = None, 
                       prioridad: Optional[str] = None) -> List[Tarea]:
        tareas_filtradas = self.tareas.values()

        if completadas is not None:
            tareas_filtradas = [t for t in tareas_filtradas if t.completada == completadas]

        if prioridad:
            tareas_filtradas = [t for t in tareas_filtradas if t.prioridad == prioridad]

        return tareas_filtradas

    def estadisticas(self) -> Dict:
        total = len(self.tareas)
        completadas = sum(1 for t in self.tareas.values() if t.completada)

        por_prioridad = defaultdict(int)
        for tarea in self.tareas.values():
            por_prioridad[tarea.prioridad] += 1

        return {
            'total': total,
            'completadas': completadas,
            'pendientes': total - completadas,
            'por_prioridad': dict(por_prioridad),
            'porcentaje_completadas': (completadas / total * 100) if total > 0 else 0
        }

    def mostrar_tareas(self, tareas: Optional[List[Tarea]] = None) -> None:
        tareas = tareas or list(self.tareas.values())

        if not tareas:
            print("No hay tareas para mostrar.")
            return

        for i, tarea in enumerate(tareas, 1):
            print(f"{i}. {tarea}")

# Uso del sistema
def main():
    gestor = GestorTareasAvanzado()

    while True:
        print("\n--- GESTOR DE TAREAS AVANZADO ---")
        print("1. Agregar tarea")
        print("2. Completar tarea")
        print("3. Eliminar tarea")
        print("4. Mostrar todas las tareas")
        print("5. Mostrar tareas pendientes")
        print("6. Mostrar tareas completadas")
        print("7. Mostrar estadísticas")
        print("8. Salir")

        opcion = input("Selecciona una opción: ")

        if opcion == "1":
            descripcion = input("Descripción de la tarea: ")
            prioridad = input("Prioridad (alta/media/baja) [media]: ") or "media"
            fecha_limite = input("Fecha límite (YYYY-MM-DD) [opcional]: ")

            kwargs = {'prioridad': prioridad}
            if fecha_limite:
                try:
                    kwargs['fecha_limite'] = datetime.strptime(fecha_limite, "%Y-%m-%d")
                except ValueError:
                    print("Formato de fecha incorrecto. Usa YYYY-MM-DD")
                    continue

            gestor.agregar_tarea(descripcion, **kwargs)
            print("Tarea agregada exitosamente.")

        elif opcion == "2":
            gestor.mostrar_tareas(gestor.filtrar_tareas(completadas=False))
            try:
                id_tarea = int(input("ID de la tarea a completar: "))
                if gestor.completar_tarea(id_tarea):
                    print("Tarea marcada como completada.")
                else:
                    print("ID de tarea no válido.")
            except ValueError:
                print("Por favor, ingresa un número válido.")

        elif opcion == "3":
            gestor.mostrar_tareas()
            try:
                id_tarea = int(input("ID de la tarea a eliminar: "))
                if gestor.eliminar_tarea(id_tarea):
                    print("Tarea eliminada exitosamente.")
                else:
                    print("ID de tarea no válido.")
            except ValueError:
                print("Por favor, ingresa un número válido.")

        elif opcion == "4":
            print("\n--- TODAS LAS TAREAS ---")
            gestor.mostrar_tareas()

        elif opcion == "5":
            print("\n--- TAREAS PENDIENTES ---")
            pendientes = gestor.filtrar_tareas(completadas=False)
            gestor.mostrar_tareas(pendientes)

        elif opcion == "6":
            print("\n--- TAREAS COMPLETADAS ---")
            completadas = gestor.filtrar_tareas(completadas=True)
            gestor.mostrar_tareas(completadas)

        elif opcion == "7":
            print("\n--- ESTADÍSTICAS ---")
            stats = gestor.estadisticas()
            print(f"Total tareas: {stats['total']}")
            print(f"Completadas: {stats['completadas']}")
            print(f"Pendientes: {stats['pendientes']}")
            print(f"Porcentaje completadas: {stats['porcentaje_completadas']:.1f}%")
            print("Por prioridad:")
            for prioridad, cantidad in stats['por_prioridad'].items():
                print(f"  {prioridad}: {cantidad}")

        elif opcion == "8":
            print("¡Hasta luego!")
            break

        else:
            print("Opción no válida. Intenta de nuevo.")

if __name__ == "__main__":
    main()

Paso 10: Próximos Pasos y Recursos

¡Felicidades! Has completado este tutorial de Python intermedio. Ahora tienes las herramientas para escribir código más eficiente y profesional.

Recursos para Continuar Aprendiendo:

• Plataformas de práctica: LeetCode, HackerRank, Codewars
• Proyectos open source: Contribuye en GitHub
• Desarrollo web: Flask o Django
• Análisis de datos: Pandas, NumPy, Matplotlib
• Testing avanzado: pytest

Conceptos Avanzados:

• Programación asíncrona con asyncio
• Patrones de diseño
• Estructuras de datos avanzadas
• Metaprogramación

Libros Recomendados:

• "Fluent Python" de Luciano Ramalho
• "Python Tricks" de Dan Bader
• Real Python (realpython.com)

Conclusión

¡Has dominado los conceptos esenciales de Python intermedio! Estas técnicas te prepararán para proyectos profesionales y te abrirán las puertas a temas más avanzados. Practica regularmente y continúa explorando.

Para más tutoriales sobre Python y desarrollo, visita nuestra sección de tutoriales.

¡Con estos conocimientos ya puedes trabajar con técnicas avanzadas en Python!

💡 Mejores Prácticas para Python Intermedio

📝 Consejos para Desarrollo Eficiente

• Usa comprensiones: Para código más conciso y legible
• Pathlib sobre os: Para manejo moderno de archivos
• Decoradores: Para código reutilizable y modular
• Excepciones personalizadas: Para mejor manejo de errores
• Collections: Para estructuras de datos optimizadas
• Programación funcional: Para código más elegante

📚 Documentación: Revisa la documentación oficial de Python aquí

¡Estos consejos te ayudarán a escribir código Python más profesional y eficiente!