How Does Python's `super()` Resolve Method Calls in Multiple Inheritance?

How Multiple Inheritance Influences the Behavior of Python's super()

Multiple inheritance in Python introduces complexities in method resolution. Python determines the method resolution order (MRO) to establish which parent method should be invoked by super().

In your example, Third inherits from both First and Second. When super().__init__() is called in Third.__init__(), it refers to First.__init__() because the MRO evaluates parent classes from left to right. First is listed before Second in the inheritance chain.

Python prioritizes the class order in the inheritance list when constructing the MRO. Thus, in the following example, the MRO is [Fourth, Second, Third, First, object]:

class First(object):
    def __init__(self):
        print("first")

class Second(First):
    def __init__(self):
        print("second")

class Third(First):
    def __init__(self):
        print("third")

class Fourth(Second, Third):
    def __init__(self):
        super(Fourth, self).__init__()
        print("that's it")

In this scenario, Fourth will call First.__init__() instead of Second.__init__() because First is encountered first in the MRO.

However, if the inheritance order is reversed:

class Third(Second, First):
    def __init__(self):
        print("third")

Then, the MRO becomes [Third, Second, First, object], and Third will initially call Second.__init__().

Notably, Python enforces a coherent MRO. If there are inconsistencies in the inheritance chain, it raises an exception to prevent unexpected behavior.

The above is the detailed content of How Does Python's `super()` Resolve Method Calls in Multiple Inheritance?. For more information, please follow other related articles on the PHP Chinese website!