在 Python 中调用每个祖先的方法

Question

我在 python 中有一个“D”类的对象，我想依次执行“D”定义的“运行”方法及其每个祖先（“A”、“B”和“C”） .

我可以这样做

class A(object):
    def run_all(self):
        # I prefer to execute in revere MRO order
        for cls in reversed(self.__class__.__mro__):
            if hasattr(cls, 'run'):
                # This works
                cls.run(self)
                # This doesn't
                #cls.__getattribute__(self, 'run')()

    def run(self):
        print "Running A"

class B(A):
    def run(self):
        print "Running B"

class C(A):
    def run(self):
        print "Running C"

class D(C, B):
    def run(self):
        print "Running D"

if __name__ == "__main__":
    D().run_all()

结果

$ python test.py 
Running A
Running B
Running C
Running D

但实际上我不知道要执行的方法的名称。但是，如果我使用 getattribute() （请参阅注释）行尝试此操作，它将不起作用：

$ python test.py 
Running D
Running D
Running D
Running D

所以我的问题是：

1. 为什么不起作用？

2. 这是最好的解决方法吗？

Answer 1

如果您可以更改所有 run 实现（并在 D 中调用 run 而不是 run_all），则此方法有效：

class A(object):
    def run(self):
        print "Running A"

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

class C(A):
    def run(self):
        super(C, self).run()
        print "Running C"

class D(C, B):
    def run(self):
        super(D, self).run()
        print "Running D"

if __name__ == "__main__":
    D().run()

请注意，我不在根类中使用super——它“知道”没有进一步的超类可以达到（object 没有定义run 方法）。不幸的是，在 Python 2 中，这不可避免地很冗长（也不太适合通过装饰器实现）。

如果我正确理解您的目的，您对hasattr 的检查非常脆弱——如果一个类定义了或继承它，它会发现一个类“具有”该属性。因此，如果您有一个不覆盖run 但确实发生在__mro__ 上的中间类，则它继承的run 版本在您的方法中被调用两次。例如，考虑：

class A(object):
    def run_all(self):
        for cls in reversed(self.__class__.__mro__):
            if hasattr(cls, 'run'):
                getattr(cls, 'run')(self)
    def run(self):
        print "Running A"
class B(A): pass
class C(A):
    def run(self):
        print "Running C"
class D(C, B): pass

if __name__ == "__main__":
    D().run_all()

打印出来

Running A
Running A
Running C
Running C

对于B 和D 继承而不覆盖的run 版本有两个“口吃”（分别来自A 和C）。假设我是对的，这不是您想要的效果，如果您想避免使用super，您可以尝试将run_all 更改为：

def run_all(self):
    for cls in reversed(self.__class__.__mro__):
        meth = cls.__dict__.get('run')
        if meth is not None: meth(self)

在我的最新示例中，在A 和C 中仅用两个不同的defs 替换run，使示例打印：

Running A
Running C

我怀疑这可能更接近你想要的。

还有一点：不要重复工作——hasattr 保护 getattr，或 in 测试保护 dict 访问——保护中的检查和受保护的访问器都必须在内部重复完全相同的工作，没有好的目的。相反，将None 的第三个参数用于单个getattr 调用（或dict 的get 方法）：这意味着如果该方法不存在，您将检索None 值，然后您可以防止 调用 发生这种情况。这正是 dicts 有 get 方法和 getattr 有第三个可选“默认”参数的原因：为了便于应用 DRY，“不要重复自己”，这是良好编程的一个非常重要的格言！- )

Answer 2

你不应该使用__getattribute__ 方法..

只需执行以下操作：

getattr(cls, 'run')(self)

Answer 3

为什么不直接使用super？虽然有些consider it harmful，但它的设计正是考虑到这种场景，我会毫不犹豫地使用它。

来自Python documentation：

这对于访问继承的很有用 在 a 中被覆盖的方法 班级。搜索顺序与 getattr() 使用的，除了 类型本身被跳过。 [...] 这 使实施成为可能 “钻石图”，其中多个基础 类实现相同的方法。

更新：在你的情况下，它会变成这样：

class A(object):

    def run(self):
        print "Running A"

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

class C(A):
    def run(self):
        super(C, self).run()
        print "Running C"

class D(C, B):
    def run(self):
        super(D, self).run()
        print "Running D"

if __name__ == "__main__":
    D().run()