Python: lier une méthode non liée?

En Python, existe-t-il un moyen de lier une méthode indépendante sans l'appeler?

J'écris un programme wxPython, et pour une certaine classe, j'ai décidé que ce serait bien de regrouper les données de tous mes boutons sous forme de liste de tuples au niveau de la classe, comme ceci:

class MyWidget(wx.Window):
    buttons = [("OK", OnOK),
               ("Cancel", OnCancel)]

    # ...

    def Setup(self):
        for text, handler in MyWidget.buttons:

            # This following line is the problem line.
            b = wx.Button(parent, label=text).Bind(wx.EVT_BUTTON, handler)

Le problème est que, puisque toutes les valeurs de handlersont des méthodes non liées, mon programme explose dans une flambée spectaculaire et je pleure.

Je cherchais en ligne une solution à ce qui semble être un problème relativement simple et résoluble. Malheureusement, je n'ai rien trouvé. En ce moment, j'utilise functools.partialpour contourner ce problème, mais est-ce que quelqu'un sait s'il existe une manière pythonique, saine et propre de lier une méthode non liée à une instance et de continuer à la transmettre sans l'appeler?

Toutes les fonctions sont également des descripteurs , vous pouvez donc les lier en appelant leur __get__méthode:

bound_handler = handler.__get__(self, MyWidget)

Voici l'excellent guide des descripteurs de R. Hettinger .

En tant qu'exemple autonome tiré du commentaire de Keith :

def bind(instance, func, as_name=None):
    """
    Bind the function *func* to *instance*, with either provided name *as_name*
    or the existing name of *func*. The provided *func* should accept the 
    instance as the first argument, i.e. "self".
    """
    if as_name is None:
        as_name = func.__name__
    bound_method = func.__get__(instance, instance.__class__)
    setattr(instance, as_name, bound_method)
    return bound_method

class Thing:
    def __init__(self, val):
        self.val = val

something = Thing(21)

def double(self):
    return 2 * self.val

bind(something, double)
something.double()  # returns 42

Cela peut être fait proprement avec types.MethodType . Exemple:

import types

def f(self): print self

class C(object): pass

meth = types.MethodType(f, C(), C) # Bind f to an instance of C
print meth # prints <bound method C.f of <__main__.C object at 0x01255E90>>

Créer une fermeture avec soi-même ne liera pas techniquement la fonction, mais c'est une manière alternative de résoudre le même problème sous-jacent (ou très similaire). Voici un exemple trivial:

self.method = (lambda self: lambda args: self.do(args))(self)

Cela se liera selfà handler:

bound_handler = lambda *args, **kwargs: handler(self, *args, **kwargs)

Cela fonctionne en passant selfcomme premier argument à la fonction. object.function()est juste du sucre syntaxique pour function(object).

En retard à la fête, mais je suis venu ici avec une question similaire: j'ai une méthode de classe et une instance, et je veux appliquer l'instance à la méthode.

Au risque de trop simplifier la question de l'OP, j'ai fini par faire quelque chose de moins mystérieux qui pourrait être utile à d'autres qui arrivent ici (mise en garde: je travaille en Python 3 - YMMV).

Considérez cette classe simple:

class Foo(object):

    def __init__(self, value):
        self._value = value

    def value(self):
        return self._value

    def set_value(self, value):
        self._value = value

Voici ce que vous pouvez en faire:

>>> meth = Foo.set_value   # the method
>>> a = Foo(12)            # a is an instance with value 12
>>> meth(a, 33)            # apply instance and method
>>> a.value()              # voila - the method was called
33