Comment faire plusieurs arguments pour mapper la fonction où l'un reste le même en python?

Disons que nous avons une fonction ajouter comme suit

def add(x, y):
    return x + y

nous voulons appliquer la fonction de carte pour un tableau

map(add, [1, 2, 3], 2)

La sémantique est que je veux ajouter 2 à chaque élément du tableau. Mais la mapfonction nécessite également une liste dans le troisième argument.

Remarque: je mets l'exemple d'ajout pour plus de simplicité. Ma fonction d'origine est beaucoup plus compliquée. Et bien sûr, l'option de définir la valeur par défaut de la yfonction d'ajout est hors de question car elle sera modifiée à chaque appel.

Une option est une compréhension de liste:

[add(x, 2) for x in [1, 2, 3]]

Plus d'options:

a = [1, 2, 3]

import functools
map(functools.partial(add, y=2), a)

import itertools
map(add, a, itertools.repeat(2, len(a)))

La documentation suggère explicitement qu'il s'agit de l'utilisation principale pour itertools.repeat:

Créez un itérateur qui renvoie un objet encore et encore. S'exécute indéfiniment sauf si l'argument times est spécifié. Utilisé comme argument map()pour les paramètres invariants de la fonction appelée. Également utilisé avec zip()pour créer une partie invariante d'un enregistrement de tuple.

Et il n'y a aucune raison de passer len([1,2,3])pour l' timesargument; maps'arrête dès que le premier itérable est consommé, donc un itérable infini convient parfaitement:

>>> from operator import add
>>> from itertools import repeat
>>> list(map(add, [1,2,3], repeat(4)))
[5, 6, 7]

En fait, cela équivaut à l'exemple de repeatla documentation:

>>> list(map(pow, range(10), repeat(2)))
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Cela en fait une belle solution de langage fonctionnel paresseux qui est également parfaitement lisible en termes d'itérateur Python.

Utilisez une compréhension de liste.

[x + 2 for x in [1, 2, 3]]

Si vous voulez vraiment , vraiment , vraiment utiliser map, donnez-lui une fonction anonyme comme premier argument:

map(lambda x: x + 2, [1,2,3])

La carte peut contenir plusieurs arguments, la méthode standard est

map(add, a, b)

Dans votre question, cela devrait être

map(add, a, [2]*len(a))

La bonne réponse est plus simple que vous ne le pensez. Faites simplement:

map(add, [(x, 2) for x in [1,2,3]])

Et changez l'implémentation de add pour prendre un tuple ie

def add(t):
   x, y = t
   return x+y

Cela peut gérer tout cas d'utilisation compliqué où les deux paramètres d'ajout sont dynamiques.

Parfois, j'ai résolu des situations similaires (telles que l'utilisation de la méthode pandas.apply ) en utilisant des fermetures

Pour les utiliser, vous définissez une fonction qui définit et retourne dynamiquement un wrapper pour votre fonction, faisant de l'un des paramètres une constante.

Quelque chose comme ça:

def add(x, y):
   return x + y

def add_constant(y):
    def f(x):
        return add(x, y)
    return f

Ensuite, add_constant(y)renvoie une fonction qui peut être utilisée pour ajouter yà n'importe quelle valeur donnée:

>>> add_constant(2)(3)
5

Ce qui vous permet de l'utiliser dans n'importe quelle situation où les paramètres sont donnés un à la fois:

>>> map(add_constant(2), [1,2,3])
[3, 4, 5]

Éditer

Si vous ne voulez pas avoir à écrire la fonction de fermeture ailleurs, vous avez toujours la possibilité de la construire à la volée en utilisant une fonction lambda:

>>> map(lambda x: add(x, 2), [1, 2, 3])
[3, 4, 5]

Si vous l'avez disponible, j'envisagerais d'utiliser numpy. C'est très rapide pour ces types d'opérations:

>>> import numpy
>>> numpy.array([1,2,3]) + 2
array([3, 4, 5])

Cela suppose que votre application réelle effectue des opérations mathématiques (qui peuvent être vectorisées).

Si vous avez vraiment besoin d'utiliser la fonction map (comme mon affectation de classe ici ...), vous pouvez utiliser une fonction wrapper avec 1 argument, en passant le reste à l'original dans son corps; c'est à dire :

extraArguments = value
def myFunc(arg):
    # call the target function
    return Func(arg, extraArguments)


map(myFunc, itterable)

Sale et laid, fait toujours l'affaire

Je crois que la carte stellaire est ce dont vous avez besoin:

from itertools import starmap


def test(x, y, z):
    return x + y + z

list(starmap(test, [(1, 2, 3), (4, 5, 6)]))

Pour passer plusieurs arguments à une mapfonction.

def q(x,y):
    return x*y

print map (q,range(0,10),range(10,20))

Ici, q est une fonction avec plusieurs arguments que map () appelle. Assurez-vous que la longueur des deux plages soit

len (range(a,a')) and len (range(b,b')) are equal.

Dans :nums = [1, 2, 3]

Dans :map(add, nums, [2]*len(nums))

En dehors:[3, 4, 5]

Vous pouvez inclure lambda avec la carte:

list(map(lambda a: a+2, [1, 2, 3]))

def func(a, b, c, d):
 return a + b * c % d

map(lambda x: func(*x), [[1,2,3,4], [5,6,7,8]])

En enveloppant l'appel de fonction avec un lambda et en utilisant la décompression en étoile, vous pouvez faire une carte avec un nombre arbitraire d'arguments.

Une autre option est:

results = []
for x in [1,2,3]:
    z = add(x,2)
    ...
    results += [f(z,x,y)]

Ce format est très utile lors de l'appel de plusieurs fonctions.