Warning: file_get_contents(/data/phpspider/zhask/data//catemap/2/python/362.json): failed to open stream: No such file or directory in /data/phpspider/zhask/libs/function.php on line 167

Warning: Invalid argument supplied for foreach() in /data/phpspider/zhask/libs/tag.function.php on line 1116

Notice: Undefined index: in /data/phpspider/zhask/libs/function.php on line 180

Warning: array_chunk() expects parameter 1 to be array, null given in /data/phpspider/zhask/libs/function.php on line 181
Python 重写实例上的特殊方法_Python_Metaprogramming - Fatal编程技术网

Python 重写实例上的特殊方法

Python 重写实例上的特殊方法,python,metaprogramming,Python,Metaprogramming,我希望对Python有深刻理解的人能够回答这个问题:) 考虑以下代码: >>> class A(object): ... pass ... >>> def __repr__(self): ... return "A" ... >>> from types import MethodType >>> a = A() >>> a <__main__.A object at 0x00AC69

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

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

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使用绕过实例的特殊方法查找。以下是摘录自:

您可以更改为旧式类(不从对象继承),也可以向该类添加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)

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

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

您始终可以手动退回到使用更通用的属性访问的特殊方法。属性访问既包括作为属性存储的绑定方法,也包括根据需要绑定的未绑定方法。这类似于
或其他方法使用属性定义其输出的方式

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)>
>>> 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>
就Python而言,“方法”通常指根据需要绑定到其实例的未绑定方法。当Python需要一个特殊的方法时,它直接调用未绑定方法的描述符协议。因此,在类上查找该方法;实例上的属性将被忽略


对象上的绑定方法 每次从其实例获取绑定方法时,都会重新创建它。结果是一个具有标识的第一类对象,可以存储和传递,并在以后调用

>>> class Foo:
...     def bar(self): print('bar on', self)
...
>>> Foo.bar
<function __main__.Foo.bar(self)>
>>> 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.bar就是foo.bar#每次查找都会绑定
假的
>>>foo_bar=foo.bar#可以存储绑定的方法
>>>foo_bar()#以后可以调用存储绑定方法
阻止
>>>福巴()
阻止
能够存储绑定方法意味着它们也可以存储为属性。将绑定方法存储在其绑定实例上使其看起来类似于未绑定方法。但事实上,存储绑定方法的行为有细微的不同,可以存储在允许属性的任何对象上

>>> 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>>
>>foo.qux=foo.bar
>>>foo.qux
>>>foo.qux是foo.qux#绑定不会在每次查找中重复!
真的
>>>too=Foo()
>>>too.qux=foo.qux#绑定的方法可以存储在其他实例上!
>>>too.qux#…但仍绑定到原始实例!
>>>进口内置设备
>>>builtins.qux=foo.qux#可以存储绑定的方法。。。
>>>库克斯*支持属性的anywhere*
就Python而言,绑定方法只是常规的、可调用的对象。正如它无法知道
是否太过。qux
太过
的一种方法,它也无法推断
是否太过
>>> 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>>