27

我希望有人可以回答这个对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'
>>>
4

5 回答 5

29

Python 通常不会调用__实例上的特殊方法，即名称被包围的方法，而只会在类上调用。（虽然这是一个实现细节，但它是标准解释器 CPython 的特性。）所以没有办法__repr__()直接覆盖实例并使其工作。相反，您需要执行以下操作：

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

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

于 2012-04-29T22:42:30.703 回答
11

如特殊方法查找中所述：

对于自定义类，特殊方法的隐式调用只有在对象类型上定义时才能保证正确工作，而不是在对象的实例字典中......除了为了正确性而绕过任何实例属性之外，隐式特殊方法查找通常还绕过__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 的解决方案是动态构建一个新的子类并重新分类对象。我怀疑任何真正有这种情况的人都会知道如何从那句话中实现它，而任何不知道如何实现的人都不应该尝试，所以我就这样吧。

于 2014-09-26T01:28:34.710 回答
4

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

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

因此，如果您愿意，可以对整个班级执行此操作：

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

或在个别情况下，如kindall 的回答。（注意这里有很多相似之处，但我认为我的示例添加到足以发布此内容）。

于 2012-04-29T22:37:38.163 回答
3

对于新样式类，Python 使用一种绕过实例的特殊方法查找。这里是源代码的摘录：

  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上的配方

于 2012-04-29T23:10:40.427 回答
0

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中的方法有两种含义：类的未绑定方法和该类实例的绑定方法。

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

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

一个未绑定的方法在类上只存在一次——它对所有实例都是相同的。

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

>>> 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__是方法。

于 2019-10-21T12:37:55.017 回答