老式的(pre-PEP 3119)方法是在调用抽象方法时在抽象类中引发NotImplementedError。

class Abstract(object):
    def foo(self):
        raise NotImplementedError('subclasses must override foo()!')

class Derived(Abstract):
    def foo(self):
        print 'Hooray!'

>>> d = Derived()
>>> d.foo()
Hooray!
>>> a = Abstract()
>>> a.foo()
Traceback (most recent call last): [...]

它没有像使用abc模块那样好的属性。您仍然可以实例化抽象基类本身，并且直到在运行时调用抽象方法时才会发现错误。

但是如果您处理的是一小组简单类，可能只有几个抽象方法，那么这种方法比费力地查阅abc文档要容易一些。

使用abc模块创建抽象类。使用abstractmethod装饰器来声明方法抽象，并使用三种方法之一来声明类抽象，具体取决于您的Python版本。

在Python 3.4及以上版本中，可以从ABC继承。在早期版本的Python中，需要将类的元类指定为ABCMeta。指定元类在Python 3和Python 2中有不同的语法。三种可能性如下所示:

# Python 3.4+
from abc import ABC, abstractmethod
class Abstract(ABC):
    @abstractmethod
    def foo(self):
        pass

# Python 3.0+
from abc import ABCMeta, abstractmethod
class Abstract(metaclass=ABCMeta):
    @abstractmethod
    def foo(self):
        pass

# Python 2
from abc import ABCMeta, abstractmethod
class Abstract:
    __metaclass__ = ABCMeta

    @abstractmethod
    def foo(self):
        pass

无论使用哪种方式，都不能实例化具有抽象方法的抽象类，但可以实例化提供这些方法的具体定义的子类:

>>> Abstract()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class Abstract with abstract methods foo
>>> class StillAbstract(Abstract):
...     pass
... 
>>> StillAbstract()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class StillAbstract with abstract methods foo
>>> class Concrete(Abstract):
...     def foo(self):
...         print('Hello, World')
... 
>>> Concrete()
<__main__.Concrete object at 0x7fc935d28898>

这里有一个不需要处理ABC模块的非常简单的方法。

在你想要成为抽象类的类的__init__方法中，你可以检查self的“类型”。如果self类型是基类，则调用者试图实例化基类，因此引发异常。这里有一个简单的例子:

class Base():
    def __init__(self):
        if type(self) is Base:
            raise Exception('Base is an abstract class and cannot be instantiated directly')
        # Any initialization code
        print('In the __init__  method of the Base class')

class Sub(Base):
    def __init__(self):
        print('In the __init__ method of the Sub class before calling __init__ of the Base class')
        super().__init__()
        print('In the __init__ method of the Sub class after calling __init__ of the Base class')

subObj = Sub()
baseObj = Base()

当运行时，它产生:

In the __init__ method of the Sub class before calling __init__ of the Base class
In the __init__  method of the Base class
In the __init__ method of the Sub class after calling __init__ of the Base class
Traceback (most recent call last):
  File "/Users/irvkalb/Desktop/Demo files/Abstract.py", line 16, in <module>
    baseObj = Base()
  File "/Users/irvkalb/Desktop/Demo files/Abstract.py", line 4, in __init__
    raise Exception('Base is an abstract class and cannot be instantiated directly')
Exception: Base is an abstract class and cannot be instantiated directly

这表明您可以实例化继承自基类的子类，但不能直接实例化基类。

这个将在python3中工作

from abc import ABCMeta, abstractmethod

class Abstract(metaclass=ABCMeta):

    @abstractmethod
    def foo(self):
        pass

Abstract()
>>> TypeError: Can not instantiate abstract class Abstract with abstract methods foo

晚些时候回答这里，但要回答另一个问题“如何做出抽象方法”哪一点在这里，我提供如下。

# decorators.py
def abstract(f):
    def _decorator(*_):
        raise NotImplementedError(f"Method '{f.__name__}' is abstract")
    return _decorator


# yourclass.py
class Vehicle:
    def add_energy():
       print("Energy added!")

    @abstract
    def get_make(): ...

    @abstract
    def get_model(): ...

类基类Vehicle仍然可以实例化用于单元测试(与ABC不同)，并且python会引发异常。哦，是的，为了方便起见，您还可以使用此方法在异常中获得抽象的方法名。

正如在其他答案中解释的那样，是的，您可以使用abc模块在Python中使用抽象类。下面我给出了一个实际的例子，使用抽象的@classmethod， @property和@abstractmethod(使用Python 3.6+)。对我来说，通常更容易从例子开始，我可以很容易地复制和粘贴;我希望这个答案对其他人也有用。

让我们首先创建一个基类base:

from abc import ABC, abstractmethod

class Base(ABC):

    @classmethod
    @abstractmethod
    def from_dict(cls, d):
        pass
    
    @property
    @abstractmethod
    def prop1(self):
        pass

    @property
    @abstractmethod
    def prop2(self):
        pass

    @prop2.setter
    @abstractmethod
    def prop2(self, val):
        pass

    @abstractmethod
    def do_stuff(self):
        pass

我们的基类总是有一个from_dict类方法，一个属性prop1(只读)和一个属性prop2(也可以设置)，以及一个名为do_stuff的函数。现在基于Base构建的任何类都必须实现所有这四个方法/属性。请注意，对于一个抽象的方法，需要两个装饰器——classmethod和abstract property。

现在我们可以像这样创建一个a类:

class A(Base):
    def __init__(self, name, val1, val2):
        self.name = name
        self.__val1 = val1
        self._val2 = val2

    @classmethod
    def from_dict(cls, d):
        name = d['name']
        val1 = d['val1']
        val2 = d['val2']

        return cls(name, val1, val2)

    @property
    def prop1(self):
        return self.__val1

    @property
    def prop2(self):
        return self._val2

    @prop2.setter
    def prop2(self, value):
        self._val2 = value

    def do_stuff(self):
        print('juhu!')

    def i_am_not_abstract(self):
        print('I can be customized')

所有必需的方法/属性都实现了，当然，我们还可以添加其他不属于Base的函数(这里:i_am_not_abstract)。

现在我们可以做:

a1 = A('dummy', 10, 'stuff')
a2 = A.from_dict({'name': 'from_d', 'val1': 20, 'val2': 'stuff'})

a1.prop1
# prints 10

a1.prop2
# prints 'stuff'

正如期望的那样，我们不能设置prop1:

a.prop1 = 100

将返回

AttributeError:不能设置属性

我们的from_dict方法也可以很好地工作:

a2.prop1
# prints 20

如果我们现在像这样定义第二个类B:

class B(Base):
    def __init__(self, name):
        self.name = name

    @property
    def prop1(self):
        return self.name

并尝试像这样实例化一个对象:

b = B('iwillfail')

我们会得到一个错误

不能用抽象方法实例化抽象类B Do_stuff, from_dict, prop2

列出所有在Base中定义的东西，这些东西我们没有在B中实现。