We're happily doing OO programming and building a class hierarchy.

Our usual technique to implement the do_your_stuff() method is to first call do_your_stuff() on the base class, and then do our stuff.

class A(object):
    def do_your_stuff(self):
        # do stuff with self for A
        return
    
class B(A):
    def do_your_stuff(self):
        A.do_your_stuff(self)
        # do stuff with self for B
        return
    
class C(A):
    def do_your_stuff(self):
        A.do_your_stuff(self)
        # do stuff with self for C
        return
    

We subtype a new class from two classes and end up having super-supertypes being accessible through two paths.

class D(B,C):
    def do_your_stuff(self):
        B.do_your_stuff(self)
        C.do_your_stuff(self)
        # do stuff with self for D
        return

Figure 2.1. The Diamond Diagram

Now we're stuck if we want to implement do_your_stuff(). Using our usual technique, if we want to call both B and C, we end up calling A.do_your_stuff() twice. And we all know it might be dangerous to have A do its stuff twice, when it is only supposed to be done once. The other option would leave either B's stuff or C's stuff not done, which is not what we want either.