未绑定方法与绑定方法

Question

我希望有人可以回答这个对Python有深刻理解的内容：）

请考虑以下代码：

>>> class A(object):
...     pass
...
>>> def __repr__(self):
...     return "A"
...
>>> from types import MethodType
>>> a = A()
>>> a
<__main__.A object at 0x00AC6990>
>>> repr(a)
'<__main__.A object at 0x00AC6990>'
>>> setattr(a, "__repr__", MethodType(__repr__, a, a.__class__))
>>> a
<__main__.A object at 0x00AC6990>
>>> repr(a)
'<__main__.A object at 0x00AC6990>'
>>>

注意repr（a）如何不产生“A”的预期结果？我想知道为什么会这样，如果有办法实现这个目标......

我对比一下，下面的例子有效（也许是因为我们没有尝试覆盖特殊方法？）：

>>> class A(object):
...     def foo(self):
...             return "foo"
...
>>> def bar(self):
...     return "bar"
...
>>> from types import MethodType
>>> a = A()
>>> a.foo()
'foo'
>>> setattr(a, "foo", MethodType(bar, a, a.__class__))
>>> a.foo()
'bar'
>>>

Answer 1

Python不会调用特殊方法，即名称在实例上包含__的方法，但仅限于类，显然是为了提高性能。因此，无法直接在实例上覆盖__repr__()并使其正常工作。相反，你需要这样做：

class A(object):
    def __repr__(self):
        return self._repr()
    def _repr(self):
        return object.__repr__(self)

现在，您可以通过替换__repr__()来覆盖实例上的_repr()。

Answer 2

如Special Method Lookup中所述：

对于自定义类，只保证在对象的类型上定义特殊方法的隐式调用才能正常工作，而不是在对象的实例字典中定义...除了为了正确性而绕过任何实例属性之外，通常隐式特殊方法查找也绕过对象的元类
的__getattribute__()方法

（如果您对此感兴趣的话，我已经删除的部分解释了这背后的理由。）

Python没有准确记录实现应该或不应该在类型上查找方法的时间;所有这些文档实际上是实现可能会或可能不会查看特殊方法查找的实例，因此您不应该依赖它们。

正如您可以从测试结果中猜测的那样，在CPython实现中，__repr__是查找该类型的函数之一。

2.x中的情况略有不同，主要是因为经典类的存在，但只要您只创建新式类，您就可以将它们视为相同。

人们想要这样做的最常见原因是猴子修补对象的不同实例以执行不同的操作。你不能用特殊方法做到这一点，所以......你能做什么？这是一个干净的解决方案和一个hacky解决方案。

干净的解决方案是在类上实现一个特殊方法，该方法只调用实例上的常规方法。然后你可以在每个实例上修补常规方法。例如：

class C(object):
    def __repr__(self):
        return getattr(self, '_repr')()
    def _repr(self):
        return 'Boring: {}'.format(object.__repr__(self))

c = C()
def c_repr(self):
    return "It's-a me, c_repr: {}".format(object.__repr__(self))
c._repr = c_repr.__get__(c)

hacky解决方案是动态构建一个新的子类并重新对对象进行类。我怀疑任何真正有这种情况的人会知道如何从那句话中实现它，任何不知道该怎么做的人都不应该尝试，所以我＆＃39;我会留下它。

Answer 3

原因是为类而不是实例定义了特殊方法（__x__()）。

当您考虑__new__()时，这是有道理的 - 在实例上调用它是不可能的，因为实例在调用时不存在。

如果您愿意，可以在整个课堂上这样做：

>>> A.__repr__ = __repr__
>>> a
A

或在单个实例上，in kindall's answer。（请注意，这里有很多相似之处，但我认为我的示例也足以发布此内容。）

Answer 4

对于新样式类，Python使用绕过实例的特殊方法查找。这里摘录自the source：

  1164 /* Internal routines to do a method lookup in the type
  1165    without looking in the instance dictionary
  1166    (so we can't use PyObject_GetAttr) but still binding
  1167    it to the instance.  The arguments are the object,
  1168    the method name as a C string, and the address of a
  1169    static variable used to cache the interned Python string.
  1170 
  1171    Two variants:
  1172 
  1173    - lookup_maybe() returns NULL without raising an exception
  1174      when the _PyType_Lookup() call fails;
  1175 
  1176    - lookup_method() always raises an exception upon errors.
  1177 
  1178    - _PyObject_LookupSpecial() exported for the benefit of other places.
  1179 */

您可以更改为旧式类（不从 object 继承），也可以向该类添加调度程序方法（将查找转发回实例的方法）。有关实例调度程序方法的示例，请参阅http://code.activestate.com/recipes/578091

处的食谱

Answer 5

TLDR：不可能在实例上定义适当的，未绑定的方法。这也适用于特殊方法。由于绑定方法是一类对象，因此在某些情况下差异并不明显。但是，在需要时，Python总是将特殊方法视为适当的未绑定方法。

您始终可以手动退回到使用更通用的属性访问的特殊方法。属性访问涵盖了存储为属性的绑定方法以及根据需要绑定的未绑定方法。这类似于__repr__或其他方法使用属性来定义其输出的方式。

class A:
    def __init__(self, name):
        self.name = name

    def __repr__(self):
        # call attribute to derive __repr__
        return self.__representation__()

    def __representation__(self):
        return f'{self.__class__.__name__}({self.name})'

    def __str__(self):
        # return attribute to derive __str__
        return self.name

未绑定方法与绑定方法

Python中的方法有两种含义：类的 unbound 方法和该类实例的 bound 方法。

未绑定方法是一个类或其基类之一的常规函数。可以在类定义期间定义它，也可以稍后添加。

>>> class Foo:
...     def bar(self): print('bar on', self)
...
>>> Foo.bar
<function __main__.Foo.bar(self)>

一个未绑定的方法在类上仅存在一次-所有实例都相同。

绑定方法是已绑定到特定实例的未绑定方法。这通常意味着该方法是通过实例进行查找的，该实例调用了函数的__get__ method。

>>> foo = Foo()
>>> # lookup through instance
>>> foo.bar
<bound method Foo.bar of <__main__.Foo object at 0x10c3b6390>>
>>> # explicit descriptor invokation
>>> type(foo).bar.__get__(foo, type(Foo))
<bound method Foo.bar of <__main__.Foo object at 0x10c3b6390>>

就Python而言，“方法”通常表示根据需要绑定到其实例的未绑定方法。当Python需要特殊方法时，它将直接为未绑定方法调用描述符协议。因此，该方法将在类上查找；实例上的属性将被忽略。

对象的绑定方法

每次从其实例中获取绑定方法时，都会重新创建一个绑定方法。结果是具有身份的一流对象，可以对其进行存储和传递，并在以后调用。

>>> foo.bar is foo.bar # binding happens on every lookup False >>> foo_bar = foo.bar # bound methods can be stored >>> foo_bar() # stored bound methods can be called later bar on <__main__.Foo object at 0x10c3b6390> >>> foo_bar() bar on <__main__.Foo object at 0x10c3b6390>

能够存储绑定方法意味着也可以存储为属性。在其绑定实例上存储绑定方法会使它看起来与未绑定方法相似。但是实际上，存储的绑定方法的行为略有不同，可以存储在允许属性的任何对象上。

>>> foo.qux = foo.bar >>> foo.qux <bound method Foo.bar of <__main__.Foo object at 0x10c3b6390>> >>> foo.qux is foo.qux # binding is not repeated on every lookup! True >>> too = Foo() >>> too.qux = foo.qux # bound methods can be stored on other instances! >>> too.qux # ...but are still bound to the original instance! <bound method Foo.bar of <__main__.Foo object at 0x10c3b6390>> >>> import builtins >>> builtins.qux = foo.qux # bound methods can be stored... >>> qux # ... *anywhere* that supports attributes <bound method Foo.bar of <__main__.Foo object at 0x10c3b6390>>

就Python而言，绑定方法只是常规的可调用对象。就像它无法知道too.qux是否是too的方法一样，它也无法推断too.__repr__是否也是一种方法。

覆盖实例上的特殊方法

5 个答案:

未绑定方法与绑定方法

对象的绑定方法