在 python 中派生类方法的正确方法是什么？

Question

最近，我遇到了元类调用派生类方法的问题。 比如我得到一个简单的基类testA，它有一个类方法do1(a)

class testA(object):

    @classmethod
    def do1(cls, a):
        print "in testA:",cls, a

然后我构建了一个元类，它实际上只打印 cls：

class testMetaA(type):
    def __init__(cls,cname,bases,cdict):
        print "in testMetaA: %s"%cls

然后我可以使用元类来构建一个子类testB，它可以按预期工作：

class testB(testA):

    @classmethod
    def do1(cls, a):
        print "in testB: %s"%cls
        super(testB, cls).do1(a)
    __metaclass__=testMetaA

它将打印：in testMetaA: <class '__main__.testB'>; testB.do1(a) 按预期工作：

>>> testB.do1('hello')
in testB: <class '__main__.testB'>
in testA: <class '__main__.testB'> hello

但是，如果我尝试调用包含“super”的元类中的类方法，如下testMetaB，则会引发错误：NameError: global name 'testC' is not defined。

class testMetaB(type):
    def __init__(cls,cname,bases,cdict):
        print "in testMetaB: %s"%cls
        cls.do1("hello")

class testC(testA):

    @classmethod
    def do1(cls, a):
        print "in testC: %s"%cls
        super(testC, cls).do1(a)
    __metaclass__=testMetaB

我终于找到了解决方法，使用super(cls, cls)而不是super(testC, cls)：

class testD(testA):

    @classmethod
    def do1(cls, a):
        print "in testD: %s"%cls
        super(cls, cls).do1(a)
    __metaclass__=testMetaB

它将打印为：

in testMetaB: <class '__main__.testD'>
in testD: <class '__main__.testD'>
in testA: <class '__main__.testD'> hello

testD.do1(a) 也可以按预期工作：

>>> testD.do1('Well done')
in testD: <class '__main__.testD'>
in testA: <class '__main__.testD'> Well done

现在我想知道在类方法中使用 super 的最正确方法是什么？是否应该始终使用super(cls,cls) 而不是显式编写当前类名？

谢谢！

@jsbueno

如果某些代码采用动态创建派生类之类的技巧，这很重要 - 如果该名称分配给另一个对象而不是类本身，则不应将类名称用作 Super 的第一个参数。相反，可以将类方法的 cls 或实例方法的 self.__class__ 传递给 Super。

这是否意味着通常使用类名来超级是一个坏主意？

对我自己来说，我通常使用super(type(self),self) 而不是super(type(self.__class__),self) 作为普通方法。我不知道使用self.__class__ 是否有任何主要优势。 我像这样重复@jsbueno 示例，这里C 使用super(type(self),self)。所以D2() 不会在C 类被改变时改变行为。

>>> class A(object):
    def do(self):
        print "in class A"


>>> class B(A):
    def do(self):
        super(B, self).do()


>>> class C(A):
    def do(self):
        super(type(self),self).do()

>>> D1=B
>>> D2=C
>>> D1().do()
in class A
>>> D2().do()
in class A
>>> class B(A):
    def do(self):
        print "in new class B"


>>> D1().do()

Traceback (most recent call last):
  File "<pyshell#52>", line 1, in <module>
    D1().do()
  File "<pyshell#37>", line 3, in do
    super(B, self).do()
TypeError: super(type, obj): obj must be an instance or subtype of type
>>> class C(A):
    def do(self):
        print "in new class C"
>>> D2().do()
in class A

根据@Don Question的建议，我把python版本放在这里：sys.version= 2.7.2+ (default, Oct 4 2011, 20:06:09) [GCC 4.6.1]

Answer 1

但是，如果我尝试在元类中调用 classmethod 包含如下 testMetaB 的“super”，它会引发错误： NameError: 未定义全局名称“testC”。

名称 TestC 只会在 MetaClass 完成它的工作后绑定到新类 - 也就是在从它的 __init__（以及在 __init__ 之前，__new__）方法返回之后。

当我们使用“super”调用时，使用类名作为第一个参数，类名不会神奇地出现在那里：它是一个（模块）全局变量，类本身被分配给它 - 在正常情况下。

在这种情况下，尚未分配名称 - 但是，因为它是一个类方法，所以你在 cls 变量中引用了类 - 这就是它起作用的原因。

如果某些代码采用动态创建派生类之类的技巧，这很重要 - 如果该名称分配给另一个对象而不是类本身，则不应将类名称用作 Super 的第一个参数。相反，cls 用于类方法，或self.__class__ 用于实例方法可以传递给 Super。

这是一个 sn-p 显示类名的全局名称绑定是 super 所采用的：

>>> class A(object):
...   def do(self):
...      print "In class A"
... 
>>> class B(A):
...   def do(self):
...     super(B, self).do()
... 
>>> C = B
>>> C().do()
In class A
>>> class B(object):
...   def do(self):
...      print "in new class B"
... 
>>> C().do()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in do
TypeError: super(type, obj): obj must be an instance or subtype of type
>>>