Python: vincular um método não vinculado?

Em Python, existe uma maneira de vincular um método não vinculado sem chamá-lo?

Estou escrevendo um programa wxPython e, para uma determinada classe, decidi que seria bom agrupar os dados de todos os meus botões como uma lista de tuplas em nível de classe, assim:

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)

O problema é que, como todos os valores de handlersão métodos desvinculados, meu programa explode em um incêndio espetacular e eu choro.

Eu estava procurando online por uma solução para o que parece ser um problema relativamente simples e solucionável. Infelizmente não consegui encontrar nada. No momento, estou usando functools.partialpara contornar isso, mas alguém sabe se existe uma maneira Pythônica com sensação de limpeza, saudável, de vincular um método não acoplado a uma instância e continuar passando-o sem chamá-lo?

Todas as funções também são descritores , portanto, você pode vinculá-las chamando seu __get__método:

bound_handler = handler.__get__(self, MyWidget)

Aqui está o excelente guia de descritores de R. Hettinger .

Como um exemplo independente retirado do comentário 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

Isso pode ser feito de forma limpa com types.MethodType . Exemplo:

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

Criar um fechamento com self nele não vinculará tecnicamente a função, mas é uma maneira alternativa de resolver o mesmo (ou muito semelhante) problema subjacente. Aqui está um exemplo trivial:

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

Isso se ligará selfa handler:

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

Isso funciona passando selfcomo o primeiro argumento para a função. object.function()é apenas açúcar sintático para function(object).

Atrasado para a festa, mas cheguei aqui com uma pergunta semelhante: Tenho um método de classe e uma instância e quero aplicar a instância ao método.

Correndo o risco de simplificar demais a pergunta do OP, acabei fazendo algo menos misterioso que pode ser útil para outras pessoas que chegam aqui (ressalva: estou trabalhando em Python 3 - YMMV).

Considere esta classe simples:

class Foo(object):

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

    def value(self):
        return self._value

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

Aqui está o que você pode fazer com ele:

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