Python 重写实例上的特殊方法

我希望对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>'
>>>

---

这是因为为类而不是实例定义了特殊方法（

\uuuuuux\uuuuuuux（）

）

当您考虑

\uuuu new\uuuu（）

时，这是有意义的-不可能在实例上调用它，因为调用它时实例不存在

因此，如果您想：

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

---

或在个别情况下，如。（注意这里有很多相似之处，但我认为我的示例添加了足够多的内容来发布这篇文章）。

原因是为类而不是实例定义了特殊方法（

\uuuuuux\uuux（）

）

当您考虑

\uuuu new\uuuu（）

时，这是有意义的-不可能在实例上调用它，因为调用它时实例不存在

因此，如果您想：

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

---

或在个别情况下，如。（注意这里有很多相似之处，但我认为我的示例添加了足够多的内容来发布这篇文章）。

Python不调用特殊方法，这些方法的名称在实例上用

\uuuuu>包围，但仅在类上调用，显然是为了提高性能。因此，无法直接在实例上重写
\uuu repr\uu（）
，并使其工作。相反，您需要这样做：

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

现在，您可以通过替换
\u repr（）
来覆盖实例上的
\u repr（）
，Python不调用特殊方法，这些方法的名称在实例上被
\u repr>包围，而仅在类上，显然是为了提高性能。因此，无法直接在实例上重写
\uuu repr\uu（）
，并使其工作。相反，您需要这样做：

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

现在，通过将新样式类替换为
\u repr（）
，可以覆盖实例上的
\u repr（）
，，Python使用绕过实例的特殊方法查找。以下是摘录自：

您可以更改为旧式类（不从对象继承），也可以向该类添加dispatcher方法（向前查找实例的方法）。有关实例分派器方法的示例，请参见
中的配方。对于新样式的类，Python使用绕过实例的特殊方法查找。以下是摘录自：

您可以更改为旧式类（不从对象继承），也可以向该类添加dispatcher方法（向前查找实例的方法）。有关实例调度程序方法的示例，请参见中的配方：

对于自定义类，只有在对象的类型上定义了特殊方法的隐式调用，而不是在对象的实例字典中定义了特殊方法的隐式调用，才能保证其正常工作……除了为了正确性而绕过任何实例属性外，隐式特殊方法查找通常也会绕过
\uuu getattribute\uuuuuuuu（）
对象元类的方法

（如果你对此感兴趣，我删掉的部分解释了这背后的原理。）

Python没有明确记录实现应该或不应该在类型上查找方法的时间；实际上，所有的it文档都是实现可能会也可能不会查看实例以进行特殊的方法查找，因此您不应该指望这两种方法

正如您可以从测试结果中猜到的，在CPython实现中，
\uuuu repr\uuu
是在类型上查找的函数之一


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


人们希望这样做的最常见的原因是对一个对象的不同实例进行猴子补丁，以执行不同的操作。你不能用特殊的方法，所以…你能做什么？有一个干净的解决方案，也有一个粗糙的解决方案

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

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)

黑客解决方案是动态构建一个新的子类，并对对象重新分类。我怀疑任何人如果真的有这样一个好主意，都会从那句话中知道如何实现它，而任何不知道如何实现的人都不应该尝试，所以我就到此为止。
如中所述：

对于自定义类，只有在对象的类型上定义了特殊方法的隐式调用，而不是在对象的实例字典中定义了特殊方法的隐式调用，才能保证其正常工作……除了为了正确性而绕过任何实例属性外，隐式特殊方法查找通常也会绕过
\uuu getattribute\uuuuuuuu（）
对象元类的方法

（如果你对此感兴趣，我删掉的部分解释了这背后的原理。）

Python没有明确记录实现应该或不应该在类型上查找方法的时间；实际上，所有的it文档都是实现可能会也可能不会查看实例以进行特殊的方法查找，因此您不应该指望这两种方法

正如您可以从测试结果中猜到的，在CPython实现中，
\uuuu repr\uuu
是在类型上查找的函数之一


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


人们希望这样做的最常见的原因是对一个对象的不同实例进行猴子补丁，以执行不同的操作。你不能用特殊的方法，所以…你能做什么？有一个干净的解决方案，也有一个粗糙的解决方案

清洁的解决方案是在表面上实施一种特殊方法
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

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

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

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