Which Exception for notifying that subclass should implement a method?

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?

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.

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.

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')