multiprocessing.Pool: ¿Cuándo usar apply, apply_async o map?

Estate atento ya que en este escrito hallarás el hallazgo que buscas.Esta noticia fue evaluado por nuestros expertos para garantizar la calidad y veracidad de nuestro post.

Solución:

En los viejos tiempos de Python, para llamar a una función con argumentos arbitrarios, usarías apply:

apply(f,args,kwargs)

apply todavía existe en Python2.7 aunque no en Python3, y generalmente ya no se usa. Hoy en día,

f(*args,**kwargs)

se prefiere. los multiprocessing.Pool Los módulos intentan proporcionar una interfaz similar.

Pool.apply es como piton applyexcepto que la llamada a la función se realiza en un proceso separado. Pool.apply bloques hasta que se completa la función.

Pool.apply_async también es como el integrado de Python apply, excepto que la llamada regresa inmediatamente en lugar de esperar el resultado. Un AsyncResult se devuelve el objeto. llamas a su get() método para recuperar el resultado de la llamada a la función. los get() bloques de método hasta que se completa la función. Por lo tanto, pool.apply(func, args, kwargs) es equivalente a pool.apply_async(func, args, kwargs).get().

En contraste con Pool.applylos Pool.apply_async El método también tiene una devolución de llamada que, si se proporciona, se llama cuando se completa la función. Esto se puede usar en lugar de llamar get().

Por ejemplo:

import multiprocessing as mp
import time

def foo_pool(x):
    time.sleep(2)
    return x*x

result_list = []
def log_result(result):
    # This is called whenever foo_pool(i) returns a result.
    # result_list is modified only by the main process, not the pool workers.
    result_list.append(result)

def apply_async_with_callback():
    pool = mp.Pool()
    for i in range(10):
        pool.apply_async(foo_pool, args = (i, ), callback = log_result)
    pool.close()
    pool.join()
    print(result_list)

if __name__ == '__main__':
    apply_async_with_callback()

puede dar un resultado como

[1, 0, 4, 9, 25, 16, 49, 36, 81, 64]

Fíjate, a diferencia pool.mapel orden de los resultados puede no corresponder al orden en que se pool.apply_async se hicieron llamadas.

---

Entonces, si necesita ejecutar una función en un proceso separado, pero desea que el proceso actual cuadra hasta que esa función regrese, use Pool.apply. Me gusta Pool.apply, Pool.map bloques hasta que se devuelve el resultado completo.

Si desea que el grupo de procesos de trabajo realice muchas llamadas a funciones de forma asíncrona, use Pool.apply_async. los pedido No se garantiza que los resultados sean los mismos que el orden de las llamadas a Pool.apply_async.

Tenga en cuenta también que puede llamar a un número de diferente funciones con Pool.apply_async (no todas las llamadas necesitan usar la misma función).

A diferencia de, Pool.map aplica la misma función a muchos argumentos. Sin embargo, a diferencia de Pool.apply_asynclos resultados se devuelven en un orden correspondiente al orden de los argumentos.

Con respecto a apply contra map:

pool.apply(f, args): f sólo se ejecuta en UNO de los trabajadores de la piscina. Entonces UNO de los procesos en el grupo se ejecutará f(args).

pool.map(f, iterable): este método corta el iterable en varios fragmentos que envía al grupo de procesos como tareas separadas. Así aprovechas todos los procesos en el pool.

Aquí hay una descripción general en formato de tabla para mostrar las diferencias entre Pool.apply, Pool.apply_async, Pool.map y Pool.map_async. Al elegir uno, debe tener en cuenta los argumentos múltiples, la concurrencia, el bloqueo y el orden:

                  | Multi-args   Concurrence    Blocking     Ordered-results
---------------------------------------------------------------------
Pool.map          | no           yes            yes          yes
Pool.map_async    | no           yes            no           yes
Pool.apply        | yes          no             yes          no
Pool.apply_async  | yes          yes            no           no
Pool.starmap      | yes          yes            yes          yes
Pool.starmap_async| yes          yes            no           no

Notas:

• Pool.imap y Pool.imap_async – versión más perezosa de map y map_async.

• Pool.starmap método, muy similar al método map además de la aceptación de múltiples argumentos.

• Async Los métodos envían todos los procesos a la vez y recuperan los resultados una vez que finalizan. Utilice el método get para obtener los resultados.

• Pool.map(o Pool.apply) Los métodos son muy similares al mapa incorporado de Python (o aplicar). Bloquean el proceso principal hasta que todos los procesos se completan y devuelven el resultado.

Ejemplos:

mapa

Se llama para una lista de trabajos en una sola vez

results = pool.map(func, [1, 2, 3])

aplicar

Solo se puede llamar para un trabajo

for x, y in [[1, 1], [2, 2]]:
    results.append(pool.apply(func, (x, y)))

def collect_result(result):
    results.append(result)

map_async

Se llama para una lista de trabajos en una sola vez

pool.map_async(func, jobs, callback=collect_result)

apply_async

Solo se puede llamar para un trabajo y ejecuta un trabajo en segundo plano en paralelo

for x, y in [[1, 1], [2, 2]]:
    pool.apply_async(worker, (x, y), callback=collect_result)

mapa estelar

es una variante de pool.map que soportan múltiples argumentos

pool.starmap(func, [(1, 1), (2, 1), (3, 1)])

starmap_async

Una combinación de starmap() y map_async() que itera sobre iterable de iterables y llama a func con los iterables desempaquetados. Devuelve un objeto de resultado.

pool.starmap_async(calculate_worker, [(1, 1), (2, 1), (3, 1)], callback=collect_result)

Referencia:

Encuentre la documentación completa aquí: https://docs.python.org/3/library/multiprocessing.html

Valoraciones y comentarios

Recuerda que puedes difundir este tutorial si te fue útil.

---

---

Utiliza Nuestro Buscador