Curso online de Programación paralela en Python para optimización de código bonificado

💻 Software

• Python 3.13 — descarga gratuita en python.org. También puedes instalar Anaconda (gratuito) si quieres gestionar entornos virtuales con interfaz gráfica; es la opción que usa el curso.
• VS Code (gratuito) con la extensión Python de Microsoft. Alternativas igualmente válidas: PyCharm Community Edition (gratis), Jupyter Notebook (incluido en Anaconda).
• Git (gratuito) — recomendable para versionar el proyecto final, aunque no es obligatorio.
• Las librerías del curso (threading, multiprocessing, concurrent.futures) forman parte de la biblioteca estándar de Python: no hay que instalar nada de pago.

?️ Hardware

• Ordenador de los últimos 5-6 años (Windows 10/11, macOS Ventura o superior, o Linux).
• 4 GB de RAM mínimo; 8 GB recomendados para ejecutar varios procesos en paralelo sin que el sistema se ralentice.
• Procesador con al menos 2 núcleos — imprescindible para apreciar los beneficios reales del paralelismo. La mayoría de PCs desde 2015 lo cumplen.
• 2 GB de espacio libre en disco para Python, Anaconda y los proyectos.

🔑 Cuentas y servicios

• Cuenta en GitHub (gratuita) — opcional, pero útil para subir el proyecto final.
• No se necesita ningún servicio de pago ni suscripción externa.

📚 Conocimientos previos

• Python intermedio: funciones, clases, listas, diccionarios y manejo básico de excepciones. El temario incluye un apéndice de repaso, pero no está diseñado para aprender Python desde cero.
• Noción básica de qué es un proceso y qué es un hilo (no hace falta haberlos programado, solo saber que existen).
• No se requiere experiencia previa en concurrencia ni en sistemas operativos.

A lo largo del curso construyes piezas funcionales que puedes reutilizar directamente en proyectos reales. Estos son los ejercicios más representativos:

1. Descargador concurrente de archivos — creas un pool de hilos que descarga varios archivos simultáneamente y mide la ganancia de tiempo frente a la versión secuencial. Caso de uso: scrapers, ETL ligeros, bots de monitorización.
2. Procesador paralelo de imágenes o datos CSV — usas ProcessPool para aplicar transformaciones a un lote de ficheros aprovechando todos los núcleos de la CPU. Caso de uso: pipelines de datos, preprocesado en ciencia de datos.
3. Sistema productor-consumidor con colas seguras — implementas colas FIFO, LIFO y de prioridad para coordinar hilos que generan y procesan tareas. Caso de uso: sistemas de mensajería interna, workers de background en aplicaciones web.
4. Simulación de acceso concurrente a recurso compartido — demuestras condiciones de carrera, las reproduces y las resuelves con Lock, RLock y semáforos. Caso de uso: cualquier aplicación con base de datos o fichero compartido entre varios hilos.
5. Pipeline de análisis de datos con sincronización por barreras — varias fases de procesamiento se sincronizan con objetos Barrier para garantizar que todos los procesos terminen cada etapa antes de continuar. Caso de uso: análisis científico por lotes, agregación de métricas en tiempo real.
6. Proyecto final integrador — aplicación completa que combina pools de procesos, eventos, colas y sincronización para resolver un problema de procesamiento intensivo real. Sirve como pieza de portafolio demostrable.

Estos son los errores que aparecen con más frecuencia al empezar con concurrencia en Python. Identificarlos antes te ahorrará horas de depuración:

• Modificar una variable compartida sin lock: varios hilos leen y escriben a la vez, el resultado final es impredecible. Siempre protege el acceso con threading.Lock() o usa tipos thread-safe como queue.Queue.
• Confundir threading con multiprocessing para tareas CPU-intensivas: el GIL impide la ejecución paralela real de hilos en tareas de cómputo puro. Usa multiprocessing o concurrent.futures.ProcessPoolExecutor para ese caso.
• No llamar a join() en hilos o procesos: el programa principal termina antes de que los workers acaben, cortando su ejecución sin aviso. Llama siempre a t.join() o usa el bloque with del executor.
• Crear deadlocks con locks anidados: si el hilo A espera el lock del hilo B y viceversa, el programa se congela. Establece un orden de adquisición consistente o usa RLock cuando el mismo hilo necesita re-adquirir el lock.
• Lanzar demasiados procesos simultáneos: crear un proceso por cada elemento de una lista de miles de ítems colapsa el sistema. Usa un ProcessPool con un tamaño razonable (típicamente igual al número de núcleos).
• Olvidar el bloque if __name__ == "__main__": en Windows: sin él, cada proceso hijo intenta re-ejecutar el módulo principal y el programa entra en un bucle de creación infinita de procesos.
• Compartir objetos no serializables entre procesos: multiprocessing serializa los datos con pickle; lambdas, conexiones de BD abiertas o sockets no son serializables y provocan errores crípticos. Crea estos recursos dentro del proceso hijo.
• Usar time.sleep() como mecanismo de sincronización: asumir que un hilo habrá terminado tras N segundos es frágil. Usa Event, Barrier o join() para sincronización explícita y determinista.

Recursos gratuitos que complementan directamente el contenido del curso y te servirán más allá de él:

📖 Documentación oficial imprescindible

• docs.python.org/3/library/threading.html — referencia completa del módulo threading: Lock, RLock, Event, Condition, Semaphore, Barrier, Timer.
• docs.python.org/3/library/multiprocessing.html — todo sobre multiprocessing: Process, Pool, Queue, Pipe, Manager y memoria compartida.
• docs.python.org/3/library/concurrent.futures.html — API de alto nivel ThreadPoolExecutor y ProcessPoolExecutor con ejemplos claros.

⌨️ Atajos y cheat sheets

• devhints.io — cheat sheets de Python, incluidos patrones de uso rápido para colecciones y clases.
• overapi.com/python — referencia visual rápida de la API de Python.
• Guarda como snippet de VS Code el patrón if __name__ == "__main__": con Pool y join: lo usarás en cada ejercicio de multiprocessing.

?️ Herramientas gratuitas útiles

• Anaconda (gratuito) — gestión de entornos virtuales y Jupyter Notebook integrado; es el entorno que usa el curso.
• Jupyter Notebook — ideal para experimentar con fragmentos de código de hilos pequeños antes de pasar a scripts completos.
• py-spy (pip, gratuito) — profiler de Python en tiempo real; te permite visualizar qué hilos están activos y dónde se bloquean sin modificar el código.
• gitignore.io — genera el .gitignore correcto para proyectos Python en segundos.

👥 Comunidades donde resolver dudas

• stackoverflow.com — busca por etiquetas [python] + [multithreading] o [multiprocessing]; la mayoría de errores clásicos ya están resueltos.
• reddit.com/r/Python y reddit.com/r/learnpython — comunidades activas para preguntas de nivel intermedio-avanzado.
• dev.to — artículos prácticos sobre GIL, asyncio y patrones de concurrencia en Python escritos por desarrolladores en activo.

?️ Práctica adicional

• exercism.io (track Python) — ejercicios con feedback de mentores; útil para afianzar la base antes o durante el curso.
• realpython.com — tutoriales gratuitos específicos sobre threading, multiprocessing y asyncio que complementan el temario con ejemplos alternativos.