GuíaAvanzado
Guía de Performance y Profiling
La intuición sobre qué hace lento a un programa casi siempre miente, y optimizar sin medir es la forma más común de perder tiempo arreglando la parte que no era el problema. Esta guía enseña el proceso completo de optimización con la única regla que importa: medir primero, cambiar después. Trabajas sobre un solo caso realista —Nómada, una herramienta de línea de comandos que procesa registros de viaje de una flota de vehículos y tarda cuatro minutos en generar un reporte mensual— y lo llevas a los pocos segundos usando el método real: cronometrar con el reloj correcto, perfilar con `cProfile` para encontrar dónde se va el tiempo de verdad (que casi nunca es donde el equipo cree), medir el costo de memoria, elegir la estructura de datos correcta para el problema, y aplicar la optimización específica que corresponde a cada cuello de botella real. La guía también enseña a reconocer cuándo Python puro ya no alcanza y hay que empujar el trabajo a código vectorizado, y cómo documentar y proteger una optimización para que no se pierda en el próximo refactor. El proyecto final exige el reporte honesto de qué cambió, cuánto ganó cada cambio y qué se decidió NO optimizar y por qué.
- 64
- lecciones
- 8
- módulos
- Inglés · Español
- disponible en
- Sí
- certificado
- Gratis
- acceso
Resultados
Lo que vas a poder hacer
- Cronometrar código con el reloj correcto y evitar la trampa del micro-benchmark que mide algo distinto de lo que importa en producción
- Usar el profiler de Python (`cProfile`) para encontrar el cuello de botella real de un programa, distinguiendo tiempo propio de tiempo acumulado
- Medir el consumo de memoria de un programa y reconocer cuándo una estructura de datos no cabe y hay que usar generadores o procesamiento por lotes
- Elegir entre lista, conjunto y diccionario según el patrón de acceso real, entendiendo el costo escondido de operaciones como `in`
- Aplicar optimizaciones concretas sobre un cuello de botella ya identificado: sacar trabajo de un bucle caliente, memoización, evaluación perezosa, reducir llamadas a función
- Reconocer cuándo un cambio de algoritmo le gana a mil micro-optimizaciones de sintaxis
- Identificar cuándo Python puro ya no alcanza y el trabajo debe empujarse a arreglos numéricos y operaciones vectorizadas
- Documentar por qué una porción de código optimizado se ve "rara", y escribir pruebas de rendimiento que avisen si la mejora se degrada con el tiempo
- Verificar que una optimización sigue dando el resultado correcto, no solo que es más rápida
- Reportar con honestidad qué se optimizó, cuánto se ganó, qué costó en legibilidad y qué se dejó deliberadamente sin tocar
Antes de empezar
Qué necesitas traer
Es para ti si...
- Desarrolladores Python de nivel intermedio con un script o servicio lento que nunca midieron sistemáticamente por qué
- Devs que ya intentaron "optimizar" cambiando código a ciegas y descubrieron que el tiempo no bajó
- Equipos donde cada persona tiene una teoría distinta de dónde está el cuello de botella y nadie las verificó con un profiler
- Personas preparando entrevistas técnicas donde se pregunta por complejidad algorítmica, uso de memoria o cómo diagnosticar código lento
- Cualquiera que necesite decidir, con criterio y no por moda, cuándo vale la pena optimizar y cuándo el costo de mantenimiento supera la ganancia
Requisitos y materiales
- Saber Python: funciones, clases, estructuras de datos, comprensiones, y haber escrito programas más allá de un ejercicio
- No se requiere experiencia previa con perfilado ni con herramientas de medición de rendimiento
- Conviene haber sentido el problema real: un script que tarda demasiado sin saber por qué, o un cambio que "debería" haber acelerado algo y no cambió nada
- No es necesario conocer concurrencia (async, hilos, procesos) ni bases de datos: esos temas viven en sus propias guías
Contenido
El temario, módulo por módulo
Abre cualquiera para ver sus lecciones.
- 1. Presentación del módulo: la intuición miente
- 2. Por qué no puedes adivinar dónde está lento
- 3. Cronometrar bien: el reloj correcto
- 4. La trampa del micro-benchmark
- 5. Rápido de verdad vs rápido en un caso
- 6. La regla: mide, cambia una cosa, vuelve a medir
- 7. Cuándo NO optimizar
- 8. Proyecto: adivina y luego mide
- 1. Presentación del módulo: el mapa de calor de tu programa
- 2. Tu primer perfil con el profiler de Python
- 3. Leer un perfil sin ahogarte
- 4. Tiempo propio y tiempo acumulado
- 5. La función que se llama un millón de veces
- 6. Perfilar línea por línea
- 7. Perfilar sin distorsionar lo que mides
- 8. Proyecto: encuentra el verdadero cuello de botella
- 1. Presentación del módulo: lo que no ves consumir
- 2. Por qué la memoria importa para la velocidad
- 3. Medir cuánta memoria usa tu programa
- 4. La lista que no cabía: generadores
- 5. Objetos, diccionarios y lo que pesan
- 6. Fugas de memoria en un lenguaje con recolector
- 7. Procesar sin cargar todo a la vez
- 8. Proyecto: haz que Nómada quepa en memoria
- 1. Presentación del módulo: la decisión que más acelera
- 2. Lista, conjunto, diccionario: cuándo cada uno
- 3. Buscar rápido: el costo escondido del `in`
- 4. La complejidad, en cristiano
- 5. Cuando cambiar la estructura cambia todo
- 6. Estructuras de la librería estándar que casi nadie usa
- 7. El costo de construir vs el costo de consultar
- 8. Proyecto: reescribe el cruce de datos
- 1. Presentación del módulo: ahora sí, con el perfil en la mano
- 2. Sacar trabajo del bucle caliente
- 3. Calcular una vez y recordar: caché y memoización
- 4. Trabajo perezoso: no calcular lo que no se usa
- 5. Las funciones de la casa están en C
- 6. Menos llamadas: el costo de llamar una función
- 7. Cuando un mejor algoritmo le gana a mil ajustes
- 8. Proyecto: optimiza el cuello de botella real
- 1. Presentación del módulo: el techo del lenguaje
- 2. Por qué Python es lento (y cuándo no importa)
- 3. Empujar el trabajo a código compilado
- 4. Arreglos numéricos: cuando los datos son números
- 5. Vectorizar en vez de iterar
- 6. La herramienta correcta para el trabajo de datos
- 7. Reconocer cuándo ya no vale la pena en Python
- 8. Proyecto: acelera el cálculo numérico
- 1. Presentación del módulo: optimizar es fácil, mantenerlo no
- 2. Legible o rápido: el tradeoff real
- 3. Documentar por qué este código es raro
- 4. Pruebas de rendimiento que avisan si se degrada
- 5. La optimización que dejó de servir
- 6. Medir en producción, no solo en tu máquina
- 7. El costo de mantener código optimizado
- 8. Proyecto: protege la optimización
- 1. Presentación del módulo: el proceso completo, de principio a fin
- 2. Medir la línea base honesta
- 3. Encontrar los tres cuellos de botella
- 4. Atacar el más grande primero
- 5. Saber cuándo parar
- 6. Verificar que sigue siendo correcto
- 7. Contar lo que ganaste y lo que costó
- 8. Proyecto final: optimiza Nómada de punta a punta
Dudas frecuentes
Lo que suele preguntarse
Sin límite. Es una guía gratuita: entras cuando quieras, las veces que quieras.
No. Los módulos están ordenados de menos a más, pero puedes saltar al que necesites. Tu progreso se guarda por lección.
Lo que haga falta está en «Qué necesitas traer», arriba. Si no aparece nada ahí, puedes empezar desde cero.
En el grupo de WhatsApp del Club, y cada quince días hay un live con un instructor donde se resuelven dudas en vivo.
Sí. Al terminar todas las lecciones se emite automáticamente, con un código verificable que puedes compartir en LinkedIn.
Empieza cuando quieras
Lo que dicen los estudiantes
Estas reseñas son de estudiantes inscritos que completaron al menos el 50% del curso. Moderamos las reseñas solo por motivos de contenido (spam, lenguaje ofensivo, datos personales), nunca por ser críticas o negativas.
Aún no hay reseñas aprobadas.
¡Sé el primero en compartir tu experiencia!