Paralelo para Loop em Python

1. Use o módulo multiprocessing para paralelizar o loop for em Python
2. Use o módulo joblib para paralelizar o loop for em Python
3. Use o módulo asyncio para paralelizar o loop for em Python

Paralelizar o loop significa espalhar todos os processos em paralelo usando vários núcleos. Quando temos vários trabalhos, cada cálculo não espera que o anterior no processamento paralelo seja concluído. Em vez disso, ele usa um processador diferente para conclusão.

Neste artigo, iremos paralelizar um loop for em Python.

Use o módulo multiprocessing para paralelizar o loop for em Python

Para paralelizar o loop, podemos usar o pacote multiprocessing em Python, pois ele suporta a criação de um processo filho por solicitação de outro processo em andamento.

O módulo multiprocessing pode ser usado em vez do loop for para executar operações em cada elemento do iterável. Seu objeto multiprocessing.pool() poderia ser usado, já que usar vários threads em Python não daria melhores resultados por causa do Bloqueio do Interpretador Global.

Por exemplo,

import multiprocessing


def sumall(value):
    return sum(range(1, value + 1))


pool_obj = multiprocessing.Pool()

answer = pool_obj.map(sumall, range(0, 5))
print(answer)

Resultado:

0, 1, 3, 6, 10

Use o módulo joblib para paralelizar o loop for em Python

O módulo joblib usa multiprocessamento para executar os vários núcleos da CPU para realizar a paralelização do loop for. Ele fornece um pipeline leve que memoriza o padrão para uma computação paralela fácil e direta.

Para realizar o processamento paralelo, temos que definir o número de trabalhos, e o número de trabalhos é limitado ao número de núcleos na CPU ou quantos estão disponíveis ou ociosos no momento.

A função delayed() nos permite dizer ao Python para chamar um determinado método mencionado após algum tempo.

A função Parallel() cria uma instância paralela com núcleos especificados (2 neste caso).

Precisamos criar uma lista para a execução do código. Em seguida, a lista é passada para o paralelo, que desenvolve dois threads e distribui a lista de tarefas para eles.

Veja o código abaixo.

from joblib import Parallel, delayed
import math


def sqrt_func(i, j):
    time.sleep(1)
    return math.sqrt(i ** j)


Parallel(n_jobs=2)(delayed(sqrt_func)(i, j) for i in range(5) for j in range(2))

Resultado:

[1.0,
 0.0,
 1.0,
 1.0,
 1.0,
 1.4142135623730951,
 1.0,
 1.7320508075688772,
 1.0,
 2.0]

Use o módulo asyncio para paralelizar o loop for em Python

O módulo asyncio é de thread único e executa o loop de eventos suspendendo a co-rotina temporariamente usando os métodos yield from ou await.

O código abaixo será executado em paralelo quando estiver sendo chamado sem afetar a função principal de espera. O loop também funciona em paralelo com a função principal.

import asyncio
import time


def background(f):
    def wrapped(*args, **kwargs):
        return asyncio.get_event_loop().run_in_executor(None, f, *args, **kwargs)

    return wrapped


@background
def your_function(argument):
    time.sleep(2)
    print("function finished for " + str(argument))


for i in range(10):
    your_function(i)


print("loop finished")

Resultado:

ended execution for 4
ended execution for 8
ended execution for 0
ended execution for 3
ended execution for 6
ended execution for 2
ended execution for 5
ended execution for 7
ended execution for 9
ended execution for 1