Python: ¿vincular un método independiente?

En Python, ¿hay alguna forma de vincular un método independiente sin llamarlo?

Estoy escribiendo un programa wxPython, y para una determinada clase decidí que sería bueno agrupar los datos de todos mis botones como una lista de tuplas a nivel de clase, así:

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)

El problema es que, dado que todos los valores de handlerson métodos independientes, mi programa explota en un resplandor espectacular y lloro.

Estaba buscando en línea una solución a lo que parece ser un problema relativamente sencillo y con solución. Desafortunadamente no pude encontrar nada. En este momento, estoy usando functools.partialpara solucionar esto, pero ¿alguien sabe si hay una forma Pythonic saludable y limpia para vincular un método no vinculado a una instancia y continuar pasándolo sin llamarlo?

Todas las funciones también son descriptores , por lo que puede vincularlas llamando a su __get__método:

bound_handler = handler.__get__(self, MyWidget)

Aquí está la excelente guía de descriptores de R. Hettinger .

Como ejemplo autónomo extraído del comentario 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

Esto se puede hacer limpiamente con types.MethodType . Ejemplo:

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>>

Crear un cierre con self en él no vinculará técnicamente la función, pero es una forma alternativa de resolver el mismo problema subyacente (o muy similar). Aquí tienes un ejemplo trivial:

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

Esto se unirá selfa handler:

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

Esto funciona pasando selfcomo primer argumento a la función. object.function()es solo azúcar sintáctico para function(object).

Llegué tarde a la fiesta, pero vine aquí con una pregunta similar: tengo un método de clase y una instancia, y quiero aplicar la instancia al método.

A riesgo de simplificar demasiado la pregunta del OP, terminé haciendo algo menos misterioso que puede ser útil para otros que lleguen aquí (advertencia: estoy trabajando en Python 3 - YMMV).

Considere esta clase 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

Esto es lo que puede hacer con él:

>>> 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