¿Cómo enlazar un método no enlazado sin llamarlo?

Question 1

En Python, ¿hay alguna forma de vincular un método no vinculado 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 handler son métodos desatados, mi programa estalla en un estallido espectacular y lloro.

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

Question 2

Todas las funciones también descriptorespor lo que puede vincularlos llamando a su __get__ método:

bound_handler = handler.__get__(self, MyWidget)

Aquí está el excelente trabajo de R. Hettinger guía a los descriptores.

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

Question 3

Esto se puede hacer con types.MethodType:

import types

bound_handler = types.MethodType(handler, self)

Question 4

Con un cierretambién conocido como un expresión cerrada (a diferencia de un expresión abierta), que es una expresión sin variables libres:

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

Aquí handler y self son variables libres en la expresión lambda interna y variables ligadas en la expresión lambda exterior, y args y kwargs son variables vinculadas en las expresiones lambda interna y externa, por lo que la expresión lambda externa es un cierre.

Question 5

esto se unirá self a handler:

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

Esto funciona pasando self como primer argumento de la función. obj.f() es solo azúcar sintáctico para f(obj).

Question 6

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

Question 7

Para ampliar la respuesta de @Keith Pinson que usa un cierre y la respuesta de @brian-brazil que no lo hace, he aquí por qué la primera es correcta.

Ejemplo con cierre:

def handler(self, *args, **kwargs):
    return self


self = True
bound_handler = (lambda handler, self:
    lambda *args, **kwargs: handler(self, *args, **kwargs)
)(handler, self)
bound_handler()  # returns True
self = False
bound_handler()  # returns True
handler = print
bound_handler()  # returns True

La expresión lambda externa está cerrada, por lo que sus variables vinculadas handler y self no se puede rebotar. __get__, types.MethodTypey functools.partial tener el mismo comportamiento.

Ejemplo sin cierre:

def handler(self, *args, **kwargs):
    return self


self = True
bound_handler = lambda *args, **kwargs: handler(self, *args, **kwargs)
bound_handler()  # returns True
self = False
bound_handler()  # returns False
handler = print
bound_handler()  # prints False

La expresión lambda está abierta por lo que sus variables libres handler y self puede ser rebote.

¿Ha sido útil esta solución?