Passer des fonctions avec des arguments à une autre fonction en Python?

Est-il possible de passer des fonctions avec des arguments à une autre fonction en Python?

Dites quelque chose comme:

def perform(function):
    return function()

Mais les fonctions à passer auront des arguments comme:

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

Est-ce que tu veut dire ça?

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

def action1( args ):
    something

def action2( args ):
    something

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

Voici à quoi sert lambda:

def Perform(f):
    f()

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

Vous pouvez utiliser la fonction partielle de functools comme ça.

from functools import partial

def perform(f):
    f()

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

Fonctionne également avec les mots clés

perform(partial(Action4, param1=p))

Utilisez functools.partial, pas lambdas! Et ofc Perform est une fonction inutile, vous pouvez passer directement les fonctions.

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

(des mois plus tard) un petit exemple réel où lambda est utile, non partiel:
disons que vous voulez diverses coupes transversales à 1 dimension à travers une fonction à 2 dimensions, comme des tranches à travers une rangée de collines.
quadf( x, f )prend un 1-d fet l'appelle pour divers x.
Pour l'appeler pour les coupes verticales à y = -1 0 1 et les coupes horizontales à 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 )

Pour autant que je sache, je ne partialpeux pas faire ça -

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

(Comment ajouter des balises numpy, partial, lambda à cela?)

C'est ce qu'on appelle des fonctions partielles et il y a au moins 3 façons de le faire. Ma façon préférée utilise lambda car elle évite la dépendance à l'égard d'un paquet supplémentaire et est la moins verbeuse. Supposons que vous ayez une fonction add(x, y)et que vous souhaitiez passer add(3, y)à une autre fonction en tant que paramètre de sorte que l'autre fonction décide de la valeur pour y.

Utilisez 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

Créez votre propre emballage

Ici, vous devez créer une fonction qui renvoie la fonction partielle. C'est évidemment beaucoup plus verbeux.

# 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

Utiliser partiel à partir de functools

Ceci est presque identique à celui lambdamontré ci-dessus. Alors pourquoi en avons-nous besoin? Il y a peu de raisons . En bref, partialpeut être un peu plus rapide dans certains cas (voir son implémentation ) et que vous pouvez l'utiliser pour une liaison anticipée vs une liaison tardive de lambda.

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

Voici une façon de le faire avec une fermeture:

    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)