I'm wondering about the differences between inheritance and composition examined with concrete code relevant arguments.

In particular my example was

Inheritance:

class Do:
    def do(self):
        self.doA()
        self.doB()

    def doA(self):
        pass

    def doB(self):
        pass

class MyDo(Do):
    def doA(self):
        print("A")

    def doB(self):
        print("B")

x=MyDo()

vs Composition:

class Do:
    def __init__(self, a, b):
        self.a=a
        self.b=b

    def do(self):
        self.a.do()
        self.b.do()

x=Do(DoA(), DoB())

(Note for composition I'm missing code so it's not actually shorter)

Can you name particular advantages of one or the other?

I'm think of:

• composition is useful if you plan to reuse DoA() in another context
• inheritance seems easier; no additional references/variables/initialization
• method doA can access internal variable (be it a good or bad thing :) )
• inheritance groups logic A and B together; even though you could equally introduce a grouped delegate object
• inheritance provides a preset class for the users; with composition you'd have to encapsule the initialization in a factory so that the user does have to assemble the logic and the skeleton
• ...

Basically I'd like to examine the implications of inheritance vs composition. I heard often composition is prefered, but I'd like to understand that by example.

Of course I can always start with one and refactor later to the other.