Python：在多次派生后查询一个类的父类（“super()”不起作用）

Question

我构建了一个使用基类的多个派生的类系统 (object->class1->class2->class3):

class class1(object):
 def __init__(self):
  print "class1.__init__()"
  object.__init__(self)

class class2(class1):
 def __init__(self):
  print "class2.__init__()"
  class1.__init__(self)


class class3(class2):
 def __init__(self):
  print "class3.__init__()"
  class2.__init__(self)

x = class3()

它按预期工作并打印:

class3.__init__()
class2.__init__()
class1.__init__()

现在我想

object.__init__(self)
...
class1.__init__(self)
...
class2.__init__(self)

用这样的东西替换 3 行:

currentParentClass().__init__()
...
currentParentClass().__init__()
...
currentParentClass().__init__()

所以基本上，我想创建一个类系统，其中我 不必输入“classXYZ.doSomething()”。

如上所述，我想获得“当前班级的 父类”。

将三行替换为：

super(type(self), self).__init__()

不起作用（它总是返回父类 当前实例-> class2) 并将导致无穷无尽 循环打印：

class3.__init__()
class2.__init__()
class2.__init__()
class2.__init__()
class2.__init__()
...

那么有没有一个函数可以给我当前类的 父级？

感谢您的帮助！

亨利

--------------------

编辑：

@Lennart 好吧，也许我误解了你，但目前我认为我没有足够清楚地描述问题。所以这个例子可能会更好地解释它：

现在让我们创建另一个子类，

class class4(class3):
 pass

如果我们从 class4 派生一个实例会发生什么？

y = class4()

我认为它清楚地执行：

super(class3, self).__init__()

我们可以将其翻译为：

class2.__init__(y)

这绝对不是目标（这将是 class3.__init__(y)）

现在进行大量父类函数调用 - i不想在 super() 调用中使用不同的基类名称重新实现所有函数。

我还想提一下，我对 python 级系统有点陌生，所以我希望你对我有耐心。

Answer 1

“如上所述，我想获取‘当前班级的父班级’。”

但你知道。在class2中它是class1。所以你想调用class1。总是。那么你就可以调用class1。

但获取当前类的父类的正确方法是 super()。但是你这样使用它：

super(type(self), self)

这将为你提供 self 类的父类。在你的例子中， self 的类是 class3 ，所以正如你所注意到的，它总是返回 class2 。正确的使用方法如下：

class class1(object):
 def __init__(self):
  print "class1.__init__()"
  super(class1, self).__init__()

class class2(class1):
 def __init__(self):
  print "class2.__init__()"
  super(class2, self).__init__()


class class3(class2):
 def __init__(self):
  print "class3.__init__()"
  super(class3, self).__init__()


x = class3()

使用 super() 和直接调用类之间的区别在于是否在层次结构中的某个位置使用多重继承。 Super 然后会找出哪个是正确的类别。

---

更新：

当您定义 class4 并调用它时会发生什么？

>>> class class4(class3):
...  pass
... 
>>> y = class4()
class3.__init__()
class2.__init__()
class1.__init__()

正如您所说，目标是调用class3.__init__()。这正是所发生的情况，因为根据正常的继承规则，class4 将从 class3 继承__init__。

您期望 class2.__init__() 被调用，但我不明白为什么您会这样期望。您继承自 class3，因此它的 __init__ 将被调用。它依次根据设计调用class2.__init__。

Answer 2

您正在寻找 __class__ 的 __bases__ 成员。您的班级的父级可以这样使用：

>>> class A: pass

>>> class B(A): pass

>>> class C(B): pass

>>> C.__bases__[0]
<class __main__.B at ...>

>>> C.__bases__[0].__bases__[0]
<class __main__.A at ...>

但是，请记住您的班级可以有多个父级。

>>> class D: pass

>>> class E(A,D): pass

>>> E.__bases__
(<class __main__.A at ...>, <class __main__.D at ...>)

在我看来，你所做的事情很少值得。但了解 Python 本身如何跟踪多重继承所需的工具是很有趣的。

Answer 3

如果没有框架检查，你就无法做到这一点，而这是令人不悦的。

这是我在网上找到的一个进行框架检查的实现：

import sys

class _super(object):
    __name__ = 'super'

    __slots__ = ('_super__super', '_super__method')

    def __init__(self, super, name):
        object.__setattr__(self, '_super__super', super)

        try:
            object.__setattr__(self, '_super__method', getattr(super, name))
        except AttributeError:
            object.__setattr__(self, '_super__method', name)

    def __call__(self, *p, **kw):
        method = object.__getattribute__(self, '_super__method')

        try:
            return method(*p, **kw)
        except TypeError:
            if type(method) is not str:
                raise

        super = object.__getattribute__(self, '_super__super')
        method = getattr(super, method)
        object.__setattr__(self, '_super__method', method)
        return method(*p, **kw)

    def __getattribute__ (self, name):
        super = object.__getattribute__(self, '_super__super')

        try:
            return getattr(super, name)
        except (TypeError, AttributeError):
            if name == 'super':
                raise TypeError("Cannot get 'super' object of 'super' object")

            raise

    def __setattr__(self, name, value):
        super = object.__getattribute__(self, '_super__super')
        object.__setattr__(super, name, value)

def _getSuper(self):
    frame = sys._getframe().f_back
    code = frame.f_code
    name = code.co_name

    cur_class = None

    for c in type(self).__mro__:
        try:
            m = getattr(c, name)
            func_code = m.func_code
        except AttributeError:
            func_code = None

        if func_code is code:
            cur_class = c
        elif cur_class is not None:
            break

    if cur_class is None:
        raise TypeError, "Can only call 'super' in a bound method"

    return _super(super(cur_class, self), name)

class autosuper(object):
    __slots__ = ()
    super = property(_getSuper)

使用它时的代码：

class class1(autosuper):
    def __init__(self):
        print "class1.__init__()"
        self.super()

class class2(class1):
    def __init__(self):
        print "class2.__init__()"
        self.super()


class class3(class2):
    def __init__(self):
        print "class3.__init__()"
        self.super()

x = class3()        

On python3, super() 已经很神奇了并且可以在不传递类的情况下工作：

super().method(args)