Python Notes
HubHistory of Python - Complete Guide 2026Python Applications - Complete Guide 2026Python Features - Complete Guide 2026What is Python? - Complete Guide 2026Why Learn Python? - Complete Guide 2026Your First Python Program – Hello World & Beyond 2026How to Install Python on Windows, Mac & Linux – Complete Guide 2026Install VS Code for Python – Complete Setup Guide with Extensions 2026Python Environment Setup – Virtual Environments, pip & Project Structure 2026Python IDLE – Complete Guide for Beginners 2026Python CommentsPython Data TypesPython Input and OutputPython OperatorsPython SyntaxPython Strings BasicsPython Type CastingPython VariablesBreak, Continue and Pass in PythonElif Statement in PythonFor Loop in PythonIf-Else Statement in PythonIf Statement in PythonNested If in PythonPattern Programs in PythonWhile Loop in PythonDecorators in PythonFunction Arguments in PythonFunctions Basics in PythonGenerators in PythonLambda Functions in PythonRecursive Functions in PythonReturn Statement in PythonScope of Variables in PythonAbstraction in PythonClasses and Objects in PythonConstructors in PythonEncapsulation in PythonInheritance in PythonMagic Methods (Dunder Methods) in PythonMethod Overriding in PythonPolymorphism in PythonPython Comprehensions – List, Dict, Set & GeneratorPython Dictionaries – Key-Value StorePython Dictionary Methods – Complete ReferencePython List Methods – All Built-in MethodsPython Lists – Complete GuidePython Set Methods – Complete ReferencePython Sets – Unordered Unique CollectionsPython Tuples – Immutable SequencesPython Asynchronous Programming with asyncioPython Context ManagersAdvanced Python DecoratorsAdvanced Python GeneratorsPython Iterators - Advanced GuidePython Memory ManagementPython MultiprocessingPython MultithreadingCRUD Operations in Python DatabasesMySQL with Python (mysql-connector-python)ORM Introduction with SQLAlchemyPostgreSQL with Python (psycopg2)SQLite3 with PythonIntroduction to DjangoDjango Models and ORMDjango REST API with DRFDjango ViewsIntroduction to FlaskFlask RoutingFlask Templates with Jinja2Email Automation with PythonPDF Automation with PythonSelenium Web Automation with PythonTask Scheduler with PythonWeb Scraping with PythonData Analysis with PythonData Cleaning with PythonData Visualization ProjectData Visualization with MatplotlibNumPy IntroductionPandas IntroductionStatistical Visualization with SeabornClassification AlgorithmsClustering AlgorithmsIntroduction to Machine LearningMachine Learning Project: Churn PredictionModel Evaluation and SelectionRegression AlgorithmsSave pipeline (includes preprocessing + model)AI Assistant ProjectCalculator ProjectChatbot ProjectExpense Tracker ProjectFace Detection ProjectPassword Generator ProjectWeather App ProjectPython Coding Interview QuestionsPython OOP Interview Questions and AnswersPython Master CheatsheetPython Interview Questions and AnswersPython Best PracticesCommon Python Errors and SolutionsPython Debugging TechniquesPython Learning Resources
Master Python inheritance — single, multiple, multilevel, and hierarchical inheritance, MRO (Method Resolution Order), super(), mixins, and real-world class hierarchies.
🧠 Real-World Analogy — Family Tree
Think of your family tree — Grandfather → Father → You. You inherit some properties from your father (height, blood group), and your father from his father. This is inheritance. In code: a child class (derived class) automatically inherits properties and methods from a parent class (base class). The child can use those properties and also override or extend them.
1️⃣ Single Inheritance
python example
class Animal:
def __init__(self, name, sound):
self.name = name
self.sound = sound
self.energy = 100
def speak(self):
print(f"{self.name} says: {self.sound}!")
def eat(self, food):
self.energy += 20
print(f"{self.name} eats {food}. Energy: {self.energy}")
def sleep(self):
self.energy += 30
print(f"{self.name} sleeps. Energy: {self.energy}")
def __str__(self):
return f"Animal({self.name})"
class Dog(Animal): # ← Dog inherits from Animal
def __init__(self, name, breed):
super().__init__(name, "Woof") # call parent __init__
self.breed = breed
def fetch(self, item):
self.energy -= 10
print(f"{self.name} fetches the {item}! Energy: {self.energy}")
def __str__(self):
return f"Dog({self.name}, {self.breed})"
buddy = Dog("Buddy", "Labrador")
buddy.speak() # inherited from Animal
buddy.eat("kibble") # inherited from Animal
buddy.fetch("ball") # Dog-specific
buddy.sleep() # inherited from Animal
print(buddy)
# Check types
print(isinstance(buddy, Dog)) # True
print(isinstance(buddy, Animal)) # True — IS-A relationship
print(issubclass(Dog, Animal)) # TrueOutput:
| Buddy says | Woof! |
| Buddy eats kibble. Energy | 120 |
| Buddy fetches the ball! Energy | 110 |
| Buddy sleeps. Energy | 140 |
2️⃣ Multilevel Inheritance
python example
class Vehicle:
def __init__(self, make, model):
self.make = make
self.model = model
self.speed = 0
def accelerate(self, amount):
self.speed += amount
print(f"{self.make} {self.model} accelerates to {self.speed} km/h")
def brake(self):
self.speed = max(0, self.speed - 20)
print(f"Braking... {self.speed} km/h")
class Car(Vehicle):
def __init__(self, make, model, doors=4):
super().__init__(make, model)
self.doors = doors
def honk(self):
print(f"{self.make} {self.model}: Beep beep! 🚗")
class ElectricCar(Car): # ← multilevel: ElectricCar → Car → Vehicle
def __init__(self, make, model, battery_kwh):
super().__init__(make, model)
self.battery_kwh = battery_kwh
self.charge_percent = 80
def charge(self):
self.charge_percent = 100
print(f"⚡ {self.make} {self.model} fully charged! ({self.battery_kwh} kWh)")
def range_km(self):
return int(self.battery_kwh * 6 * self.charge_percent / 100)
def status(self):
print(f"🔋 Battery: {self.charge_percent}% | Range: {self.range_km()} km")
tesla = ElectricCar("Tesla", "Model 3", 75)
tesla.accelerate(60) # from Vehicle
tesla.honk() # from Car
tesla.charge() # from ElectricCar
tesla.status()Output:
Example
Tesla Model 3 accelerates to 60 km/h
Tesla Model 3: Beep beep! 🚗
⚡ Tesla Model 3 fully charged! (75 kWh)
🔋 Battery: 100% | Range: 450 km
3️⃣ Hierarchical Inheritance
Example
class Shape:
def __init__(self, color="white"):
self.color = color
def describe(self):
print(f"I am a {self.color} {self.__class__.__name__}")
def area(self):
raise NotImplementedError("Subclasses must implement area()")
def perimeter(self):
raise NotImplementedError("Subclasses must implement perimeter()")
class Circle(Shape):
def __init__(self, radius, color="white"):
super().__init__(color)
self.radius = radius
def area(self):
import math
return round(math.pi * self.radius ** 2, 2)
def perimeter(self):
import math
return round(2 * math.pi * self.radius, 2)
class Rectangle(Shape):
def __init__(self, length, width, color="white"):
super().__init__(color)
self.length = length
self.width = width
def area(self):
return self.length * self.width
def perimeter(self):
return 2 * (self.length + self.width)
class Triangle(Shape):
def __init__(self, a, b, c, color="white"):
super().__init__(color)
self.a, self.b, self.c = a, b, c
def area(self):
import math
s = (self.a + self.b + self.c) / 2
return round(math.sqrt(s * (s-self.a) * (s-self.b) * (s-self.c)), 2)
def perimeter(self):
return self.a + self.b + self.c
shapes = [
Circle(7, "red"),
Rectangle(10, 5, "blue"),
Triangle(3, 4, 5, "green"),
]
print(f"{'Shape':12} {'Color':8} {'Area':10} {'Perimeter':10}")
print("-" * 45)
for s in shapes:
print(f"{s.__class__.__name__:12} {s.color:8} {s.area():10} {s.perimeter():10}")
Output:
Example
Shape Color Area Perimeter
---------------------------------------------
Circle red 153.94 43.98
Rectangle blue 50 30
Triangle green 6.0 12
4️⃣ Multiple Inheritance
Example
class Flyable:
def fly(self):
print(f"{self.name} is flying! ✈️")
def land(self):
print(f"{self.name} lands safely.")
class Swimmable:
def swim(self):
print(f"{self.name} is swimming! 🏊")
def dive(self):
print(f"{self.name} dives deep!")
class Duck(Animal, Flyable, Swimmable): # multiple inheritance
def __init__(self, name):
super().__init__(name, "Quack")
def show_abilities(self):
self.speak()
self.fly()
self.swim()
self.eat("breadcrumbs")
donald = Duck("Donald")
donald.show_abilities()
print("\nMRO:", [c.__name__ for c in Duck.__mro__])
Output:
| Donald says | Quack! |
| Donald eats breadcrumbs. Energy | 120 |
| MRO | ['Duck', 'Animal', 'Flyable', 'Swimmable', 'object'] |
🔀 Method Resolution Order (MRO)
With multiple inheritance, Python needs to decide which method gets called first. This is determined by the MRO (Method Resolution Order) — the C3 linearization algorithm ensures a consistent, predictable order.
text example
Diamond Problem:
A
/ \
B C
\ /
D
MRO: D → B → C → A → objectpython example
class A:
def greet(self): print("Hello from A")
class B(A):
def greet(self): print("Hello from B")
class C(A):
def greet(self): print("Hello from C")
class D(B, C): # multiple inheritance
pass
d = D()
d.greet() # which greet() gets called?
print(D.__mro__)
# (<class 'D'>, <class 'B'>, <class 'C'>, <class 'A'>, <class 'object'>)Output:
Code example
Hello from B
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)Python resolves left-to-right, depth-first, with each class appearing only once.
🧩 Mixin Pattern
A Mixin is a small class that provides only one specific feature — inherit it to add that feature to your main class.
Example
class JSONMixin:
"""Add JSON serialization to any class."""
def to_json(self):
import json
return json.dumps(self.__dict__, indent=2, default=str)
class LogMixin:
"""Add logging capability to any class."""
def log(self, message):
import datetime
ts = datetime.datetime.now().strftime("%H:%M:%S")
print(f"[{ts}] [{self.__class__.__name__}] {message}")
class ValidateMixin:
"""Add basic validation."""
def validate(self):
for key, val in self.__dict__.items():
if val is None:
raise ValueError(f"Field '{key}' cannot be None.")
return True
# Compose a rich class from mixins
class Employee(JSONMixin, LogMixin, ValidateMixin):
def __init__(self, name, emp_id, department, salary):
self.name = name
self.emp_id = emp_id
self.department = department
self.salary = salary
def give_raise(self, percent):
raise_amount = self.salary * percent / 100
self.salary += raise_amount
self.log(f"Salary raised by {percent}%. New salary: ₹{self.salary:,.0f}")
emp = Employee("Arjun Sharma", "EMP001", "Engineering", 75000)
emp.log("Employee record created.")
emp.validate()
emp.give_raise(15)
print(emp.to_json())
Output:
| [HH | MM:SS] [Employee] Employee record created. |
| [HH | MM:SS] [Employee] Salary raised by 15%. New salary: ₹86,250 |
| "name" | "Arjun Sharma", |
| "emp_id" | "EMP001", |
| "department" | "Engineering", |
| "salary" | 86250.0 |
🏦 Real-World Example — Banking Hierarchy
Example
┌──────────────────┐
│ BankAccount │
│──────────────────│
│ owner │
│ balance │
│──────────────────│
│ deposit() │
│ withdraw() │
│ get_balance() │
└────────┬─────────┘
│
┌──────────┴──────────┐
▼ ▼
┌─────────────┐ ┌──────────────────┐
│SavingsAcct │ │ CurrentAccount │
│─────────────│ │──────────────────│
│ rate │ │ overdraft_limit │
│─────────────│ │──────────────────│
│ add_interest│ │ withdraw() │
│ compound() │ │ (allows overdraft│
└─────────────┘ └──────────────────┘
Example
class BankAccount:
def __init__(self, owner, balance=0):
self.owner = owner
self._balance = balance
def deposit(self, amount):
self._balance += amount
print(f" + Deposited ₹{amount:,} | Balance: ₹{self._balance:,}")
def withdraw(self, amount):
if amount > self._balance:
print(f" ✗ Insufficient funds. Balance: ₹{self._balance:,}")
return False
self._balance -= amount
print(f" - Withdrew ₹{amount:,} | Balance: ₹{self._balance:,}")
return True
def get_balance(self):
return self._balance
class SavingsAccount(BankAccount):
def __init__(self, owner, balance=0, rate=4.0):
super().__init__(owner, balance)
self.rate = rate
def add_interest(self):
interest = self._balance * self.rate / 100
self._balance += interest
print(f" 💰 Interest ({self.rate}%): +₹{interest:.2f} | Balance: ₹{self._balance:.2f}")
class CurrentAccount(BankAccount):
def __init__(self, owner, balance=0, overdraft_limit=10000):
super().__init__(owner, balance)
self.overdraft_limit = overdraft_limit
def withdraw(self, amount): # overrides parent withdraw
if amount > self._balance + self.overdraft_limit:
print(f" ✗ Overdraft limit exceeded!")
return False
self._balance -= amount
status = "⚠️ Overdraft" if self._balance < 0 else "✓"
print(f" - Withdrew ₹{amount:,} | Balance: ₹{self._balance:,} {status}")
return True
print("── Savings Account ─────────────────")
savings = SavingsAccount("Priya", 50000, rate=5.5)
savings.deposit(10000)
savings.withdraw(5000)
savings.add_interest()
print("\n── Current Account ─────────────────")
current = CurrentAccount("Rahul", 2000, overdraft_limit=5000)
current.withdraw(3000) # uses overdraft
current.withdraw(5000) # exceeds limit
Output:
| + Deposited ₹10,000 | Balance | ₹60,000 |
| - Withdrew ₹5,000 | Balance | ₹55,000 |
| 💰 Interest (5.5%) | +₹3025.00 | Balance: ₹58025.00 |
| - Withdrew ₹3,000 | Balance | ₹-1,000 ⚠️ Overdraft |
🇮🇳 Hindi Explanation (हिंदी में समझें)
Inheritance kya hai? Inheritance is a mechanism where one class (child) can use another class's (parent) attributes and methods — without rewriting them. It's the most powerful technique for code reuse.
Why do we usesuper()?super()lets us call parent class methods from within a child class. This is especially important in__init__to ensure parent class attributes are also initialized.
MRO kya hai? With multiple inheritance, Python uses the C3 Linearization algorithm to determine a fixed order for which class's method gets called first. You can view this order with ClassName.__mro__.Mixin kya hai? A Mixin is a small class that provides just one specific feature (like JSON conversion or logging). You can easily add that feature to multiple classes by inheriting the mixin.
❓ Interview Questions
Q1: What is inheritance? What problem does it solve?
Answer: Inheritance allows a child class to acquire attributes and methods of a parent class. It solves the DRY (Don't Repeat Yourself) problem — common behavior is defined once in the base class and reused across all subclasses. It also models the IS-A relationship (e.g., a Dog IS-A Animal).
Q2: Explain the different types of inheritance in Python.
Answer:
- Single:
class B(A)— one parent - Multiple:
class C(A, B)— two or more parents - Multilevel:
class C(B)whereclass B(A)— chain - Hierarchical: Multiple classes inherit from one parent
- Hybrid: Combination of multiple + multilevel
Q3: What is MRO and how does Python calculate it?
Answer: MRO (Method Resolution Order) defines the order in which Python searches classes when calling a method. Python uses the C3 Linearization algorithm:
- Start with the current class
- Follow left-to-right depth-first, but each class appears only once
- Always respects the inheritance order
Use ClassName.__mro__ or ClassName.mro() to inspect it.
Q4: What is the diamond problem? How does Python handle it?
Answer: The diamond problem occurs in multiple inheritance when two parent classes share a common ancestor. Without MRO, it's ambiguous which grandparent method to call. Python's C3 MRO ensures each class appears exactly once in a predictable order, eliminating ambiguity.
Q5: When should you use super() vs calling the parent directly?
Answer: Always prefer super() over ParentClass.method(self) because:
super()respects MRO in multiple inheritance- It avoids hardcoding the parent class name
- Direct calls can break in multiple-inheritance hierarchies
Q6: What is the difference between isinstance() and issubclass()?
Answer:
isinstance(obj, Class)— checks ifobjis an instance ofClassor any subclassissubclass(ChildClass, ParentClass)— checks ifChildClassis a subclass ofParentClass
Q7: What is a Mixin? Give an example use case.
Answer: A Mixin is a class designed to add specific functionality to other classes via inheritance without being a standalone base class. Example: a JSONMixin that adds to_json() to any class, or a LogMixin that adds log(). They're used to compose behavior rather than build deep hierarchies.
🧪 Practice Exercises
- School Hierarchy: Create
Person→Employee→TeacherandStudentwith appropriate attributes and methods. - Vehicle Family: Create
Vehicle→LandVehicle→Car,Truck; andVehicle→WaterVehicle→Boat,Ship. - E-Commerce Products: Create
Product→Electronics,Clothing,Foodeach with category-specific attributes. - Mixin Composition: Create
TimestampMixin(addscreated_at,updated_at),AuditMixin(logs changes), and apply both to aBlogPostclass. - Override Bank: Override
withdraw()in aFixedDepositAccountto raise an exception if the account is less than 1 year old.
💡 Next Topic → Polymorphism: One name, many forms — learn duck typing, method overriding, operator overloading, and the power of polymorphic code.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Inheritance in Python.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Python Master Course topic.
Search Terms
python-master-course, python master course, python, master, course, object, oriented, programming
Related Python Master Course Topics
Continue learning this concept
Object Oriented ProgrammingAbstraction in PythonMaster abstraction in Python — abstract base classes (ABC), @abstractmethod, interface design, abstract properties, concrete vs abstract classes, and real-world design patterns.Object Oriented ProgrammingClasses and Objects in PythonMaster the foundation of Object-Oriented Programming — learn how to define classes, create objects, use attributes and methods, and understand how Python models real-world entities as code.Object Oriented ProgrammingConstructors in PythonDeep dive into Python constructors — __init__, __new__, default parameters, class method constructors, constructor chaining, and destructor __del__ with real-world examples.Object Oriented ProgrammingEncapsulation in PythonLearn encapsulation in Python — public, protected, and private attributes, name mangling, getter/setter methods, the @property decorator, and data validation patterns.Object Oriented ProgrammingMagic Methods (Dunder Methods) in PythonMaster PythonObject Oriented ProgrammingMethod Overriding in PythonDeep dive into Python method overriding — redefining parent class methods in child classes, using super(), cooperative multiple inheritance, MRO interaction, and real-world design patterns.