¿Cómo hacer múltiples argumentos para asignar la función donde uno permanece igual en python?

Digamos que tenemos una función agregar de la siguiente manera

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

queremos aplicar la función de mapa para una matriz

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

La semántica es que quiero agregar 2 a cada elemento de la matriz. Pero la mapfunción también requiere una lista en el tercer argumento.

Nota: Estoy poniendo el ejemplo de agregar por simplicidad. Mi función original es mucho más complicada. Y, por supuesto, la opción de configurar el valor predeterminado de la yfunción in add está fuera de discusión, ya que se cambiará para cada llamada.

Una opción es una lista de comprensión:

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

Mas opciones:

a = [1, 2, 3]

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

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

Los documentos sugieren explícitamente que este es el uso principal para itertools.repeat:

Haga un iterador que devuelva el objeto una y otra vez. Se ejecuta indefinidamente a menos que se especifique el argumento de tiempos. Se usa como argumento map()para los parámetros invariantes de la función llamada. También se usa con zip()para crear una parte invariable de un registro de tupla.

Y no hay razón para pasar len([1,2,3])como timesargumento; mapse detiene tan pronto como se consume el primer iterable, por lo que un iterable infinito está perfectamente bien:

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

De hecho, esto es equivalente al ejemplo de repeaten los documentos:

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

Esto lo convierte en una buena solución de lenguaje perezoso y funcional que también es perfectamente legible en términos de iterador de Python.

Usa una lista de comprensión.

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

Si realmente , realmente , realmente quiere usar map, dele una función anónima como primer argumento:

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

El mapa puede contener múltiples argumentos, la forma estándar es

map(add, a, b)

En su pregunta, debería ser

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

La respuesta correcta es más simple de lo que piensas. Simplemente haz:

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

Y cambie la implementación de add para tomar una tupla, es decir

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

Esto puede manejar cualquier caso de uso complicado donde ambos parámetros de adición son dinámicos.

Algunas veces resolví situaciones similares (como usar el método pandas.apply ) usando cierres

Para usarlos, usted define una función que define y devuelve dinámicamente un contenedor para su función, convirtiendo efectivamente uno de los parámetros en una constante.

Algo como esto:

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

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

Luego, add_constant(y)devuelve una función que se puede usar para agregar ya cualquier valor dado:

>>> add_constant(2)(3)
5

Lo que le permite usarlo en cualquier situación en la que los parámetros se dan uno a la vez:

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

editar

Si no desea tener que escribir la función de cierre en otro lugar, siempre tiene la posibilidad de construirla sobre la marcha utilizando una función lambda:

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

Si lo tiene disponible, consideraría usar numpy. Es muy rápido para este tipo de operaciones:

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

Esto supone que su aplicación real está haciendo operaciones matemáticas (que se pueden vectorizar).

Si realmente necesita usar la función de mapa (como mi asignación de clase aquí ...), podría usar una función de contenedor con 1 argumento, pasando el resto a la original en su cuerpo; es decir:

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


map(myFunc, itterable)

Sucio y feo, todavía funciona

Creo que Starmap es lo que necesitas:

from itertools import starmap


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

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

Para pasar múltiples argumentos a una mapfunción.

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

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

Aquí q es una función con múltiples argumentos que map () llama. Asegúrese de que la longitud de ambos rangos es decir

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

En:nums = [1, 2, 3]

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

Fuera:[3, 4, 5]

Puede incluir lambda junto con el mapa:

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]])

Al ajustar la llamada a la función con una lambda y usar el descomprimir estrella, puede hacer un mapa con un número arbitrario de argumentos.

Otra opción es:

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

Este formato es muy útil cuando se llaman múltiples funciones.