将 super 与类方法一起使用

Question

我正在尝试学习 Python 中的 super() 函数。

我以为我已经掌握了它，直到我看到这个例子（2.6）并发现自己陷入困境。

http://www.cafepy.com/article/python_attributes_and_methods/python_attributes_and_methods.html#super-with-classmethod-example

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "test.py", line 9, in do_something
    do_something = classmethod(do_something)
TypeError: unbound method do_something() must be called with B instance as first argument (got nothing instead)
>>>

当我在示例之前读到这一行时，这不是我所期望的：

如果我们'当使用类方法时，我们没有调用 super 的实例。对我们来说幸运的是，即使将类型作为第二个参数， super 也能工作。 --- 类型可以直接传递给 super ，如下所示。

Python 告诉我，应该用 B 的实例调用 do_something() ，这正是不可能的。

Answer 1

有时，必须更多地阅读文本才能了解想法的风格，而不是细节。这是其中之一。

在链接页面中，示例2.5、2.6和2.7都应该使用一种方法，do_your_stuff。 （也就是说，do_something 应更改为 do_your_stuff。）

此外，如 Ned Deily 指出，A.do_your_stuff 必须是一个类方法。

class A(object):
    @classmethod
    def do_your_stuff(cls):
        print 'This is A'

class B(A):
    @classmethod
    def do_your_stuff(cls):
        super(B, cls).do_your_stuff()

B.do_your_stuff()

super(B, cls).do_your_stuff
返回绑定方法（请参阅脚注 2 ）。由于 cls 作为第二个参数传递给 super()，因此 cls 绑定到返回的方法。换句话说，cls 作为第一个参数传递给类 A 的 do_your_stuff() 方法。

重申一下：super(B, cls).do_your_stuff( ) 导致 A 的 do_your_stuff 方法成为
使用作为第一个参数传递的 cls 进行调用。为了使其发挥作用，A 的
do_your_stuff 必须是类方法。链接页面没有提到这一点，
但事实确实如此。

附言。 do_something = classmethod(do_something) 是创建类方法的旧方法。
新的方法是使用 @classmethod 装饰器。

---

请注意，super(B, cls) 不能被 super(cls, cls) 替换。这样做可能会导致无限循环。例如，

class A(object):
    @classmethod
    def do_your_stuff(cls):
        print('This is A')

class B(A):
    @classmethod
    def do_your_stuff(cls):
        print('This is B')
        # super(B, cls).do_your_stuff()  # CORRECT
        super(cls, cls).do_your_stuff()  # WRONG

class C(B):
    @classmethod
    def do_your_stuff(cls):
        print('This is C')
        # super(C, cls).do_your_stuff()  # CORRECT
        super(cls, cls).do_your_stuff()  # WRONG

C.do_your_stuff()

将引发RuntimeError：调用 Python 对象时超出最大递归深度。

如果 cls 是 C，则 super(cls, cls) 会在 C.mro() 中搜索以下类：位于C之后。

In [161]: C.mro()
Out[161]: [__main__.C, __main__.B, __main__.A, object]

由于该类是 B，当 cls 是 C 时，super(cls, cls).do_your_stuff() <强>总是调用B.do_your_stuff。由于 super(cls, cls).do_your_stuff() 是在 B.do_your_stuff 内部调用的，因此您最终会在无限循环中调用 B.do_your_stuff 。

在 Python3 中，0 参数形式的 super 是为了让 super(B, cls) 可以被 super() 替换，并且 Python3 会从上下文中找出 super() class B 定义中的 > 应该等同于 super(B, cls)。

但在任何情况下 super(cls, cls) （或出于类似原因，super(type(self), self)）都是正确的。

Answer 2

在 Python 3 中，您可以跳过为 super 指定参数，

class A:
    @classmethod
    def f(cls):
        return "A's f was called."

class B(A):
    @classmethod
    def f(cls):
        return super().f()

assert B.f() == "A's f was called."

Answer 3

我更新了这篇文章，使其更加清晰： Python属性和方法 # Super

上面使用 classmethod 的示例显示了类方法是什么 - 它传递类本身而不是实例作为第一个参数。但您甚至不需要实例来调用该方法，例如：

>>> class A(object):
...     @classmethod
...     def foo(cls):
...         print cls
... 
>>> A.foo() # note this is called directly on the class
<class '__main__.A'>

Answer 4

网页上的示例似乎可以按发布的方式工作。您是否也为超类创建了一个 do_something 方法，但没有将其放入类方法中？像这样的事情会给你这个错误：

>>> class A(object):
...     def do_something(cls):
...         print cls
... #   do_something = classmethod(do_something)
... 
>>> class B(A):
...     def do_something(cls):
...         super(B, cls).do_something()
...     do_something = classmethod(do_something)
... 
>>> B().do_something()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in do_something
TypeError: unbound method do_something() must be called with B instance as first argument (got nothing instead)

Answer 5

我想我现在已经明白了这一点，感谢这个美丽的网站和可爱的社区。

如果您不介意，如果我在类方法上错了（我现在正在尝试完全理解），请纠正我：

# EXAMPLE #1
>>> class A(object):
...     def foo(cls):
...             print cls
...     foo = classmethod(foo)
... 
>>> a = A()
>>> a.foo()
# THIS IS THE CLASS ITSELF (__class__)
class '__main__.A'

# EXAMPLE #2
# SAME AS ABOVE (With new @decorator)
>>> class A(object):
...     @classmethod
...     def foo(cls):
...             print cls
... 
>>> a = A()
>>> a.foo()
class '__main__.A'

# EXAMPLE #3
>>> class B(object):
...     def foo(self):
...             print self
... 
>>> b = B()
>>> b.foo()
# THIS IS THE INSTANCE WITH ADDRESS (self)
__main__.B object at 0xb747a8ec
>>>

我希望这个插图显示..