Passing Funktionen mit Argumenten an einem anderen Funktion in Python?

Question

Ist es möglich, Funktionen mit Argumenten zu einer anderen Funktion in Python passieren?

Sprich für so etwas wie:

def perform(function):
    return function()

Aber die Funktionen übergeben werden, werden Argumente wie haben:

action1()
action2(p)
action3(p,r)

Answer 1

Haben Sie das bedeuten?

def perform( fun, *args ):
    fun( *args )

def action1( args ):
    something

def action2( args ):
    something

perform( action1 )
perform( action2, p )
perform( action3, p, r )

Answer 2

Dies ist, was Lambda ist für:

def Perform(f):
    f()

Perform(lambda: Action1())
Perform(lambda: Action2(p))
Perform(lambda: Action3(p, r))

Answer 3

Sie können die Teilfunktion von functools wie so verwenden.

from functools import partial

def perform(f):
    f()

perform(Action1)
perform(partial(Action2, p))
perform(partial(Action3, p, r))

Funktioniert auch mit Keywords

perform(partial(Action4, param1=p))

Answer 4

Mit functools.partial, nicht lambdas! Und OFC Führen Sie eine unnütze Funktion ist, können Sie rund um Funktionen übergeben direkt an.

for func in [Action1, partial(Action2, p), partial(Action3, p, r)]:
  func()

Answer 5

(Monate später) ein kleines reales Beispiel, wo Lambda ist nützlich, teilweise nicht:
sagen Sie verschiedene 1-dimensionale Querschnitte durch eine 2-dimensionale Funktion möchten, wie Scheiben durch eine Reihe von Hügeln.
quadf( x, f ) nimmt einen 1-d f und nennt es für verschiedene x.
So rufen sie für vertikale Schnitte bei y = -1 0 1 und horizontale Schnitte bei x = -1 0 1,

fx1 = quadf( x, lambda x: f( x, 1 ))
fx0 = quadf( x, lambda x: f( x, 0 ))
fx_1 = quadf( x, lambda x: f( x, -1 ))
fxy = parabola( y, fx_1, fx0, fx1 )

f_1y = quadf( y, lambda y: f( -1, y ))
f0y = quadf( y, lambda y: f( 0, y ))
f1y = quadf( y, lambda y: f( 1, y ))
fyx = parabola( x, f_1y, f0y, f1y )

Soweit ich weiß, partial kann dies nicht tun -

quadf( y, partial( f, x=1 ))
TypeError: f() got multiple values for keyword argument 'x'

(Wie Tags numpy, teilweise, Lambda dazu hinzufügen?)

Answer 6

Dies ist Teilfunktionen genannt und es gibt mindestens drei Möglichkeiten, dies zu tun. Mein Liebling Weg ist mit Lambda, weil es der Abhängigkeit von zusätzlichem Paket vermeidet und ist die am wenigsten ausführlich. Angenommen, Sie eine Funktion add(x, y) haben und Sie möchten add(3, y) auf eine andere Funktion als Parameter zu übergeben, so dass die andere Funktion, um den Wert für y entscheidet.

Verwenden Lambda

# generic function takes op and its argument
def runOp(op, val):
    return op(val)

# declare full function
def add(x, y):
    return x+y

# run example
def main():
    f = lambda y: add(3, y)
    result = runOp(f, 1) # is 4

Erstellen Sie Ihre eigenen Wrapper

Hier müssen Sie eine Funktion erstellen, die die Teilfunktion zurückgibt. Das ist natürlich viel ausführlicher.

# generic function takes op and its argument
def runOp(op, val):
    return op(val)

# declare full function
def add(x, y):
    return x+y

# declare partial function
def addPartial(x):
    def _wrapper(y):
        return add(x, y)
    return _wrapper

# run example
def main():
    f = addPartial(3)
    result = runOp(f, 1) # is 4

Verwenden Sie teilweise von functools

Das ist fast identisch oben gezeigten lambda. Warum tun wir das brauchen? Es gibt paar Gründe . Kurz gesagt, könnte partial etwas schneller sein in einigen Fällen (siehe seine Implementierung ) und dass Sie es für die frühe Bindung vs Lambda späte Bindung.

verwenden können,

from functools import partial

# generic function takes op and its argument
def runOp(op, val):
    return op(val)

# declare full function
def add(x, y):
    return x+y

# run example
def main():
    f = partial(add, 3)
    result = runOp(f, 1) # is 4

Answer 7

Hier ist ein Weg, um es mit einem Verschluss zu tun:

    def generate_add_mult_func(func):
        def function_generator(x):
            return reduce(func,range(1,x))
        return function_generator

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

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

    adding=generate_add_mult_func(add)
    multiplying=generate_add_mult_func(mult)

    print adding(10)
    print multiplying(10)