Question

Abstract base classes can still be handy in Python.在编写一个抽象基类时，我希望每个子类都有一个spam()方法，我想写这样的东西：

class Abstract(object):
    def spam(self):
        raise NotImplementedError

挑战还在于想要使用super()，并通过将其包含在整个子类链中来正确地完成。在这种情况下，似乎我必须包含每个super调用，如下所示：

class Useful(Abstract):
    def spam(self):
        try:
            super(Useful, self).spam()
        except NotImplementedError, e:
            pass
        print("It's okay.")

对于一个简单的子类来说没问题，但是当编写一个有很多方法的类时，try-except的东西有点麻烦，有点难看。是否有更优雅的抽象基类子类化方法？我只是做错吗？

Answer 1

您可以使用abc module

在python 2.6+中干净利落地完成此操作

import abc
class B(object):
    __metaclass__ = abc.ABCMeta
    @abc.abstractmethod
    def foo(self):
        print 'In B'

class C(B):
    def foo(self):
        super(C, self).foo()
        print 'In C'

C().foo()

输出

In B
In C

Answer 2

不要写所有代码。简单检查抽象类可以节省您编写所有代码的时间。

如果方法是抽象的，则具体子类不会调用super。

如果方法具体，那么具体的子类会调用super。

Answer 3

理解这一点的关键是super()用于实现协作继承。课程如何合作取决于程序员。 super()不是魔术，也不知道你想要什么！使用super对于不需要合作继承的平面层次结构没有多大意义，因此在这种情况下，S.Lott的建议就是现场。有用的子类可能会或可能不会根据其目标使用super()：）

例如：摘要是A. A＆lt; -B，但是你想支持C的插入，就像这样A＆lt; - C＆lt; -B。

class A(object):                                                                                         
    """I am an abstract abstraction :)"""
    def foo(self):
        raise NotImplementedError('I need to be implemented!')

class B(A):
    """I want to implement A"""
    def foo(self):
        print('B: foo')
        # MRO Stops here, unless super is not A
        position = self.__class__.__mro__.index
        if not position(B) + 1 == position(A):
            super().foo()

b = B()     
b.foo()

class C(A):
    """I want to modify B and all its siblings (see below)"""
    def foo(self):
        print('C: foo')
        # MRO Stops here, unless super is not A
        position = self.__class__.__mro__.index
        if not position(C) + 1 == position(A):
            super().foo()

print('')   
print('B: Old __base__ and __mro__:\n')
print('Base:', B.__bases__)
print('MRO:', B.__mro__)
print('')
# __mro__ change implementation
B.__bases__ = (C,)
print('B: New __base__ and __mro__:\n')
print('Base:', B.__bases__)
print('MRO:', B.__mro__)
print('')
b.foo()

输出：

B: foo

B: Old __base__ and __mro__:

Base: (<class '__main__.A'>,)
MRO: (<class '__main__.B'>, <class '__main__.A'>, <class 'object'>)

B: New __base__ and __mro__:

Base: (<class '__main__.C'>,)
MRO: (<class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

B: foo
C: foo

Python的super（），抽象基类和NotImplementedError

3 个答案: