Jak zrobić wiele argumentów, aby zmapować funkcję, w której jeden pozostaje taki sam w Pythonie?

Powiedzmy, że mamy funkcję add w następujący sposób

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

chcemy zastosować funkcję mapy dla tablicy

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

Semantyka jest taka, że ​​chcę dodać 2 do każdego elementu tablicy. Ale mapfunkcja wymaga również listy w trzecim argumencie.

Uwaga: dodaję przykład dla uproszczenia. Moja pierwotna funkcja jest znacznie bardziej skomplikowana. I oczywiście opcja ustawienia domyślnej wartości yfunkcji dodawania nie wchodzi w grę, ponieważ będzie ona zmieniana przy każdym wywołaniu.

Jedną z opcji jest zrozumienie listy:

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

Więcej możliwości:

a = [1, 2, 3]

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

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

Dokumenty wyraźnie sugerują, że jest to główne zastosowanie itertools.repeat:

Stwórz iterator, który zwraca obiekt w kółko. Działa przez czas nieokreślony, chyba że określono argument times. Używany jako argument map()dla niezmiennych parametrów wywoływanej funkcji. Używany również w programie zip()do tworzenia niezmiennej części rekordu krotki.

I nie ma powodu, aby przekazać len([1,2,3])jako timesargument; mapzatrzymuje się, gdy tylko zostanie zużyta pierwsza iterowalna, więc nieskończona iteracja jest całkowicie w porządku:

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

W rzeczywistości jest to równoważne z przykładem repeatw dokumentach:

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

To sprawia, że ​​jest to przyjemne, leniwe, funkcjonalne rozwiązanie w języku y, które jest również doskonale czytelne pod względem iteratorów Pythona.

Użyj rozumienia listy.

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

Jeśli naprawdę , naprawdę , naprawdę chcesz użyć map, daj mu anonimową funkcję jako pierwszy argument:

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

Mapa może zawierać wiele argumentów, standardowym sposobem jest

map(add, a, b)

W twoim pytaniu tak powinno być

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

Prawidłowa odpowiedź jest prostsza niż myślisz. Po prostu zrób:

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

I zmień implementację add, aby wziąć krotkę tj

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

Może to obsłużyć każdy skomplikowany przypadek użycia, w którym oba parametry dodawania są dynamiczne.

Czasami rozwiązywałem podobne sytuacje (np. Używając metody pandas.apply ) używając domknięć

Aby z nich skorzystać, definiujesz funkcję, która dynamicznie definiuje i zwraca opakowanie dla Twojej funkcji, skutecznie czyniąc jeden z parametrów stałą.

Coś takiego:

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

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

Następnie add_constant(y)zwraca funkcję, której można użyć do dodania ydo dowolnej podanej wartości:

>>> add_constant(2)(3)
5

Co pozwala na użycie go w każdej sytuacji, w której parametry podawane są pojedynczo:

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

edytować

Jeśli nie chcesz pisać funkcji zamknięcia w innym miejscu, zawsze masz możliwość zbudowania jej w locie za pomocą funkcji lambda:

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

Jeśli masz to dostępne, rozważyłbym użycie numpy. Jest bardzo szybki w przypadku tego typu operacji:

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

Zakłada się, że twoja prawdziwa aplikacja wykonuje operacje matematyczne (które można wektoryzować).

Jeśli naprawdę potrzebujesz użyć funkcji map (tak jak moje przypisanie klasy tutaj ...), możesz użyć funkcji opakowującej z 1 argumentem, przekazując resztę do oryginalnej w jej treści; tj .:

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


map(myFunc, itterable)

Brudny i brzydki, nadal działa

Wierzę, że Starmap jest tym, czego potrzebujesz:

from itertools import starmap


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

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

Przekazywanie wielu argumentów do mapfunkcji.

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

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

Tutaj q jest funkcją z wieloma argumentami, którą wywołuje map () . Upewnij się, że długość obu zakresów tj

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

W :nums = [1, 2, 3]

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

Na zewnątrz:[3, 4, 5]

Możesz dołączyć lambdę wraz z mapą:

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

Zawijając wywołanie funkcji lambda i używając polecenia rozpakowywania gwiazdy, możesz wykonać mapowanie z dowolną liczbą argumentów.

Inną opcją jest:

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

Ten format jest bardzo przydatny podczas wywoływania wielu funkcji.