Classeurs d'arguments en Python

Question

Comment puis-je lier des arguments à une méthode Python afin de stocker un functor nullaire pour une invocation ultérieure ? Comme pour le C++ boost::bind .

Par exemple :

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

add_5 = magic_function(add, 5)
assert add_5(3) == 8

Answer 1

functools.partial renvoie un appelable enveloppant une fonction avec certains ou tous les arguments figés.

import sys
import functools

print_hello = functools.partial(sys.stdout.write, "Hello world\n")

print_hello()

Hello world

L'usage ci-dessus est équivalent à ce qui suit lambda .

print_hello = lambda *a, **kw: sys.stdout.write("Hello world\n", *a, **kw)

Answer 2

Je ne suis pas très familier avec boost::bind, mais la fonction partial de la fonction functools peut être un bon début :

>>> from functools import partial

>>> def f(a, b):
...     return a+b

>>> p = partial(f, 1, 2)
>>> p()
3

>>> p2 = partial(f, 1)
>>> p2(7)
8

Answer 3

Si functools.partial n'est pas disponible, il peut être facilement émulé :

>>> make_printer = lambda s: lambda: sys.stdout.write("%s\n" % s)
>>> import sys
>>> print_hello = make_printer("hello")
>>> print_hello()
hello

Ou

def partial(func, *args, **kwargs):
    def f(*args_rest, **kwargs_rest):
        kw = kwargs.copy()
        kw.update(kwargs_rest)
        return func(*(args + args_rest), **kw) 
    return f

def f(a, b):
    return a + b

p = partial(f, 1, 2)
print p() # -> 3

p2 = partial(f, 1)
print p2(7) # -> 8

d = dict(a=2, b=3)
p3 = partial(f, **d)
print p3(), p3(a=3), p3() # -> 5 6 5

Answer 4

Les lambdas vous permettent de créer une nouvelle fonction sans nom avec moins d'arguments et d'appeler la fonction !

>>> def foobar(x,y,z):
...     print "%d, %d, %d" % (x,y,z)
>>> foobar(1,2,3) # call normal function

>>> bind = lambda x: foobar(x, 10, 20) # bind 10 and 20 to foobar
>>> bind(1) # print 1, 10, 20

>>> bind = lambda: foobar(1,2,3) # bind all elements  
>>> bind()  # print 1, 2, 3

modifier

https://docs.python.org/2/library/functools.html#functools.partial

si vous envisagez d'utiliser la liaison d'arguments nommés dans l'appel de fonction, ceci est également applicable :

>>> from functools import partial
>>> barfoo = partial(foobar, x=10)
>>> barfoo(y=5,z=6)
21

Veuillez noter que si vous liez des arguments depuis la gauche, vous devez appeler les arguments par leur nom. Si vous liez les arguments par la droite, cela fonctionne comme prévu.

>>> barfoo(5,6) 
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: foobar() got multiple values for keyword argument 'x'
>>> f = partial(foobar, z=20)
>>> f(1,1)
22

Answer 5

Cela fonctionnerait aussi :

def curry(func, *args):
    def curried(*innerargs):
       return func(*(args+innerargs))
    curried.__name__ = "%s(%s, ...)" % (func.__name__, ", ".join(map(str, args)))
    return curried

>>> w=curry(sys.stdout.write, "Hey there")
>>> w()
Hey there