Python Argument Liants

Comment puis-je lier les arguments d'une méthode Python pour stocker un nullary functor pour plus tard invocation? Similaire à C++de boost::bind.

Par exemple:

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

add_5 = magic_function(add, 5)
assert add_5(3) == 8
InformationsquelleAutor Dustin Getz | 2008-11-10
  1. 72

    functools.partielle retourne un callable emballage d'une fonction avec certains ou tous les arguments congelés.

    import sys
import functools

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

print_hello()
    Hello world

    Ci-dessus l'utilisation est équivalent à celui-ci lambda.

    print_hello = lambda *a, **kw: sys.stdout.write("Hello world\n", *a, **kw)
    • pour python2.6 au moins, vous pouvez utiliser à partir de avenir importer print_function
    InformationsquelleAutor Jeremy Banks
  2. 43

    Je ne suis pas trop familier avec boost::bind, mais le partial fonction de 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
    • c'est un meilleur exemple que l'on a accepté la réponse, parce qu'elle montre partielle de la liaison.
    InformationsquelleAutor Matthew Trevor
  3. 11

    Si functools.partial n'est pas disponible, alors 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
    InformationsquelleAutor jfs
  4. 9

    lambdas vous permettre 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 prévoyez utiliser un argument nommé obligatoire dans l'appel de fonction, ceci est aussi valable:

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

    Notez bien que l' 

    >>> 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
    • Ce doit être la accepté de répondre. C'est le Pythonic moyen de lier les arguments pour callables
    InformationsquelleAutor Alex
  5. 7

    Ce serait le travail, trop:

    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
    • Ce n'est pas un curry. Nourrissage est pour les fonctions à plusieurs arguments. Curry fonctionne comme ceci: étant Donné g = curry(f), nous avons f(x1,x2,...) = g(x1)(x2)...
    InformationsquelleAutor Claudiu
  6. 1

    Foncteurs peuvent être définis de cette façon en Python. Ils sont remboursables objets. La "liaison" de simples ensembles de valeurs d'argument.

    class SomeFunctor( object ):
    def __init__( self, arg1, arg2=None ):
        self.arg1= arg1
        self.arg2= arg2
    def __call___( self, arg1=None, arg2=None ):
        a1= arg1 or self.arg1
        a2= arg2 or self.arg2
        # do something
        return

    Vous pouvez faire des choses comme

    x= SomeFunctor( 3.456 )
x( arg2=123 )

y= SomeFunctor( 3.456, 123 )
y()
    • modèle intéressant, beaucoup de passe-partout pour trivial fonctions.
    • Vous pouvez le couper à quelque chose de beaucoup plus simple, en fonction de votre utilisation réelle des cas. La question d'origine ne fournit aucune indication sur la façon dont la liaison se produit. Sans plus de précisions, il y a de trop nombreuses bases de couverture.
    InformationsquelleAutor S.Lott