为什么 Python 3.x 的 super() 很神奇？

Question

在 Python 3.x 中，可以不带参数调用super() ：

class A(object):
    def x(self):
         print("Hey now")

class B(A):
    def x(self):
        super().x()

>>> B().x()
Hey now

为了使这项工作，一些编译时魔术被执行，其后果之一是以下代码（将super重新super_到super_ ）失败：

super_ = super

class A(object):
    def x(self):
        print("No flipping")

class B(A):
    def x(self):
        super_().x()

>>> B().x()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in x
RuntimeError: super(): __class__ cell not found

为什么super()在没有编译器帮助的情况下无法在运行时解析超类？ 是否存在这种行为或其根本原因可能会咬到粗心的程序员的实际情况？

......而且，作为一个附带问题：Python 中是否还有其他函数、方法等示例可以通过将它们重新绑定到不同的名称来破坏？

Answer 1

添加了新的魔法super()行为以避免违反 DRY（不要重复自己）原则，请参阅PEP 3135 。 必须通过将类作为全局引用来显式命名类也容易出现与您使用super()本身发现的相同的重新绑定问题：

class Foo(Bar):
    def baz(self):
        return super(Foo, self).baz() + 42

Spam = Foo
Foo = something_else()

Spam().baz()  # liable to blow up

这同样适用于使用类装饰器，其中装饰器返回一个新对象，它重新绑定类名：

@class_decorator_returning_new_class
class Foo(Bar):
    def baz(self):
        # Now `Foo` is a *different class*
        return super(Foo, self).baz() + 42

神奇的super() __class__单元让您可以访问原始类对象，从而很好地避开了这些问题。

PEP 由 Guido 发起，他最初设想super成为关键字，使用单元格查找当前类的想法也是他的. 当然，将其作为关键字的想法是PEP 初稿的一部分。

然而，实际上是 Guido 本人因为“太神奇”而放弃了关键字想法，而是提出了当前的实现。 他预计为super()使用不同的名称可能会出现问题：

我的补丁使用了一个中间解决方案：它假设您在使用名为'super'的变量时需要__class__ 。 因此，如果您（全局）将super重命名为supper并使用supper而不是super ，则它在没有参数的情况下将无法工作（但如果您将其传递给__class__或实际的类对象，它仍然可以工作）； 如果您有一个名为super的不相关变量，事情会起作用，但该方法将使用用于单元格变量的稍慢的调用路径。

因此，最终是 Guido 本人宣称使用super关键字感觉不对，并且提供一个神奇的__class__单元格是一个可以接受的折衷方案。

我同意实现的神奇、隐式行为有点令人惊讶，但super()是该语言中最被误用的函数之一。 看看网上发现的所有被误用的super(type(self), self)或super(self.__class__, self)调用； 如果从派生类中调用过任何代码， 您最终会遇到无限递归异常。 至少，没有参数的简化super()调用避免了这个问题。

至于重命名的super_ ； 刚才提到__class__在你的方法，以及它会重新工作。 如果您在方法中引用super或__class__名称，则会创建单元格：

>>> super_ = super
>>> class A(object):
...     def x(self):
...         print("No flipping")
... 
>>> class B(A):
...     def x(self):
...         __class__  # just referencing it is enough
...         super_().x()
... 
>>> B().x()
No flipping