12

Suppose I want to create an abstract class in Python with some methods to be implemented by subclasses, for example:

class Base():
    def f(self):
        print "Hello."
        self.g()
        print "Bye!" 

class A(Base):
    def g(self):
        print "I am A"

class B(Base):
    def g(self):
        print "I am B"

I'd like that if the base class is instantiated and its f() method called, when self.g() is called, that throws an exception telling you that a subclass should have implemented method g().

What's the usual thing to do here? Should I raise a NotImplementedError? or is there a more specific way of doing it?

smci
  • 32,567
  • 20
  • 113
  • 146
Manuel Araoz
  • 15,962
  • 24
  • 71
  • 95

3 Answers3

15

In Python 2.6 and better, you can use the abc module to make Base an "actually" abstract base class:

import abc

class Base:
    __metaclass__ = abc.ABCMeta
    @abc.abstractmethod
    def g(self):
        pass
    def f(self): # &c

this guarantees that Base cannot be instantiated -- and neither can any subclass which fails to override g -- while meeting @Aaron's target of allowing subclasses to use super in their g implementations. Overall, a much better solution than what we used to have in Python 2.5 and earlier!

Side note: having Base inherit from object would be redundant, because the metaclass needs to be set explicitly anyway.

Alex Martelli
  • 854,459
  • 170
  • 1,222
  • 1,395
  • hah. I just got a basic implementation of that running! I'll finish it anyways as an exercise and then see how mine stacks up against the official one. – aaronasterling Aug 13 '10 at 04:02
  • 3
    Just as a side node: in Python 3.x, the metaclass is defined like this: class Base(metaclass=abc.ABCMeta): ... – Fabian Fagerholm Aug 13 '10 at 04:13
2

Make a method that does nothing, but still has a docstring explaining the interface. Getting a NameError is confusing, and raising NotImplementedError (or any other exception, for that matter) will break proper usage of super.

habnabit
  • 9,906
  • 3
  • 32
  • 26
  • 1
    how does raising an error break proper usage of `super`? `super` wouldn't get called in this case because the immediate subclass wouldn't call it. Any calls to super further down the inheritance chain would work fine. – aaronasterling Aug 13 '10 at 03:36
  • @aaronasterling, why wouldn't the immediate subclass call it? If you have two classes that inherit from Base and implement the method, and one class that inherits from both, only one of the implementations will be called. If both immediate subclasses call `super` (as they should be), then both implementations will be called. – habnabit Aug 13 '10 at 03:38
  • Good call. I deleted my answer. – aaronasterling Aug 13 '10 at 03:48
0

Peter Norvig has given a solution for this in his Python Infrequently Asked Questions list. I'll reproduce it here. Do check out the IAQ, it is very useful. 

## Python
class MyAbstractClass:
    def method1(self): abstract

class MyClass(MyAbstractClass): 
    pass

def abstract():
    import inspect
    caller = inspect.getouterframes(inspect.currentframe())[1][3]
    raise NotImplementedError(caller + ' must be implemented in subclass')
Manoj Govindan
  • 72,339
  • 21
  • 134
  • 141
  • 3
    notice that **just mentioning** `abstract` as `method1`'s body does nothing at all: you need to **call** it. Anyway, while @Peter's idea is worthwhile for 2.5 and earlier, in 2.6 and later the abc module I recommend is better: the error comes ASAP, as soon as a still-abstract class is **instantiated**, which is always helpful for fixing errors. – Alex Martelli Aug 13 '10 at 15:19