1. `multiprocesamiento.pool` para tareas unidas a CPU:
Esto es adecuado cuando sus iteraciones de bucle son independientes y computacionalmente intensivas (unidas a CPU). Es eficiente para distribuir el trabajo en múltiples núcleos de CPU.
`` `Python
importar multiprocesamiento
def my_function (i):
"" "La función se ejecutará en paralelo". ""
# Tu código aquí ...
resultado =I * 2 # Ejemplo
Resultado de retorno
Si __name__ =='__main__':
con multiprocesamiento.pool (procesos =multiprocessing.cpu_count ()) como grupo:
Resultados =Pool.map (my_function, rango (10)) # rango (10) es su rango de bucle 'para'
Imprimir (resultados) # Salida:[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
`` `` ``
`multiprocesamiento.pool.map` aplica` my_function` a cada elemento en `rango (10)` en paralelo. `multiprocesamiento.cpu_count ()` determina el número óptimo de procesos. Ajuste esto en función de su sistema y la cantidad de núcleos disponibles. Recuerde el `if __name__ =='__main __':` El bloque es crucial para el multiprocesamiento adecuado en las ventanas.
2. `concurrente.futures.processpoolexecutor` (más flexible):
Esto ofrece más control y flexibilidad que `multiprocesamiento.pool`, particularmente si necesita más control o manejo de errores de grano fino.
`` `Python
importación concurrente.
def my_function (i):
# Tu código aquí ...
resultado =i * 2
return i, resultado #retornando el índice original y el resultado es útil para realizar un seguimiento
Si __name__ =='__main__':
con concurrent.futures.processpoolexecutor () como ejecutor:
resultados =ejecutor.map (my_function, rango (10))
Para I, resulta en resultados:
print (f "entrada:{i}, salida:{resultado}")
`` `` ``
`Ejecutor.map` es similar a` Pool.Map`, pero permite que las excepciones sean y manejen. También puede usar `Executor.submit` para un control más asíncrono.
3. `joblib` para una sintaxis más simple (a menudo más rápido):
`Joblib` simplifica el procesamiento paralelo, especialmente para matrices numpy. A menudo funciona mejor que 'multiprocesamiento' para operaciones numéricas específicas.
`` `Python
de la importación de joblib paralelo, retrasado
def my_function (i):
# Tu código aquí ...
resultado =i * 2
Resultado de retorno
Si __name__ =='__main__':
Resultados =paralelo (n_jobs =multiprocessing.cpu_count ()) (retrasado (my_function) (i) para i en el rango (10))
Imprimir (resultados)
`` `` ``
`Joblib` maneja automáticamente la distribución de tareas y la agregación de resultados. `n_jobs` especifica el número de procesos paralelos.
Consideraciones importantes:
* Overhead: El procesamiento paralelo introduce gastos generales de la creación y comunicación de procesos. Para tareas muy pequeñas, la sobrecarga podría superar los beneficios.
* Compartir datos: Evite compartir datos mutables directamente entre procesos; En su lugar, pase copias o use mecanismos de comunicación entre procesos (colas, tuberías) si es necesario.
* Dependencias: Asegúrese de que sus funciones y sus dependencias estén debidamente empaquetadas y disponibles para cada proceso de trabajadores.
* Tareas de enlace I/O: Si su bucle implica operaciones significativas de E/S (por ejemplo, solicitudes de red, lecturas de archivos), el uso de `multiprocesamiento` podría no proporcionar aceleras significativas. Considere `Asyncio` o` Threading` (aunque `Threading` está limitado por el Lock Global Interpreter (GIL) en CPython).
Elija el enfoque que mejor se adapte a sus necesidades y las características de su tarea. Para casos simples, `joblib` a menudo proporciona la solución más fácil y eficiente. Para escenarios más complejos con operaciones asincrónicas o control de grano fino, `concurrente.futures` es más poderoso. Recuerde perfilar siempre su código para determinar las ganancias de rendimiento reales.