Como fazer vários argumentos para mapear a função em que um permanece o mesmo em python?

Vamos dizer que temos uma função add da seguinte forma

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

queremos aplicar a função de mapa para uma matriz

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

A semântica é que eu quero adicionar 2 para todos os elementos da matriz. Mas a mapfunção também requer uma lista no terceiro argumento.

Nota: Estou colocando o exemplo add por simplicidade. Minha função original é muito mais complicada. E é claro que a opção de definir o valor padrão da yfunção add está fora de questão, pois ela será alterada para cada chamada.

Uma opção é a compreensão da lista:

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

Mais opções:

a = [1, 2, 3]

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

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

Os documentos sugerem explicitamente que esse é o principal uso para itertools.repeat:

Faça um iterador que retorne o objeto repetidamente. É executado indefinidamente, a menos que o argumento times seja especificado. Usado como argumento map()para parâmetros invariantes para a função chamada. Também usado com zip()para criar uma parte invariável de um registro de tupla.

E não há razão para passar len([1,2,3])como timesargumento; mappara assim que o primeiro iterável é consumido, portanto, um iterável infinito é perfeitamente adequado:

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

De fato, isso é equivalente ao exemplo repeatdos documentos:

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

Isso cria uma boa solução de linguagem funcional e preguiçosa que também é perfeitamente legível em termos de iterador Python.

Use uma lista de compreensão.

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

Se você realmente , realmente , realmente deseja usar map, dê a ela uma função anônima como o primeiro argumento:

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

O mapa pode conter vários argumentos, a maneira padrão é

map(add, a, b)

Na sua pergunta, deve ser

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

A resposta correta é mais simples do que você pensa. Simplesmente faça:

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

E mude a implementação de add para fazer uma tupla, ie

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

Isso pode lidar com qualquer caso de uso complicado em que ambos os parâmetros de adição sejam dinâmicos.

Às vezes, resolvia situações semelhantes (como usar o método pandas.apply ) usando closures

Para usá-los, você define uma função que define e retorna dinamicamente um wrapper para sua função, tornando efetivamente um dos parâmetros uma constante.

Algo assim:

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

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

Em seguida, add_constant(y)retorna uma função que pode ser usada para adicionar ya qualquer valor:

>>> add_constant(2)(3)
5

O que permite usá-lo em qualquer situação em que os parâmetros sejam dados um de cada vez:

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

editar

Se você não quiser escrever a função de fechamento em outro lugar, sempre terá a possibilidade de construí-la em tempo real usando uma função lambda:

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

Se você tiver disponível, eu consideraria usar numpy. É muito rápido para esses tipos de operações:

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

Isso pressupõe que sua aplicação real esteja executando operações matemáticas (que podem ser vetorizadas).

Se você realmente precisa usar a função map (como minha tarefa de classe aqui ...), você pode usar uma função wrapper com 1 argumento, passando o restante para o original em seu corpo; ou seja:

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


map(myFunc, itterable)

Sujo e feio, ainda faz o truque

Acredito que starmap é o que você precisa:

from itertools import starmap


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

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

Para passar vários argumentos para uma mapfunção.

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

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

Aqui q é função com múltiplos argumentos que map () chama. Verifique se o comprimento de ambos os intervalos

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

No :nums = [1, 2, 3]

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

Fora:[3, 4, 5]

Você pode incluir lambda junto com o 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]])

Envolvendo a chamada de função com um lambda e usando a descompactação em estrela, é possível mapear com número arbitrário de argumentos.

Outra opção é:

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

Este formato é muito útil ao chamar várias funções.