Pool.map multiprocessing Python pour plusieurs arguments

536

Dans la bibliothèque multiprocessing Python, existe-t-il une variante de pool.map qui prend en charge plusieurs arguments?

text = "test"
def harvester(text, case):
    X = case[0]
    text+ str(X)

if __name__ == '__main__':
    pool = multiprocessing.Pool(processes=6)
    case = RAW_DATASET
    pool.map(harvester(text,case),case, 1)
    pool.close()
    pool.join()
user642897
la source
4
À ma grande surprise, je n'ai pu ni faire partialni lambdafaire ça. Je pense que cela a à voir avec l'étrange façon dont les fonctions sont transmises aux sous-processus (via pickle).
senderle
10
@senderle: Il s'agit d'un bogue dans Python 2.6, mais il a été corrigé à partir de 2.7: bugs.python.org/issue5228
unutbu
1
Remplacez simplement pool.map(harvester(text,case),case, 1) par: pool.apply_async(harvester(text,case),case, 1)
Tung Nguyen
3
@Syrtis_Major, veuillez ne pas modifier les questions OP qui faussent effectivement les réponses qui ont déjà été données. Ajouter returnà harvester()la réponse de @senderie est devenu inexact. Cela n'aide pas les futurs lecteurs.
Ricalsin
1
Je dirais qu'une solution simple serait de regrouper tous les arguments dans un tuple et de le décompresser dans le func en cours d'exécution. J'ai fait cela quand j'avais besoin d'envoyer plusieurs arguments compliqués à une fonction exécutée par un pool de processus.
HS Rathore

Réponses:

358

La réponse à cette question dépend de la version et de la situation. La réponse la plus générale pour les versions récentes de Python (depuis 3.3) a d'abord été décrite ci-dessous par JF Sebastian . 1 Il utilise la Pool.starmapméthode, qui accepte une séquence de tuples d'argument. Il décompresse ensuite automatiquement les arguments de chaque tuple et les transmet à la fonction donnée:

import multiprocessing
from itertools import product

def merge_names(a, b):
    return '{} & {}'.format(a, b)

if __name__ == '__main__':
    names = ['Brown', 'Wilson', 'Bartlett', 'Rivera', 'Molloy', 'Opie']
    with multiprocessing.Pool(processes=3) as pool:
        results = pool.starmap(merge_names, product(names, repeat=2))
    print(results)

# Output: ['Brown & Brown', 'Brown & Wilson', 'Brown & Bartlett', ...

Pour les versions antérieures de Python, vous devrez écrire une fonction d'assistance pour décompresser explicitement les arguments. Si vous souhaitez l'utiliser with, vous devrez également écrire un wrapper pour le transformer Poolen gestionnaire de contexte. (Merci à muon de l' avoir signalé.)

import multiprocessing
from itertools import product
from contextlib import contextmanager

def merge_names(a, b):
    return '{} & {}'.format(a, b)

def merge_names_unpack(args):
    return merge_names(*args)

@contextmanager
def poolcontext(*args, **kwargs):
    pool = multiprocessing.Pool(*args, **kwargs)
    yield pool
    pool.terminate()

if __name__ == '__main__':
    names = ['Brown', 'Wilson', 'Bartlett', 'Rivera', 'Molloy', 'Opie']
    with poolcontext(processes=3) as pool:
        results = pool.map(merge_names_unpack, product(names, repeat=2))
    print(results)

# Output: ['Brown & Brown', 'Brown & Wilson', 'Brown & Bartlett', ...

Dans les cas plus simples, avec un second argument fixe, vous pouvez également utiliser partial, mais uniquement dans Python 2.7+.

import multiprocessing
from functools import partial
from contextlib import contextmanager

@contextmanager
def poolcontext(*args, **kwargs):
    pool = multiprocessing.Pool(*args, **kwargs)
    yield pool
    pool.terminate()

def merge_names(a, b):
    return '{} & {}'.format(a, b)

if __name__ == '__main__':
    names = ['Brown', 'Wilson', 'Bartlett', 'Rivera', 'Molloy', 'Opie']
    with poolcontext(processes=3) as pool:
        results = pool.map(partial(merge_names, b='Sons'), names)
    print(results)

# Output: ['Brown & Sons', 'Wilson & Sons', 'Bartlett & Sons', ...

1. Une grande partie de cela a été inspirée par sa réponse, qui aurait probablement dû être acceptée à la place. Mais comme celui-ci est coincé au sommet, il semblait préférable de l'améliorer pour les futurs lecteurs.

senderle
la source
Il me semble que RAW_DATASET dans ce cas devrait être une variable globale? Alors que je veux que le partial_harvester change la valeur de case dans chaque appel de harvester (). Comment y parvenir?
xgdgsc
La chose la plus importante ici est d'attribuer une =RAW_DATASETvaleur par défaut à case. Sinon, vous pool.mapserez confus au sujet des multiples arguments.
Emerson Xu
1
Je suis confus, qu'est-il arrivé à la textvariable dans votre exemple? Pourquoi est RAW_DATASETapparemment passé deux fois. Je pense que vous pourriez avoir une faute de frappe?
Dave
Je ne sais pas pourquoi l'utilisation with .. as .. me donne AttributeError: __exit__, mais fonctionne très bien si je viens d'appeler pool = Pool();puis de fermer manuellement pool.close()(python2.7)
muon
1
@muon, bonne prise. Il semble que les Poolobjets ne deviennent pas des gestionnaires de contexte avant Python 3.3. J'ai ajouté une fonction wrapper simple qui renvoie un Poolgestionnaire de contexte.
senderle
501

existe-t-il une variante de pool.map qui prend en charge plusieurs arguments?

Python 3.3 inclut une pool.starmap()méthode :

#!/usr/bin/env python3
from functools import partial
from itertools import repeat
from multiprocessing import Pool, freeze_support

def func(a, b):
    return a + b

def main():
    a_args = [1,2,3]
    second_arg = 1
    with Pool() as pool:
        L = pool.starmap(func, [(1, 1), (2, 1), (3, 1)])
        M = pool.starmap(func, zip(a_args, repeat(second_arg)))
        N = pool.map(partial(func, b=second_arg), a_args)
        assert L == M == N

if __name__=="__main__":
    freeze_support()
    main()

Pour les anciennes versions:

#!/usr/bin/env python2
import itertools
from multiprocessing import Pool, freeze_support

def func(a, b):
    print a, b

def func_star(a_b):
    """Convert `f([1,2])` to `f(1,2)` call."""
    return func(*a_b)

def main():
    pool = Pool()
    a_args = [1,2,3]
    second_arg = 1
    pool.map(func_star, itertools.izip(a_args, itertools.repeat(second_arg)))

if __name__=="__main__":
    freeze_support()
    main()

Production

1 1
2 1
3 1

Remarquez comment itertools.izip()et itertools.repeat()sont utilisés ici.

En raison du bogue mentionné par @unutbu, vous ne pouvez pas utiliser functools.partial()ou des fonctionnalités similaires sur Python 2.6, donc la fonction wrapper simple func_star()doit être définie explicitement. Voir également la solution de contournement suggérée paruptimebox .

jfs
la source
1
F .: Vous pouvez déballer le tuple argument dans la signature func_starcomme ceci: def func_star((a, b)). Bien sûr, cela ne fonctionne que pour un nombre fixe d'arguments, mais si c'est le seul cas qu'il a, il est plus lisible.
Björn Pollex
1
@ Space_C0wb0y: la f((a,b))syntaxe est déconseillée et supprimée dans py3k. Et c'est inutile ici.
jfs
peut-être plus pythonique: func = lambda x: func(*x)au lieu de définir une fonction wrapper
dylam
1
@ zthomas.nc, cette question porte sur la façon de prendre en charge plusieurs arguments pour le pool de traitement multiple pool.map. Si vous voulez savoir comment appeler une méthode au lieu d'une fonction dans un processus Python différent via le multitraitement, posez une question distincte (si tout le reste échoue, vous pouvez toujours créer une fonction globale qui enveloppe l'appel de méthode comme func_star()ci-dessus)
jfs
1
J'aurais aimé qu'il y en ait starstarmap.
Константин Ван
141

Je pense que ce qui suit sera meilleur

def multi_run_wrapper(args):
   return add(*args)
def add(x,y):
    return x+y
if __name__ == "__main__":
    from multiprocessing import Pool
    pool = Pool(4)
    results = pool.map(multi_run_wrapper,[(1,2),(2,3),(3,4)])
    print results

production

[3, 5, 7]
imotai
la source
16
Solution la plus simple. Il y a une petite optimisation; supprimer la fonction wrapper et décompresser argsdirectement dans add, cela fonctionne pour n'importe quel nombre d'arguments:def add(args): (x,y) = args
Ahmed
1
vous pouvez également utiliser une lambdafonction au lieu de définirmulti_run_wrapper(..)
Andre Holzner
2
hm ... en fait, utiliser un lambdane fonctionne pas car pool.map(..)essaie de décaper la fonction donnée
Andre Holzner
Comment l'utilisez-vous si vous souhaitez stocker le résultat de adddans une liste?
Vivek Subramanian
@Ahmed Je l'aime bien, car à mon humble avis, l'appel de méthode devrait échouer, chaque fois que le nombre de paramètres n'est pas correct.
Michael Dorner
56

Utilisation de Python 3.3+ avecpool.starmap():

from multiprocessing.dummy import Pool as ThreadPool 

def write(i, x):
    print(i, "---", x)

a = ["1","2","3"]
b = ["4","5","6"] 

pool = ThreadPool(2)
pool.starmap(write, zip(a,b)) 
pool.close() 
pool.join()

Résultat:

1 --- 4
2 --- 5
3 --- 6

Vous pouvez également compresser () d'autres arguments si vous le souhaitez: zip(a,b,c,d,e)

Dans le cas où vous souhaitez avoir une valeur constante passée comme argument, vous devez utiliser import itertools, puis zip(itertools.repeat(constant), a)par exemple.

user136036
la source
2
Il s'agit d'une réponse en double presque exacte comme celle de @JFSebastian en 2011 (avec plus de 60 votes).
Mike McKerns
29
Non. Tout d'abord, il a supprimé beaucoup de choses inutiles et indique clairement que c'est pour python 3.3+ et est destiné aux débutants qui recherchent une réponse simple et claire. En tant que débutant moi-même, il a fallu un certain temps pour le comprendre de cette façon (oui avec les messages JFSebastians) et c'est pourquoi j'ai écrit mon message pour aider les autres débutants, parce que son message disait simplement "il y a du starmap" mais ne l'expliquait pas - ce est ce que mon message a l'intention. Il n'y a donc absolument aucune raison de me critiquer avec deux downvotes.
user136036
En 2011, il n'y avait pas de "+" en python 3.3 +… donc évidemment.
Mike McKerns
27

Ayant appris les outils itert dans la réponse de JF Sebastian, j'ai décidé d'aller plus loin et d'écrire un parmappackage qui prend en charge la parallélisation, l'offre mapet les starmapfonctions sur python-2.7 et python-3.2 (et plus tard également) qui peut prendre n'importe quel nombre d'arguments positionnels. .

Installation

pip install parmap

Comment paralléliser:

import parmap
# If you want to do:
y = [myfunction(x, argument1, argument2) for x in mylist]
# In parallel:
y = parmap.map(myfunction, mylist, argument1, argument2)

# If you want to do:
z = [myfunction(x, y, argument1, argument2) for (x,y) in mylist]
# In parallel:
z = parmap.starmap(myfunction, mylist, argument1, argument2)

# If you want to do:
listx = [1, 2, 3, 4, 5, 6]
listy = [2, 3, 4, 5, 6, 7]
param = 3.14
param2 = 42
listz = []
for (x, y) in zip(listx, listy):
        listz.append(myfunction(x, y, param1, param2))
# In parallel:
listz = parmap.starmap(myfunction, zip(listx, listy), param1, param2)

J'ai téléchargé parmap sur PyPI et dans un dépôt github .

À titre d'exemple, la question peut être répondue comme suit:

import parmap

def harvester(case, text):
    X = case[0]
    text+ str(X)

if __name__ == "__main__":
    case = RAW_DATASET  # assuming this is an iterable
    parmap.map(harvester, case, "test", chunksize=1)
zeehio
la source
20

# "Comment prendre plusieurs arguments".

def f1(args):
    a, b, c = args[0] , args[1] , args[2]
    return a+b+c

if __name__ == "__main__":
    import multiprocessing
    pool = multiprocessing.Pool(4) 

    result1 = pool.map(f1, [ [1,2,3] ])
    print(result1)
Dane Lee
la source
2
Soigné et élégant.
Prav001
1
Je ne comprends pas pourquoi je dois faire défiler tout le chemin ici pour trouver la meilleure réponse.
toti
12

Il y a une fourchette de pathosmultiprocessing appelés ( remarque: utilisez la version sur github ) qui n'a pas besoin - les fonctions de carte reflètent l'API pour la carte de python, donc la carte peut prendre plusieurs arguments. Avec , vous pouvez aussi généralement faire du multitraitement dans l'interpréteur, au lieu d'être coincé dans le bloc. Pathos devrait sortir, après quelques mises à jour légères - principalement une conversion en python 3.x.starmappathos__main__

  Python 2.7.5 (default, Sep 30 2013, 20:15:49) 
  [GCC 4.2.1 (Apple Inc. build 5566)] on darwin
  Type "help", "copyright", "credits" or "license" for more information.
  >>> def func(a,b):
  ...     print a,b
  ...
  >>>
  >>> from pathos.multiprocessing import ProcessingPool    
  >>> pool = ProcessingPool(nodes=4)
  >>> pool.map(func, [1,2,3], [1,1,1])
  1 1
  2 1
  3 1
  [None, None, None]
  >>>
  >>> # also can pickle stuff like lambdas 
  >>> result = pool.map(lambda x: x**2, range(10))
  >>> result
  [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
  >>>
  >>> # also does asynchronous map
  >>> result = pool.amap(pow, [1,2,3], [4,5,6])
  >>> result.get()
  [1, 32, 729]
  >>>
  >>> # or can return a map iterator
  >>> result = pool.imap(pow, [1,2,3], [4,5,6])
  >>> result
  <processing.pool.IMapIterator object at 0x110c2ffd0>
  >>> list(result)
  [1, 32, 729]

pathosa plusieurs façons dont vous pouvez obtenir le comportement exact starmap.

>>> def add(*x):
...   return sum(x)
... 
>>> x = [[1,2,3],[4,5,6]]
>>> import pathos
>>> import numpy as np
>>> # use ProcessPool's map and transposing the inputs
>>> pp = pathos.pools.ProcessPool()
>>> pp.map(add, *np.array(x).T)
[6, 15]
>>> # use ProcessPool's map and a lambda to apply the star
>>> pp.map(lambda x: add(*x), x)
[6, 15]
>>> # use a _ProcessPool, which has starmap
>>> _pp = pathos.pools._ProcessPool()
>>> _pp.starmap(add, x)
[6, 15]
>>> 
Mike McKerns
la source
Je tiens à noter que cela ne concerne pas la structure de la question d'origine. [[1, 2, 3], [4, 5, 6]] déballerait avec une bande de calage pour [pow (1,2,3), pow (4,5,6)], pas [pow (1,4) , pow (2,5), pow (3, 6)]. Si vous n'avez pas un bon contrôle sur les entrées transmises à votre fonction, vous devrez peut-être d'abord les restructurer.
Scott
@Scott: ah, je n'ai pas remarqué ça ... il y a plus de 5 ans. Je ferai une petite mise à jour. Merci.
Mike McKerns
8

Vous pouvez utiliser les deux fonctions suivantes afin d'éviter d'écrire un wrapper pour chaque nouvelle fonction:

import itertools
from multiprocessing import Pool

def universal_worker(input_pair):
    function, args = input_pair
    return function(*args)

def pool_args(function, *args):
    return zip(itertools.repeat(function), zip(*args))

Utilisez la fonction functionavec les listes d'arguments arg_0, arg_1et arg_2comme suit:

pool = Pool(n_core)
list_model = pool.map(universal_worker, pool_args(function, arg_0, arg_1, arg_2)
pool.close()
pool.join()
M. Toya
la source
8

Une meilleure solution pour python2:

from multiprocessing import Pool
def func((i, (a, b))):
    print i, a, b
    return a + b
pool = Pool(3)
pool.map(func, [(0,(1,2)), (1,(2,3)), (2,(3, 4))])

2 3 4

1 2 3

0 1 2

en dehors[]:

[3, 5, 7]

xmduhan
la source
7

Une autre alternative simple consiste à encapsuler vos paramètres de fonction dans un tuple, puis à encapsuler les paramètres qui doivent également être passés en tuples. Ce n'est peut-être pas idéal lorsqu'il s'agit de grandes quantités de données. Je pense qu'il ferait des copies pour chaque tuple.

from multiprocessing import Pool

def f((a,b,c,d)):
    print a,b,c,d
    return a + b + c +d

if __name__ == '__main__':
    p = Pool(10)
    data = [(i+0,i+1,i+2,i+3) for i in xrange(10)]
    print(p.map(f, data))
    p.close()
    p.join()

Donne la sortie dans un ordre aléatoire:

0 1 2 3
1 2 3 4
2 3 4 5
3 4 5 6
4 5 6 7
5 6 7 8
7 8 9 10
6 7 8 9
8 9 10 11
9 10 11 12
[6, 10, 14, 18, 22, 26, 30, 34, 38, 42]
Alex Klibisz
la source
En effet, il cherche toujours un meilleur moyen :(
Fábio Dias
6

Une meilleure façon est d'utiliser le décorateur au lieu d'écrire la fonction wrapper à la main. Surtout lorsque vous avez beaucoup de fonctions à cartographier, le décorateur vous fera gagner du temps en évitant d'écrire du wrapper pour chaque fonction. Habituellement, une fonction décorée n'est pas picklable, mais nous pouvons l'utiliser functoolspour la contourner. Plus de discussions peuvent être trouvées ici .

Voici l'exemple

def unpack_args(func):
    from functools import wraps
    @wraps(func)
    def wrapper(args):
        if isinstance(args, dict):
            return func(**args)
        else:
            return func(*args)
    return wrapper

@unpack_args
def func(x, y):
    return x + y

Ensuite, vous pouvez le mapper avec des arguments zippés

np, xlist, ylist = 2, range(10), range(10)
pool = Pool(np)
res = pool.map(func, zip(xlist, ylist))
pool.close()
pool.join()

Bien sûr, vous pouvez toujours utiliser Pool.starmapen Python 3 (> = 3.3) comme mentionné dans d'autres réponses.

Syrtis Major
la source
Les résultats ne sont pas ceux attendus: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] Je m'attendrais à: [0,1,2,3,4,5,6,7,8, 9,1,2,3,4,5,6,7,8,9,10,2,3,4,5,6,7,8,9,10,11, ...
Tedo Vrbanec
@TedoVrbanec Les résultats devraient juste être [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]. Si vous voulez le dernier, vous pouvez utiliser à la itertools.productplace de zip.
Syrtis Major
4

Une autre façon consiste à passer une liste de listes à une routine à un argument:

import os
from multiprocessing import Pool

def task(args):
    print "PID =", os.getpid(), ", arg1 =", args[0], ", arg2 =", args[1]

pool = Pool()

pool.map(task, [
        [1,2],
        [3,4],
        [5,6],
        [7,8]
    ])

On peut alors construire une liste de listes d'arguments avec sa méthode préférée.

Adobe
la source
C'est un moyen simple, mais vous devez modifier vos fonctions d'origine. De plus, un certain temps rappelle les fonctions des autres qui ne peuvent pas être modifiées.
WeizhongTu
Je dirai que cela reste fidèle à Python zen. Il devrait y avoir une et une seule façon évidente de le faire. Si par hasard vous êtes l'auteur de la fonction appelante, vous devez utiliser cette méthode, pour d'autres cas nous pouvons utiliser la méthode imotai.
nehem
Mon choix est d'utiliser un tuple, puis de les déballer immédiatement comme première chose dans la première ligne.
nehem
3

Voici une autre façon de le faire, à mon humble avis, plus simple et élégant que toutes les autres réponses fournies.

Ce programme a une fonction qui prend deux paramètres, les imprime et imprime également la somme:

import multiprocessing

def main():

    with multiprocessing.Pool(10) as pool:
        params = [ (2, 2), (3, 3), (4, 4) ]
        pool.starmap(printSum, params)
    # end with

# end function

def printSum(num1, num2):
    mySum = num1 + num2
    print('num1 = ' + str(num1) + ', num2 = ' + str(num2) + ', sum = ' + str(mySum))
# end function

if __name__ == '__main__':
    main()

la sortie est:

num1 = 2, num2 = 2, sum = 4
num1 = 3, num2 = 3, sum = 6
num1 = 4, num2 = 4, sum = 8

Consultez la documentation de python pour plus d'informations:

https://docs.python.org/3/library/multiprocessing.html#module-multiprocessing.pool

Assurez-vous en particulier de vérifier la starmapfonction.

J'utilise Python 3.6, je ne sais pas si cela fonctionnera avec les anciennes versions de Python

Pourquoi il n'y a pas un exemple très simple comme celui-ci dans les documents, je ne suis pas sûr.

cdahms
la source
2

À partir de python 3.4.4, vous pouvez utiliser multiprocessing.get_context () pour obtenir un objet contextuel pour utiliser plusieurs méthodes de démarrage:

import multiprocessing as mp

def foo(q, h, w):
    q.put(h + ' ' + w)
    print(h + ' ' + w)

if __name__ == '__main__':
    ctx = mp.get_context('spawn')
    q = ctx.Queue()
    p = ctx.Process(target=foo, args=(q,'hello', 'world'))
    p.start()
    print(q.get())
    p.join()

Ou vous remplacez simplement

pool.map(harvester(text,case),case, 1)

par:

pool.apply_async(harvester(text,case),case, 1)
Tung Nguyen
la source
2

Il existe de nombreuses réponses ici, mais aucune ne semble fournir de code compatible Python 2/3 qui fonctionnera sur n'importe quelle version. Si vous voulez que votre code fonctionne , cela fonctionnera pour l'une ou l'autre version de Python:

# For python 2/3 compatibility, define pool context manager
# to support the 'with' statement in Python 2
if sys.version_info[0] == 2:
    from contextlib import contextmanager
    @contextmanager
    def multiprocessing_context(*args, **kwargs):
        pool = multiprocessing.Pool(*args, **kwargs)
        yield pool
        pool.terminate()
else:
    multiprocessing_context = multiprocessing.Pool

Après cela, vous pouvez utiliser le multitraitement de la manière Python 3 habituelle, comme vous le souhaitez. Par exemple:

def _function_to_run_for_each(x):
       return x.lower()
with multiprocessing_context(processes=3) as pool:
    results = pool.map(_function_to_run_for_each, ['Bob', 'Sue', 'Tim'])    print(results)

fonctionnera en Python 2 ou Python 3.

cgnorthcutt
la source
1

Dans la documentation officielle, il ne prend en charge qu'un seul argument itérable. J'aime utiliser apply_async dans de tels cas. Dans votre cas, je ferais:

from multiprocessing import Process, Pool, Manager

text = "test"
def harvester(text, case, q = None):
 X = case[0]
 res = text+ str(X)
 if q:
  q.put(res)
 return res


def block_until(q, results_queue, until_counter=0):
 i = 0
 while i < until_counter:
  results_queue.put(q.get())
  i+=1

if __name__ == '__main__':
 pool = multiprocessing.Pool(processes=6)
 case = RAW_DATASET
 m = Manager()
 q = m.Queue()
 results_queue = m.Queue() # when it completes results will reside in this queue
 blocking_process = Process(block_until, (q, results_queue, len(case)))
 blocking_process.start()
 for c in case:
  try:
   res = pool.apply_async(harvester, (text, case, q = None))
   res.get(timeout=0.1)
  except:
   pass
 blocking_process.join()
roj4s
la source
1
text = "test"

def unpack(args):
    return args[0](*args[1:])

def harvester(text, case):
    X = case[0]
    text+ str(X)

if __name__ == '__main__':
    pool = multiprocessing.Pool(processes=6)
    case = RAW_DATASET
    # args is a list of tuples 
    # with the function to execute as the first item in each tuple
    args = [(harvester, text, c) for c in case]
    # doing it this way, we can pass any function
    # and we don't need to define a wrapper for each different function
    # if we need to use more than one
    pool.map(unpack, args)
    pool.close()
    pool.join()
Jaime
la source
1

Voici un exemple de la routine que j'utilise pour passer plusieurs arguments à une fonction à un argument utilisée dans un fork pool.imap :

from multiprocessing import Pool

# Wrapper of the function to map:
class makefun:
    def __init__(self, var2):
        self.var2 = var2
    def fun(self, i):
        var2 = self.var2
        return var1[i] + var2

# Couple of variables for the example:
var1 = [1, 2, 3, 5, 6, 7, 8]
var2 = [9, 10, 11, 12]

# Open the pool:
pool = Pool(processes=2)

# Wrapper loop
for j in range(len(var2)):
    # Obtain the function to map
    pool_fun = makefun(var2[j]).fun

    # Fork loop
    for i, value in enumerate(pool.imap(pool_fun, range(len(var1))), 0):
        print(var1[i], '+' ,var2[j], '=', value)

# Close the pool
pool.close()
A. Nodar
la source
-3

pour python2, vous pouvez utiliser cette astuce

def fun(a,b):
    return a+b

pool = multiprocessing.Pool(processes=6)
b=233
pool.map(lambda x:fun(x,b),range(1000))
Hz Shang
la source
pourquoi b = 233. défait le but de la question
comme - si