For example we have a base class called A, and three sub classes called B C D, all inheritance of A. If I want some method only appear in B and C, but not in D. Where should I put this method?
If I put it in A, D will have the method it doesn't need.
If I put it in B and C, I repeat myself.
If it's meant to be the "same" method visible in both B and C, it sounds like you need to add another class into the hierarchy below A, but above B and C. Let's call it E. You'll have D and E as subclasses of A, and B and C as subclasses of E.
There is no 'standard' way of doing this unlike other languages.
You can override it so that it raises an exception.
class Human( object ):
def walk( self ):
print 'walking...'
class Baby(Human)
def walk( self ):
raise NotImplementedError("can't right now")
class Teenager(Human):
...
intended for use in abstract classes Can you provide some evidence of this?There are 2 things that you can do in your concept
If still you cannot do any changes in A, and still D needs to inherit from A, then its best to raise the un-implemented/not-supported error like below
class D(object):
"""docstring for D"""
def __init__(self, arg):
super(D, self).__init__()
self.arg = arg
def methodThatWasNotSupposedToComeHere(some_params ):
raise NotImplementedError("This is not supported")
Python is a very flexible language in this respect.
You can define your method outside of C and D classes scope, and bind it to them separately:
class A(object):
pass
class B(A):
pass
def method(self):
print '%s.method()' % type(self).__name__
class C(A):
method = method
class D(A):
method = method
c = C()
d = D()
c.method() # prints "C.method()"
d.method() # prints "D.method()"
print c.method # prints "<bound method C.method of <__main__.C object at 0x????????>>"
print d.method # prints "<bound method D.method of <__main__.D object at 0x????????>>"
You can introduce a new class that inherits from A, define your method in this class and inherit C and D from this new class. This is the 'classic' OOP approach.
You can implement your method in A and override it in B, telling it to raise some exception. Preferably something else than NotImplementedError as it's intended to be used in abstract classes - AttributeError seems like a better candidate. Note that if you're not going to instantiate A class in your code, it will make sense for A.method to raise NotImplementedError, effectively converting A into an abstract class.
You can resort to duck-typing and simply implement two identical methods in C and D. Python is big on duck-typing, but not big on duplicating code, so this might not be the best solution in this situation.