1. `multiprocessing.pool` per attività legate alla CPU:
Questo è adatto quando le iterazioni del loop sono indipendenti e intensive computazionalmente (legate alla CPU). È efficiente per la distribuzione di lavori su più core della CPU.
`` `Python
Import Multiprocessing
def my_function (i):
"" "La funzione da eseguire in parallelo." ""
# Il tuo codice qui ...
risultato =i * 2 # esempio
risultato di ritorno
Se __Name__ =='__main__':
con multiprocessing.pool (processi =multiprocessing.cpu_count ()) come pool:
Risultati =pool.map (my_function, intervallo (10)) # intervallo (10) è il tuo 'per' gamma di loop
Stampa (risultati) # output:[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
`` `
`multiprocessing.pool.map` applica` my_function` per ogni elemento in `intervallo (10)` in parallelo. `multiprocessing.cpu_count ()` determina il numero ottimale di processi. Regola questo in base al sistema e al numero di core disponibili. Ricorda `if __name__ =='__main __':` Block è cruciale per la corretta multiprocesso su Windows.
2. `concurrent.futures.processpoolexecutor` (più flessibile):
Ciò offre più controllo e flessibilità di `multiprocessing.pool`, in particolare se hai bisogno di più controllo a grana fine o gestione degli errori.
`` `Python
Importazione Concurrent.Futures
def my_function (i):
# Il tuo codice qui ...
risultato =i * 2
Restituzione I, risultato #restituzione dell'indice originale e il risultato è utile per tenere traccia
Se __Name__ =='__main__':
con concurrent.futures.processpoolexecutor () come esecutore:
Risultati =Executor.Map (my_function, intervallo (10))
Per io, risultati in risultati:
print (f "input:{i}, output:{risultato}")
`` `
`Executor.map` è simile a` pool.map`, ma consente di aumentare e gestire le eccezioni. Puoi anche usare `Executor.submit` per un controllo più asincrono.
3. `joblib` per sintassi più semplice (spesso più veloce):
`Joblib` semplifica l'elaborazione parallela, specialmente per gli array numpy. Spesso funziona meglio del "multiprocessing" per operazioni numeriche specifiche.
`` `Python
da joblib import parallele, ritardato
def my_function (i):
# Il tuo codice qui ...
risultato =i * 2
risultato di ritorno
Se __Name__ =='__main__':
Risultati =parallele (n_jobs =multiprocessing.cpu_count ()) (ritardato (my_function) (i) per i nell'intervallo (10))
Stampa (risultati)
`` `
`Joblib` Gestisce automaticamente la distribuzione delle attività e l'aggregazione dei risultati. `N_JOBS` specifica il numero di processi paralleli.
Considerazioni importanti:
* Overhead: L'elaborazione parallela introduce le spese generali dalla creazione e comunicazione del processo. Per compiti molto piccoli, le spese generali potrebbero superare i benefici.
* Condivisione dei dati: Evitare di condividere dati mutabili direttamente tra i processi; Invece, passa copie o usa i meccanismi di comunicazione tra process (code, tubi) se necessario.
* Dipendenze: Assicurati che le tue funzioni e le loro dipendenze siano adeguatamente confezionate e disponibili per ogni processo di lavoratore.
* Attività legate a I/O: Se il tuo loop prevede operazioni di I/O significative (ad es. Richieste di rete, letture dei file), l'uso di `multiprocessing` potrebbe non fornire accelerazioni significative. Considera invece `asyncio` o` threading` (sebbene `threading` sia limitato dal blocco dell'interprete globale (GIL) in cpython).
Scegli l'approccio che si adatta meglio alle tue esigenze e alle caratteristiche del tuo compito. Per casi semplici, `Joblib` fornisce spesso la soluzione più semplice ed efficiente. Per scenari più complessi con operazioni asincroni o controllo a grana fine, `concomitante.futures` è più potente. Ricorda di profilare sempre il tuo codice per determinare i guadagni delle prestazioni effettivi.
Programmazione © www.354353.com