Python: associare un metodo non associato?

In Python, c'è un modo per associare un metodo non associato senza chiamarlo?

Sto scrivendo un programma wxPython e per una certa classe ho deciso che sarebbe stato bello raggruppare i dati di tutti i miei pulsanti insieme come un elenco di tuple a livello di classe, in questo modo:

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)

Il problema è che, poiché tutti i valori di handlersono metodi non vincolati, il mio programma esplode in un tripudio spettacolare e io piango.

Stavo cercando una soluzione online a quello che sembra dovrebbe essere un problema relativamente semplice e risolvibile. Purtroppo non sono riuscito a trovare niente. In questo momento, sto usando functools.partialper aggirare questo problema, ma qualcuno sa se esiste un modo pulito, sano e pitonico per associare un metodo non associato a un'istanza e continuare a trasmetterlo senza chiamarlo?

Tutte le funzioni sono anche descrittori , quindi puoi associarle chiamando il loro __get__metodo:

bound_handler = handler.__get__(self, MyWidget)

Ecco l'eccellente guida ai descrittori di R. Hettinger .

Come esempio autonomo tratto dal commento di 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

Questo può essere fatto in modo pulito con types.MethodType . Esempio:

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

Creare una chiusura con il sé in essa non vincolerà tecnicamente la funzione, ma è un modo alternativo di risolvere lo stesso (o molto simile) problema sottostante. Ecco un esempio banale:

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

Questo si vincolerà selfa handler:

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

Funziona passando selfcome primo argomento alla funzione. object.function()è solo zucchero sintattico per function(object).

In ritardo alla festa, ma sono venuto qui con una domanda simile: ho un metodo di classe e un'istanza e voglio applicare l'istanza al metodo.

A rischio di semplificare eccessivamente la domanda dell'OP, ho finito per fare qualcosa di meno misterioso che potrebbe essere utile ad altri che arrivano qui (avvertimento: sto lavorando in Python 3 - YMMV).

Considera questa semplice classe:

class Foo(object):

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

    def value(self):
        return self._value

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

Ecco cosa puoi fare con esso:

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