python - super().method() 与 super(self.__class__,self).method() 之间的区别

Question

这个问题已经有答案了:

When calling super() in a derived class, can I pass in self.__class__? [duplicate] (2 个回答)

已关闭 9 年前。

这是我试图编写的代码:

class A(object):
    def bind_foo(self):
        old_foo = self.foo
        def new_foo():
            old_foo()
            #super().foo()
            super(self.__class__,self).foo()

        self.foo = new_foo

    def __init__(self):
        print("A __init__")          

    def foo(self):
        print("A foo")

class B(A):
    def __init__(self):
        print("B __init__")
        super().__init__()

    def foo(self):
        print("B foo")
        super().foo()

class C(A):
    def __init__(self):
        print("C __init__")
        super().__init__()
        super().bind_foo()

    def foo(self):
        print("C foo")    

b  = B()
b.foo()

c = C()
c.foo()

B 类和 A 类是预期的行为，即当我调用 b.foo() 时，它调用 a.foo()以及 super() 。 C 类是试图模仿 child B 和 parent A 的行为，但这次我不想明确地输入 super().foo()在子类，但我仍然想要家长 foo()被称为。它按预期工作。

但是，我不太明白的是，在 A.bind_foo 下，我必须使用super(self.__class__,self).foo()而不是super().foo 。 super().foo给出一个

"SystemError: super(): no arguments". 

有人能解释一下为什么会这样吗？

Answer 1

您不应该使用self.__class__或type(self)调用super()时.

在 Python 3 中，调用 super()不带参数相当于 super(B, self) (在类 B 的方法内)；请注意类的显式命名。 Python编译器添加了__class__使用 super() 的方法的闭合单元不带参数(请参阅 Why is Python 3.x's super() magic? )引用正在定义的当前类。

如果您使用super(self.__class__, self)或super(type(self), self) ，当子类尝试调用该方法时，您将遇到无限递归异常；那时self.__class__是派生类，而不是原始类。请参阅When calling super() in a derived class, can I pass in self.__class__?

总结一下，在 Python 3 中:

class B(A):
    def __init__(self):
        print("B __init__")
        super().__init__()

    def foo(self):
        print("B foo")
        super().foo()

等于:

class B(A):
    def __init__(self):
        print("B __init__")
        super(B, self).__init__()

    def foo(self):
        print("B foo")
        super(B, self).foo()

但您应该使用前者，因为这样可以避免重复。

在 Python 2 中，您只能使用第二种形式。

为了您的bind_foo()方法，您必须传入一个显式类来从中搜索 MRO，因为 Python 编译器无法确定当您绑定(bind)新的替换 foo 时使用哪个类。 :

def bind_foo(self, klass=None):
    old_foo = self.foo
    if klass is None:
        klass = type(self)

    def new_foo():
        old_foo()
        super(klass, self).foo()

    self.foo = new_foo

您可以使用__class__ (没有 self )让 Python 为您提供闭包单元，但这将是对 A 的引用，不是C这里。当您绑定(bind)新的foo时，您希望在 MRO 中搜索覆盖的方法从 C 开始搜索反而。

请注意，如果您现在创建一个类 D ，从 C 子类化，事情会再次出错，因为现在您正在调用 bind_foo()依次调用super()与 D ，不是C ，作为起点。那么您最好的选择就是调用bind_foo()带有显式类引用。这里__class__ (没有 self. )会很好:

class C(A):
    def __init__(self):
        print("C __init__")
        super().__init__()
        self.bind_foo(__class__)

现在您的行为与使用 super() 相同不带参数，对 current 类的引用，您在其中定义方法 __init__ ，传递给super() ，使得new_foo()其行为就像直接在 C 的类定义中定义一样.

请注意，调用 bind_foo() 是没有意义的。上super()这里;你没有在这里重写它，所以你可以直接调用 self.bind_foo()相反。