Come fare più argomenti per mappare la funzione in cui uno rimane lo stesso in Python?

Diciamo che abbiamo una funzione aggiungere come segue

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

vogliamo applicare la funzione mappa per un array

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

La semantica è che voglio aggiungere 2 a ogni elemento dell'array. Ma la mapfunzione richiede anche un elenco nel terzo argomento.

Nota: sto aggiungendo l'esempio per semplicità. La mia funzione originale è molto più complicata. E ovviamente l'opzione di impostare il valore predefinito di yin funzione add è fuori discussione in quanto verrà modificata per ogni chiamata.

Un'opzione è la comprensione di un elenco:

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

Più opzioni:

a = [1, 2, 3]

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

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

I documenti suggeriscono esplicitamente che questo è l'uso principale per itertools.repeat:

Crea un iteratore che restituisce ripetutamente l'oggetto. Viene eseguito indefinitamente a meno che non venga specificato l'argomento times. Utilizzato come argomento map()per i parametri invarianti della funzione chiamata. Utilizzato anche con zip()per creare una parte invariante di un record di tupla.

E non c'è motivo di passare len([1,2,3])come timesargomento; mapsi interrompe non appena viene consumato il primo iterabile, quindi un iterabile infinito va perfettamente bene:

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

In realtà, questo equivale all'esempio per repeatnei documenti:

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

Questo rende una bella soluzione lazy-funzionale-linguaggio-y che è anche perfettamente leggibile in termini di iteratore Python.

Usa una comprensione dell'elenco.

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

Se davvero , davvero , vuoi davvero usare map, dagli una funzione anonima come primo argomento:

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

La mappa può contenere più argomenti, il modo standard è

map(add, a, b)

Nella tua domanda, dovrebbe essere

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

La risposta corretta è più semplice di quanto pensi. Fai semplicemente:

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

E cambia l'implementazione di add per prendere una tupla, ad es

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

Questo può gestire qualsiasi caso d'uso complicato in cui entrambi i parametri add sono dinamici.

A volte ho risolto situazioni simili (come l'uso del metodo pandas.apply ) usando le chiusure

Per usarli, si definisce una funzione che definisce e restituisce dinamicamente un wrapper per la propria funzione, rendendo efficace uno dei parametri una costante.

Qualcosa come questo:

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

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

Quindi, add_constant(y)restituisce una funzione che può essere utilizzata per aggiungere ya qualsiasi dato valore:

>>> add_constant(2)(3)
5

Ciò consente di utilizzarlo in qualsiasi situazione in cui i parametri vengono dati uno alla volta:

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

modificare

Se non vuoi scrivere la funzione di chiusura da qualche altra parte, hai sempre la possibilità di crearla al volo usando una funzione lambda:

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

Se lo hai a disposizione, prenderei in considerazione l'utilizzo di numpy. È molto veloce per questi tipi di operazioni:

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

Questo presuppone che la tua vera applicazione stia facendo operazioni matematiche (che possono essere vettorializzate).

Se hai davvero bisogno di usare la funzione mappa (come il mio compito di classe qui ...), potresti usare una funzione wrapper con 1 argomento, passando il resto a quello originale nel suo corpo; cioè:

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


map(myFunc, itterable)

Sporco e brutto, fa ancora il trucco

Credo che lo starmap sia ciò di cui hai bisogno:

from itertools import starmap


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

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

Passare più argomenti a una mapfunzione.

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

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

Qui q è una funzione con più argomenti che map () chiama. Assicurarsi che la lunghezza di entrambe le gamme es

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

Nel :nums = [1, 2, 3]

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

Su:[3, 4, 5]

Puoi includere lambda insieme alla mappa:

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

Avvolgendo la chiamata di funzione con un lambda e usando la stella unpack, puoi fare la mappa con un numero arbitrario di argomenti.

Un'altra opzione è:

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

Questo formato è molto utile quando si chiamano più funzioni.