Abstract methods in Python

In Python, you usually avoid having such abstract methods alltogether. You define an interface by the documentation, and simply assume the objects that are passed in fulfil that interface ("duck typing").

If you really want to define an abstract base class with abstract methods, this can be done using the abc module:

from abc import ABCMeta, abstractmethodclass Abstract(metaclass=ABCMeta):    def use_concrete_implementation(self):        print(self._concrete_method())    @abstractmethod    def _concrete_method(self):        passclass Concrete(Abstract):    def _concrete_method(self):        return 2 * 3

Again, that is not the usual Python way to do things. One of the main objectives of the abc module was to introduce a mechanism to overload isinstance(), but isinstance() checks are normally avoided in favour of duck typing. Use it if you need it, but not as a general pattern for defining interfaces.

When in doubt, do as Guido does.

No underscore. Just define the "abstract method" as a one-liner which raises NotImplementedError:

class Abstract():    def ConcreteMethod(self):        raise NotImplementedError("error message")

Basically, an empty method in the base class is not necessary here. Just do it like this:

class Abstract:    def use_concrete_implementation(self):        print(self._concrete_method())class Concrete(Abstract):    def _concrete_method(self):        return 2 * 3

In fact, you usually don't even need the base class in Python. Since all calls are resolved dynamically, if the method is present, it will be invoked, if not, an AttributeError will be raised.

Attention: It is import to mention in the documentation that _concrete_method needs to be implemented in subclasses.