Python Multiprocessing per loop

Il multiprocessing è paragonabile al multithreading. Tuttavia, si differenzia in quanto possiamo eseguire solo un thread in un momento a causa del GIL che viene impiegato per il threading. Il multiprocessing è il processo di eseguire operazioni in sequenza su diversi core della CPU. I thread non possono essere gestiti in parallelo. Tuttavia, il multiprocessing ci consente di stabilire i processi e eseguirli contemporaneamente su vari core della CPU. Il ciclo, come il per loop, è uno dei linguaggi di scripting più utilizzati. Ripetere lo stesso lavoro utilizzando vari dati fino a quando non viene raggiunto un criterio, come un numero predeterminato di iterazioni. Il ciclo realizza ogni iterazione uno per uno.

Esempio 1: utilizzando il per loop nel modulo multiprocessing Python

In questo esempio, utilizziamo il processo di classe del modulo multiprocessing Python e Python. Iniziamo con un esempio molto semplice in modo da poter capire rapidamente come funziona il python multiprocessing per loop. Utilizzando un'interfaccia paragonabile al modulo di threading, il multiprocessing racchiude la creazione di processi.

Impiegando i sottoprocessi anziché i thread, il pacchetto multiprocessing fornisce una concorrenza locale e lontana, evitando così il blocco dell'interprete globale. Usa un per loop, che può essere un oggetto stringa o una tupla, per iterare continuamente attraverso una sequenza. Questo funziona meno come la parola chiave vista in altri linguaggi di programmazione e più come un metodo iteratore trovato in altri linguaggi di programmazione. Avviando un nuovo multiprocessing, è possibile eseguire un per loop che esegue una procedura contemporaneamente.

Cominciamo implementando il codice per l'esecuzione del codice utilizzando lo strumento "Spyder". Crediamo che "Spyder" sia anche il migliore per gestire Python. Importiamo un processo di modulo multiprocessing che il codice è in esecuzione. Il multiprocessing nel concetto di Python definito una "classe di processo" crea un nuovo processo di Python, gli dà un metodo per eseguire il codice e fornisce all'applicazione genitore un modo per gestire l'esecuzione. La classe di processo contiene le procedure start () e join (), entrambe cruciali.

Successivamente, definiamo una funzione definita dall'utente chiamata "func". Poiché è una funzione definita dall'utente, gli diamo un nome di nostra scelta. All'interno del corpo di questa funzione, passiamo la variabile "soggetto" come argomento e il valore di "matematica". Successivamente, chiamiamo la funzione "Print ()", passando l'affermazione "Il nome dell'argomento comune è" e il suo argomento "soggetto" che contiene il valore. Quindi, nel passaggio seguente, utilizziamo il "se name == _main_", che impedisce di eseguire il codice quando il file viene importato come modulo e consente di farlo solo quando il contenuto viene eseguito come script.

La sezione delle condizioni con cui inizi può essere pensato nella maggior parte dei casi come una posizione per fornire il contenuto che dovrebbe essere eseguito solo quando il file viene eseguito come script. Quindi, usiamo la materia dell'argomento e archiviamo alcuni valori che sono "scienza", "inglese" e "computer". Al processo viene quindi dato il nome "Process1 []" nel passaggio seguente. Quindi, utilizziamo il "processo (target = func)" per chiamare la funzione nel processo. Target viene utilizzato per chiamare la funzione e salviamo questo processo nella variabile "P".

Successivamente, utilizziamo la funzione "Process1" per chiamare la funzione "Append ()" che aggiunge un elemento alla fine dell'elenco che abbiamo nella funzione "Func."Poiché il processo è memorizzato nella variabile" p ", passiamo" p "a questa funzione come argomento. Infine, utilizziamo la funzione "start ()" con "p" per avviare il processo. Successivamente, eseguiamo di nuovo il metodo mentre forniamo l'argomento "soggetto" e usiamo "per" nell'argomento. Quindi, utilizzando ancora una volta il metodo "Process1" e "Add ()", iniziamo il processo. Il processo viene quindi eseguito e l'uscita viene restituita. La procedura viene quindi detto di terminare usando la tecnica "join ()". I processi che non chiamano la procedura "join ()" non usciranno. Un punto cruciale è che il parametro delle parole chiave "Args" deve essere utilizzato se si desidera fornire argomenti attraverso il processo.

Ora, puoi vedere nell'output che l'istruzione viene visualizzata per prima passando il valore per il soggetto "matematica" che passiamo alla funzione "func" perché la chiamiamo per la prima volta usando la funzione "processo". Quindi, utilizziamo il comando "Append ()" per avere valori già nell'elenco che viene aggiunto alla fine. Quindi, sono stati presentati "scienza", "computer" e "inglese". Ma, come puoi vedere, i valori non sono nella sequenza corretta. Questo perché lo fanno rapidamente quanto la procedura è finita e segnala il loro messaggio.

Esempio 2: conversione del per loop sequenziale in loop parallelo multiprocessing

In questo esempio, l'attività ad anello multiprocessing viene eseguita in sequenza prima di essere convertita in un compito parallelo per loop. È possibile scorrere sequenze come una raccolta o una stringa nell'ordine in cui si verificano usando i loop per.

Ora, iniziamo ad implementare il codice. Innanzitutto, importa "sonno" dal modulo Time. Usando la procedura "sleep ()" nel modulo temporale, è possibile sospendere l'esecuzione del thread chiamante per tutto il tempo che desideri. Quindi, usiamo "casuale" dal modulo casuale, definiamo una funzione con il nome "func" e passiamo la parola chiave "argu". Quindi, creiamo un valore casuale usando "Val" e lo impostiamo su "Random". Quindi, blocciamo per un piccolo periodo usando il metodo "sleep ()" e passiamo "val" come parametro. Quindi, per trasmettere un messaggio, eseguiamo il metodo "Print ()", passando le parole "Ready" e la parola chiave "Arg" come parametro, oltre a "Creato" e passiamo il valore usando "Val".

Infine, utilizziamo "flush" e lo impostiamo su "vero". L'utente può decidere se buffer o meno l'output utilizzando l'opzione flush nella funzione di stampa di Python. Il valore predefinito di questo parametro di false indica che l'output non verrà bufferizzato. L'output viene visualizzato come una serie di righe che si seguono se lo si imposta su true. Quindi, utilizziamo "if name == main" per proteggere i punti di iscrizione. Successivamente, eseguiamo il lavoro in sequenza. Qui, impostiamo l'intervallo su "10", il che significa che il ciclo termina dopo 10 iterazioni. Successivamente, chiamiamo la funzione "Print ()", passiamo l'istruzione di input "Ready" e utilizziamo l'opzione "Flush = True".

Ora puoi vedere che quando eseguiamo il codice, il ciclo fa sì che la funzione esegui "10" volte. Iterato fino a 10 volte, iniziando da indice zero e termina all'indice nove. Ogni messaggio contiene un numero di attività che è un numero di funzione che trasmettiamo come "arg" e un numero di creazione.

Questo ciclo sequenziale viene ora trasformato in un parallelo multiprocessing per loop. Usiamo lo stesso codice, ma andiamo ad alcune librerie e funzioni extra per il multiprocesso. Pertanto, dobbiamo importare il processo dal multiprocessing, proprio come abbiamo spiegato in precedenza. Successivamente, creiamo una funzione chiamata "func" e passiamo la parola chiave "arg" prima di usare "val = casuale" per ottenere un numero casuale.

Quindi, dopo aver invocato il metodo "Print ()" per mostrare un messaggio e dare il parametro "Val" per ritardare un piccolo periodo, utilizziamo la funzione "if name = main" per proteggere i punti di iscrizione. Quindi, creiamo un processo e chiamiamo la funzione nel processo usando "processo" e passiamo "target = func". Quindi, passiamo il "func", "arg", passiamo il valore "m" e passiamo l'intervallo "10", il che significa che il ciclo termina la funzione dopo "10" iterazioni. Quindi, iniziamo il processo utilizzando il metodo "start ()" con "processo". Quindi, chiamiamo il metodo "join ()" per attendere l'esecuzione del processo e completare tutto il processo dopo.

Pertanto, quando eseguiamo il codice, le funzioni chiamano il processo principale e iniziano la loro esecuzione. Sono fatti, tuttavia, fino a quando tutti i compiti non saranno compiuti. Possiamo vederlo perché ogni attività viene svolta contemporaneamente. Riporta il suo messaggio non appena è finito. Ciò significa che sebbene i messaggi siano fuori servizio, il ciclo termina dopo che tutte le iterazioni "10" sono state completate.

Conclusione

In questo articolo abbiamo coperto il multiprocessing Python. Abbiamo anche presentato due illustrazioni. La prima illustrazione mostra come utilizzare un per loop nella biblioteca multiprocessing di Python. E la seconda illustrazione mostra come cambiare un per loop sequenziale in un multiprocessing parallelo per loop. Prima di costruire lo script per il multiprocessing di Python, dobbiamo importare il modulo multiprocessing.