Wie kann man mehrere Argumente ausführen, um Funktionen zuzuordnen, bei denen eines in Python gleich bleibt?

Nehmen wir an, wir haben eine Funktion wie folgt hinzugefügt

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

Wir möchten die Map-Funktion für ein Array anwenden

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

Die Semantik ist, dass ich jedem Element des Arrays 2 hinzufügen möchte. Die mapFunktion erfordert aber auch eine Liste im dritten Argument.

Hinweis: Der Einfachheit halber füge ich das Beispiel zum Hinzufügen hinzu. Meine ursprüngliche Funktion ist viel komplizierter. Die Option, den Standardwert für ydie Funktion zum Hinzufügen festzulegen, kommt natürlich nicht in Frage, da sie bei jedem Aufruf geändert wird.

Eine Option ist ein Listenverständnis:

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

Mehr Optionen:

a = [1, 2, 3]

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

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

In den Dokumenten wird ausdrücklich darauf hingewiesen, dass dies die Hauptverwendung ist für itertools.repeat:

Erstellen Sie einen Iterator, der das Objekt immer wieder zurückgibt. Wird unbegrenzt ausgeführt, sofern nicht das Argument times angegeben ist. Wird als Argument map()für invariante Parameter für die aufgerufene Funktion verwendet. Wird auch verwendet zip(), um einen invarianten Teil eines Tupeldatensatzes zu erstellen.

Und es gibt keinen Grund, len([1,2,3])als timesArgument zu gelten. mapstoppt, sobald das erste iterable verbraucht ist, so dass ein unendliches iterable vollkommen in Ordnung ist:

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

Tatsächlich entspricht dies dem Beispiel repeatin den Dokumenten:

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

Dies ergibt eine nette Lazy-Functional-Language-y-Lösung, die auch in Python-Iterator-Begriffen perfekt lesbar ist.

Verwenden Sie ein Listenverständnis.

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

Wenn Sie wirklich , wirklich , wirklich verwenden möchten map, geben Sie ihm als erstes Argument eine anonyme Funktion:

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

Map kann mehrere Argumente enthalten, der Standardweg ist

map(add, a, b)

In Ihrer Frage sollte es sein

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

Die richtige Antwort ist einfacher als Sie denken. Einfach machen:

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

Und ändern Sie die Implementierung von add, um ein Tupel zu nehmen, dh

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

Dies kann jeden komplizierten Anwendungsfall behandeln, bei dem beide Add-Parameter dynamisch sind.

Manchmal habe ich ähnliche Situationen (z. B. mit der Methode pandas.apply ) mithilfe von Verschlüssen gelöst

Um sie zu verwenden, definieren Sie eine Funktion, die dynamisch einen Wrapper für Ihre Funktion definiert und zurückgibt, wodurch einer der Parameter effektiv zu einer Konstanten wird.

Etwas wie das:

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

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

Dann add_constant(y)gibt eine Funktion , die verwendet werden kann , hinzufügen yzu einem bestimmten Wert:

>>> add_constant(2)(3)
5

So können Sie es in jeder Situation verwenden, in der Parameter einzeln angegeben werden:

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

bearbeiten

Wenn Sie die Closure-Funktion nicht an einer anderen Stelle schreiben möchten, haben Sie immer die Möglichkeit, sie mithilfe einer Lambda-Funktion im laufenden Betrieb zu erstellen:

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

Wenn Sie es zur Verfügung haben, würde ich die Verwendung von numpy in Betracht ziehen. Es ist sehr schnell für diese Art von Operationen:

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

Dies setzt voraus, dass Ihre reale Anwendung mathematische Operationen ausführt (die vektorisiert werden können).

Wenn Sie wirklich wirklich die Map-Funktion verwenden müssen (wie meine Klassenzuweisung hier ...), können Sie eine Wrapper-Funktion mit 1 Argument verwenden und den Rest an die ursprüngliche Funktion in ihrem Hauptteil übergeben. dh:

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


map(myFunc, itterable)

Schmutzig und hässlich, macht immer noch den Trick

Ich glaube, Starmap ist das, was Sie brauchen:

from itertools import starmap


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

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

Übergeben mehrerer Argumente an eine mapFunktion.

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

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

Hier ist q eine Funktion mit mehreren Argumenten, die map () aufruft. Stellen Sie sicher, dass die Länge beider Bereiche dh

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

Im :nums = [1, 2, 3]

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

Aus:[3, 4, 5]

Sie können Lambda zusammen mit der Karte einschließen:

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

Indem Sie den Funktionsaufruf mit einem Lambda umschließen und das Entpacken des Sterns verwenden, können Sie eine Zuordnung mit einer beliebigen Anzahl von Argumenten durchführen.

Eine weitere Option ist:

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

Dieses Format ist sehr nützlich, wenn Sie mehrere Funktionen aufrufen.