Question

I am pondering if I should use inheritance or delegation to implement a kind of wrapper class. My problem is like this: Say I have a class named Python.

class Python:

    def __init__(self):
        ...

    def snake(self):
        """ Make python snake through the forest"""
        ...

    def sleep(self):
        """ Let python sleep """
        ...

… and much more behavior. Now I have existing code which expects an Anaconda, which is almost like a Python, but slightly different: Some members have slightly different names and parameters, other members add new functionality. I really want to reuse the code in Python. Therefore I could do this with inheritance:

class Anaconda(Python):

    def __init__(self):
        Python.__init__(self)

    def wriggle(self):
        """Different name, same thing"""
        Python.snake(self)

    def devourCrocodile(self, croc):
        """ Python can't do this"""
        ...

Of course I can also call Anaconda().sleep(). But here is the problem: There is a PythonFactory which I need to use.

class PythonFactory:

    def makeSpecialPython(self):
        """ Do a lot of complicated work to produce a special python"""
        …
        return python

I want it to make a Python and then I should be able to convert it to an Anaconda:

myAnaconda = Anaconda(PythonFactory().makeSpecialPython())

In this case, delegation would be the way to go. (I don’t know whether this can be done using inheritance):

class Anaconda:

    def __init__(self, python):
        self.python = python

    def wriggle(self):
        self.python.wriggle()


    def devourCrocodile(self, croc):
        ...

But with delegation, I cannot call Anaconda().sleep().

So, if you’re still with me, my questions are:

A) In a case similar to this, where I need to

• add some functionality
• rename some functionality
• use “base class” functionality otherwise
• convert “base class” object to “subclass” object

should I use inheritance or delegation? (Or something else?)

B) An elegant solution would be to use delegation plus some special method that forwards all attribute and method accesses which Anaconda does not respond to to its instance of Python.

Answer 1

B) An elegant solution would be to use delegation plus some special method that forwards all attribute and method accesses which Anaconda does not respond to to its instance of Python.

This is simple in Python, just define __getattr__:

class Anaconda:

    def __init__(self, python):
        self.python = python

    def wriggle(self):
        self.python.snake()


    def devourCrocodile(self, croc):
        ...

    def __getattr__(self, name):
        return getattr(self.python, name)

See the Python docs on __getattr__