Tuttavia, è possibile ottenere il parallelismo usando il multiprocessing, che bypassa il GIL creando più processi. Ecco come è possibile implementare l'elaborazione parallela in Python usando una libreria `per` per loop e la libreria` multiprocessing ':
Metodo 1:usando `multiprocessing.pool.map` (più semplice per molte operazioni identiche)
Questo è l'approccio più semplice se ogni iterazione del tuo loop esegue la stessa operazione su dati diversi. `Pool.map` distribuisce in modo efficiente il lavoro su più processi.
`` `Python
Import Multiprocessing
def processo_item (elemento):
"" "La funzione da eseguire in parallelo per ogni elemento." ""
# Il tuo codice per elaborare un singolo elemento va qui
# ... un po 'di calcolo ...
Risultato di restituzione # restituisce il risultato del calcolo
Se __name__ =='__main__':# importante per la compatibilità di Windows
dati =[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # i tuoi dati
con multiprocessing.pool (processi =multiprocessing.cpu_count ()) come pool:
Risultati =pool.map (process_item, dati)
Stampa (risultati)
`` `
Questo codice crea un pool di processi di lavoro (pari al numero di core della CPU per impostazione predefinita). `pool.map` applica` processo_item` per ogni elemento in `data` contemporaneamente e restituisce un elenco dei risultati nello stesso ordine dell'input.
Metodo 2:usando `multiprocessing.pool.apply_async` (per scenari più complessi o operazioni asincroni)
Se il tuo ciclo comporta una logica più complessa o operazioni asincroni, `Applica_Async` offre un maggiore controllo.
`` `Python
Import Multiprocessing
def processo_item (elemento):
# ... il tuo codice ...
risultato di ritorno
Se __Name__ =='__main__':
Dati =[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Risultati =[]
con multiprocessing.pool (processi =multiprocessing.cpu_count ()) come pool:
# Applic_async restituisce un oggetto asyncresult
async_results =[pool.apply_async (process_item, (elemento,)) per elemento nei dati]
# Ottieni i risultati (blocco fino al completamento di tutti i processi)
per async_result in async_results:
Results.Append (async_result.get ())
Stampa (risultati)
`` `
`Applica_async` consente di inviare attività individualmente e recuperare i risultati in seguito. Ciò è utile se il tempo di elaborazione per ciascun elemento varia in modo significativo.
Considerazioni importanti:
* `if __name__ =='__main __':`: Questo è cruciale, specialmente su Windows, per prevenire la creazione di processo ricorsivo.
* Condivisione dei dati: Evita di condividere dati mutabili direttamente tra i processi. Utilizzare tecniche come code o tubi per la comunicazione tra processo per prevenire le condizioni di gara.
* Overhead: La creazione e la gestione dei processi ha un sovraccarico. L'elaborazione parallela è più vantaggiosa per le attività computazionalmente intensive in cui il tempo di elaborazione supera significativamente il sovraccarico.
* Numero di processi: Il numero ottimale di processi spesso equivale al numero di core della CPU, ma potrebbe essere necessaria la sperimentazione.
Ricorda di sostituire `# ... il tuo codice ...` con il tuo vero calcolo. Scegli il metodo che si adatta meglio alla struttura e alla complessità delle operazioni del tuo loop. Per operazioni semplici e parallele, `pool.map` è di solito l'approccio preferito ed efficiente.
Programmazione © www.354353.com