CODEWITHSUNDEEP
pythonclass
Siva kumar Reddy
Siva kumar Reddy

Reputation: 97

Python multiple inheritance, calling second base class method, if both base classes holding same method

class A:
    def amethod(self): print("Base1")


class B():
    def amethod(self): print("Base3")

class Derived(A,B):
    pass

instance = Derived()
instance.amethod() 
#Now i want to call B method amethod().. please let me know the way.**

Python multiple inheritance, calling second base class method, if both base classes holding same method

Upvotes: 2

Views: 1613

Answers (2)

Blckknght
Blckknght

Reputation: 104702

galaxyan's answer suggesting composition is probably the best one. Multiple inheritance is often complicated to design and debug, and unless you know what you're doing, it can be difficult to get right. But if you really do want it, here's an answer explaining how you can make it work:

For multiple inheritance to work properly, the base classes will often need to cooperate with their children. Python's super function makes this not too difficult to set up. You often will need a common base for the classes involved in the inheritance (to stop the inheritance chain):

class CommonBase:
    def amethod(self):
        print("CommonBase")
        # don't call `super` here, we're the end of the inheritance chain

class Base1(CommonBase):
    def amethod(self):
        print("Base1")
        super().amethod()

class Base2(CommonBase):
    def amethod(self):
        print("Base2")
        super().amethod()

class Derived(Base1, Base2):
    def amethod(self):
        print("Derived")
        super().amethod()

Now calling Derived().amethod() will print Derived, Base1, Base2, and finally CommonBase. The trick is that super passes each call on to the the next class in the MRO of self, even if that's not the in the current class's inheritance hierarchy. So Base1.amethod ends up calling Base2.amethod via super since they're being run on an instance of Derived.

If you don't need any behavior in the common base class, its method body just be pass. And of course, the Derived class can just inherit the method without writing its own version and calling super to get the rest.

Upvotes: 5

galaxyan
galaxyan

Reputation: 6111

try to use composition

+Avoid multiple inheritance at all costs, as it's too complex to be reliable. If you're stuck with it, then be prepared to know the class hierarchy and spend time finding where everything is coming from.
+Use composition to package code into modules that are used in many different unrelated places and situations.
+Use inheritance only when there are clearly related reusable pieces of code that fit under a single common concept or if you have to because of something you're using.
class A:
    def amethod(self): print("Base1")


class B:
    def amethod(self): print("Base3")

class Derived2:
    def __init__(self):
        self.a = A()
        self.b = B()

    def amthodBase1(self):
        self.a.amethod()

    def amthodBase3(self):
        self.b.amethod()

instance2 = Derived2()
instance2.amthodBase1() 
instance2.amthodBase3()

Upvotes: 5

Related Questions