Pasar múltiples parámetros a la función pool.map() en Python

Luego de mucho batallar ya encontramos la solución de este apuro que algunos de nuestros lectores de nuestro espacio han tenido. Si deseas compartir alguna información no dudes en compartir tu comentario.

Solución:

Puedes usar functools.partial por esto (como sospechabas):

from functools import partial

def target(lock, iterable_item):
    for item in iterable_item:
        # Do cool stuff
        if (... some condition here ...):
            lock.acquire()
            # Write to stdout or logfile, etc.
            lock.release()

def main():
    iterable = [1, 2, 3, 4, 5]
    pool = multiprocessing.Pool()
    l = multiprocessing.Lock()
    func = partial(target, l)
    pool.map(func, iterable)
    pool.close()
    pool.join()

Ejemplo:

def f(a, b, c):
    print("  ".format(a, b, c))

def main():
    iterable = [1, 2, 3, 4, 5]
    pool = multiprocessing.Pool()
    a = "hi"
    b = "there"
    func = partial(f, a, b)
    pool.map(func, iterable)
    pool.close()
    pool.join()

if __name__ == "__main__":
    main()

Producción:

hi there 1
hi there 2
hi there 3
hi there 4
hi there 5

Podría usar una función de mapa que permita múltiples argumentos, al igual que la bifurcación de multiprocessing encontrado en pathos.

>>> from pathos.multiprocessing import ProcessingPool as Pool
>>> 
>>> def add_and_subtract(x,y):
...   return x+y, x-y
... 
>>> res = Pool().map(add_and_subtract, range(0,20,2), range(-5,5,1))
>>> res
[(-5, 5), (-2, 6), (1, 7), (4, 8), (7, 9), (10, 10), (13, 11), (16, 12), (19, 13), (22, 14)]
>>> Pool().map(add_and_subtract, *zip(*res))
[(0, -10), (4, -8), (8, -6), (12, -4), (16, -2), (20, 0), (24, 2), (28, 4), (32, 6), (36, 8)]

pathos le permite anidar fácilmente mapas paralelos jerárquicos con múltiples entradas, por lo que podemos ampliar nuestro ejemplo para demostrarlo.

>>> from pathos.multiprocessing import ThreadingPool as TPool
>>> 
>>> res = TPool().amap(add_and_subtract, *zip(*Pool().map(add_and_subtract, range(0,20,2), range(-5,5,1))))
>>> res.get()
[(0, -10), (4, -8), (8, -6), (12, -4), (16, -2), (20, 0), (24, 2), (28, 4), (32, 6), (36, 8)]

Aún más divertido, es construir una función anidada que podamos pasar al Pool. Esto es posible porque pathos usos dillque puede serializar casi cualquier cosa en python.

>>> def build_fun_things(f, g):
...   def do_fun_things(x, y):
...     return f(x,y), g(x,y)
...   return do_fun_things
... 
>>> def add(x,y):
...   return x+y
... 
>>> def sub(x,y):
...   return x-y
... 
>>> neato = build_fun_things(add, sub)
>>> 
>>> res = TPool().imap(neato, *zip(*Pool().map(neato, range(0,20,2), range(-5,5,1))))
>>> list(res)
[(0, -10), (4, -8), (8, -6), (12, -4), (16, -2), (20, 0), (24, 2), (28, 4), (32, 6), (36, 8)]

Sin embargo, si no puede salir de la biblioteca estándar, tendrá que hacerlo de otra manera. Su mejor apuesta en ese caso es usar multiprocessing.starmap como se ve aquí: Python multiprocesamiento pool.map para múltiples argumentos (señalado por @Roberto en los comentarios en la publicación del OP)

Obtener pathos aquí: https://github.com/uqfoundation

Si te sientes motivado, tienes la opción de dejar un ensayo acerca de qué te ha parecido este artículo.

---

---

Utiliza Nuestro Buscador