1. Introduction
Multiple inheritance lets a Python class inherit from more than one base class simultaneously, e.g. class D(B, C). This is powerful for mixing in independent pieces of behavior (mixins), but it raises an ambiguity: if two parent classes define the same method, which one does the child use? Python answers this with a deterministic algorithm called MRO (Method Resolution Order), computed via C3 linearization.
Cricket analogy: A player like Hardik Pandya inherits skills from both a batting coach and a bowling coach at once, but if both coaches teach a different grip for the same shot, the team needs a fixed rule for whose instruction wins.
The classic 'diamond problem' occurs when a class D inherits from B and C, which both inherit from a common ancestor A (forming a diamond shape: D -> B, C -> A). Python's C3 linearization guarantees a single, consistent, and predictable method lookup order in this situation, which you can inspect directly via ClassName.__mro__ or ClassName.mro().
Cricket analogy: When India's fielding drill and India's batting drill both trace back to the same base fitness program, the diamond shape (drills -> base program) means the coach needs one consistent order to avoid running the same warm-up twice.
2. Syntax
class A:
pass
class B(A):
pass
class C(A):
pass
class D(B, C): # multiple inheritance: D inherits from both B and C
pass
print(D.__mro__) # inspect the resolution order
print(D.mro()) # same information as a list3. Explanation
When you call an attribute or method on an instance of D, Python searches the classes in D.__mro__ order (D, then its bases, then their bases, ..., then object) and uses the first match it finds. C3 linearization builds this order by merging the MROs of the parents plus the list of parents itself, preserving two rules: a class always appears before its own ancestors (local precedence), and the order of base classes as written in the class definition is respected. For class D(B, C) where B(A) and C(A), the MRO is [D, B, C, A, object] — note C comes before A, and importantly A appears only once, after both B and C, rather than once per inheritance path.
Cricket analogy: Selectors reviewing a player's form check the state team's stats first, then the zonal team's, then the national academy's, in a fixed sequence, and stop at the first record that answers their question -- never checking the same academy record twice for two different zonal paths.
super() doesn't mean 'my parent class' — it means 'the next class in the MRO after the current class, given the actual instance's type'. This is what makes cooperative multiple inheritance work: each class's method calls super().method(), and the calls thread through the entire MRO chain (D -> B -> C -> A) rather than each class independently calling its own direct parent.
Gotcha (diamond problem): naive multiple inheritance without super() would cause A's method to run twice if both B and C called A's method directly (e.g. via A.method(self)), since both B and C independently inherit from A. Python avoids this duplication because super() follows the linearized MRO exactly once per class — each class's __init__ or method executes exactly once in a diamond, in a well-defined order, as long as every class in the chain consistently uses super() instead of hardcoding a parent class name. If a class in the middle of the hierarchy skips calling super(), the chain breaks and later classes in the MRO are never reached.
4. Example
class A:
def greet(self):
return "A"
class B(A):
def greet(self):
return "B -> " + super().greet()
class C(A):
def greet(self):
return "C -> " + super().greet()
class D(B, C):
def greet(self):
return "D -> " + super().greet()
d = D()
print(d.greet())
print([cls.__name__ for cls in D.__mro__])5. Output
D -> B -> C -> A
['D', 'B', 'C', 'A', 'object']6. Key Takeaways
- Multiple inheritance (class D(B, C)) lets a class combine behavior from more than one base class.
- Python computes a single, deterministic Method Resolution Order (MRO) using C3 linearization, inspectable via ClassName.__mro__ or ClassName.mro().
- For the diamond D(B, C) with B(A) and C(A), the MRO is [D, B, C, A, object] — A appears exactly once, after both B and C.
- super() means 'the next class in the MRO relative to the current class and the actual runtime type', not literally 'my direct parent'.
- Cooperative multiple inheritance requires every class in the hierarchy to consistently call super() so the chain isn't broken partway through.
- C3 linearization prevents a common ancestor's method from being invoked more than once in diamond-shaped hierarchies.
Practice what you learned
1. For class D(B, C) where class B(A) and class C(A), what is D's Method Resolution Order?
2. What does super() actually refer to in Python?
3. Given the example where A.greet returns 'A', B.greet returns 'B -> ' + super().greet(), C.greet returns 'C -> ' + super().greet(), and D.greet returns 'D -> ' + super().greet(), what does D().greet() return?
4. What problem does C3 linearization specifically prevent in diamond-shaped multiple inheritance?
5. What happens if a class in the middle of a cooperative multiple-inheritance chain overrides a method but does NOT call super()?
6. Which attribute lets you inspect a class's Method Resolution Order directly?
Was this page helpful?
You May Also Like
Inheritance in Python
How subclasses reuse and extend behavior from parent classes, and how super() and MRO resolve method lookups.
Abstract Classes in Python
Using the abc module to define abstract base classes and abstract methods that force subclasses to implement required behavior.
Polymorphism in Python
How different objects can respond to the same method call or operator in their own way, enabled by duck typing.
Classes and Objects in Python
How Python's class statement defines a blueprint for objects, and how instances are created and used.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics