如何绑定未绑定的方法而不调用它？

Question

在Python中，有没有一种方法可以绑定未绑定的方法而不调用它？

我正在编写一个 wxPython 程序，对于某个类，我决定将所有按钮的数据作为类级元组列表分组在一起会很好，如下所示：

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)

问题是，因为handler 是未绑定的方法，我的程序在一场壮观的大火中爆炸，我哭了。

我在网上寻找一个似乎应该是相对简单、可解决的问题的解决方案。 不幸的是我找不到任何东西。 现在，我正在使用 functools.partial 来解决这个问题，但是有谁知道是否有一种干净、健康、Pythonic 的方式将未绑定的方法绑定到实例并继续传递它而无需调用它？

Answer 1

所有函数也是描述符，因此您可以通过调用它们的 __get__ 方法来绑定它们：

bound_handler = handler.__get__(self, MyWidget)

这是 R. Hettinger 的优秀 描述符指南。

---

作为一个独立的示例，来自 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

Answer 2

这可以通过 types.MethodType< 来完成/a>：

import types

bound_handler = types.MethodType(handler, self)

Answer 3

使用闭包，也称为封闭表达式（与开放表达式相反），这是一个没有自由变量：

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

这里handler和self是内部lambda表达式中的自由变量，外部 lambda 表达式中的绑定变量，而 args 和 kwargs 是两个表达式中的绑定变量内部和外部 lambda 表达式，因此外部 lambda 表达式是一个闭包。

Answer 4

这会将 self 绑定到 handler：

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

这通过将 self 作为第一个参数传递给函数来实现。 obj.f() 只是 f(obj) 的语法糖。

Answer 5

聚会迟到了，但我带着类似的问题来到这里：我有一个类方法和一个实例，并且想要将该实例应用于该方法。

冒着过度简化OP问题的风险，我最终做了一些不太神秘的事情，这可能对到达这里的其他人有用（警告：我正在Python 3 - YMMV中工作）。

考虑这个简单的类：

class Foo(object):

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

    def value(self):
        return self._value

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

您可以使用它执行以下操作：

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

Answer 6

扩展@Keith Pinson的答案，它使用闭包和@brian-brazil 的答案 没有，这就是为什么前者是正确的。

带闭包的示例：

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

外部 lambda 表达式已关闭，因此其绑定变量 handler 和 self 无法重新绑定。 __get__、types.MethodType 和 functools.partial 具有相同的行为。

没有闭包的示例：

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

lambda 表达式是开放的，因此它的自由变量 handler 和 self 可以被重新绑定。