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
Deep dive into Python method overriding — redefining parent class methods in child classes, using super(), cooperative multiple inheritance, MRO interaction, and real-world design patterns.
🧠 Real-World Analogy — Company Policy
A company has a general HR policy — uniform leave rules for all employees. But the Engineering department manager has added extra rules for their team — "remote work on Fridays." The special rule applies to engineering employees; the general policy applies to everyone else. This is method overriding — a child class redefines its parent's method to provide new behavior.
✅ Basic Method Overriding
Example
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
return f"{self.name} makes a sound."
def move(self):
return f"{self.name} moves."
def describe(self):
return f"I am {self.name}. {self.speak()} {self.move()}"
class Dog(Animal):
def speak(self): # override Animal.speak()
return f"{self.name} says: Woof! 🐕"
def move(self): # override Animal.move()
return f"{self.name} runs on 4 legs."
class Cat(Animal):
def speak(self):
return f"{self.name} says: Meow! 🐈"
def move(self):
return f"{self.name} slinks silently."
class Snake(Animal):
def speak(self):
return f"{self.name} hisses: Ssss! 🐍"
def move(self):
return f"{self.name} slithers."
animals = [
Animal("Generic Animal"),
Dog("Rex"),
Cat("Whiskers"),
Snake("Nagraj"),
]
for animal in animals:
print(animal.describe())
Output:
| I am Rex. Rex says | Woof! 🐕 Rex runs on 4 legs. |
| I am Whiskers. Whiskers says | Meow! 🐈 Whiskers slinks silently. |
| I am Nagraj. Nagraj hisses | Ssss! 🐍 Nagraj slithers. |
🔗 Overriding with super() — Extending Parent Behavior
Sometimes you need to do the parent's work and add something extra — with super() you call the parent method and then add your own logic on top.Example
class Employee:
def __init__(self, name, emp_id, salary):
self.name = name
self.emp_id = emp_id
self.salary = salary
def get_details(self):
return (f"[{self.emp_id}] {self.name:20s} | "
f"Salary: ₹{self.salary:>10,.2f}")
def calculate_bonus(self):
return self.salary * 0.10 # 10% for all employees
class Manager(Employee):
def __init__(self, name, emp_id, salary, team_size):
super().__init__(name, emp_id, salary) # reuse parent __init__
self.team_size = team_size
def get_details(self):
base = super().get_details() # reuse parent method
return f"{base} | Team: {self.team_size:>3} people | Role: Manager"
def calculate_bonus(self):
base_bonus = super().calculate_bonus() # 10% base
team_bonus = self.team_size * 500 # extra per team member
total = base_bonus + team_bonus
return total
class Director(Manager):
def __init__(self, name, emp_id, salary, team_size, budget_crores):
super().__init__(name, emp_id, salary, team_size)
self.budget = budget_crores
def get_details(self):
base = super().get_details()
return f"{base} | Budget: ₹{self.budget}Cr | Role: Director"
def calculate_bonus(self):
base = super().calculate_bonus()
return base + self.budget * 10000 # extra budget bonus
employees = [
Employee("Rahul Kumar", "E001", 50000),
Employee("Sneha Singh", "E002", 55000),
Manager( "Arjun Sharma", "M001", 90000, 8),
Manager( "Priya Mehta", "M002", 95000, 12),
Director("Vikram Nair", "D001", 150000, 30, 5),
]
print("── Employee Report ──────────────────────────────────────────────────")
for emp in employees:
print(emp.get_details())
print(f" → Annual Bonus: ₹{emp.calculate_bonus():,.2f}\n")
Output:
| [E001] Rahul Kumar | Salary | ₹ 50,000.00 |
| [E002] Sneha Singh | Salary | ₹ 55,000.00 |
| [M001] Arjun Sharma | Salary | ₹ 90,000.00 | Team: 8 people | Role: Manager |
| [M002] Priya Mehta | Salary | ₹ 95,000.00 | Team: 12 people | Role: Manager |
| [D001] Vikram Nair | Salary | ₹ 150,000.00 | Team: 30 people | Role: Director |
🎮 Game Characters — Override Chain
Example
class GameCharacter:
def __init__(self, name, health, attack):
self.name = name
self.health = health
self.attack = attack
self.level = 1
def take_damage(self, damage):
actual = max(0, damage - self._defense())
self.health -= actual
self.health = max(0, self.health)
print(f" {self.name} takes {actual} damage (blocked {damage - actual}). HP: {self.health}")
def perform_attack(self):
dmg = self._calculate_damage()
print(f" ⚔️ {self.name} attacks for {dmg} damage!")
return dmg
def level_up(self):
self.level += 1
self.health += 20
self.attack += 5
print(f" 🆙 {self.name} leveled up to {self.level}! HP: {self.health}, ATK: {self.attack}")
def _defense(self): # can be overridden
return 0
def _calculate_damage(self): # can be overridden
return self.attack
def status(self):
return (f"[{self.__class__.__name__}] {self.name:15s} "
f"HP:{self.health:>5} | ATK:{self.attack:>4} | "
f"DEF:{self._defense():>3} | LVL:{self.level}")
class Warrior(GameCharacter):
def __init__(self, name, health=120, attack=25, armor=15):
super().__init__(name, health, attack)
self.armor = armor
def _defense(self): # override — warriors have armor
return self.armor
def level_up(self):
super().level_up() # call parent level_up
self.armor += 3 # extra armor per level
print(f" 🛡️ Armor increased to {self.armor}")
def shield_bash(self):
bonus_dmg = self.armor // 2
print(f" 🛡️ {self.name} shield bashes for {bonus_dmg} bonus damage!")
return bonus_dmg
class Mage(GameCharacter):
def __init__(self, name, health=80, attack=15, mana=100, spell_power=40):
super().__init__(name, health, attack)
self.mana = mana
self.spell_power = spell_power
def _calculate_damage(self): # override — mages use spell_power
if self.mana >= 30:
self.mana -= 30
return self.attack + self.spell_power
print(f" ⚡ {self.name} is out of mana! Using physical attack.")
return self.attack
def level_up(self):
super().level_up()
self.mana += 30
self.spell_power += 10
print(f" 🔮 Spell power: {self.spell_power}, Mana: {self.mana}")
class Rogue(GameCharacter):
def __init__(self, name, health=90, attack=20, crit_chance=0.3):
super().__init__(name, health, attack)
self.crit_chance = crit_chance
def _calculate_damage(self): # override — rogues can crit
import random
is_crit = random.random() < self.crit_chance
dmg = self.attack * (2.5 if is_crit else 1)
if is_crit:
print(f" ✨ CRITICAL HIT!")
return int(dmg)
# ── Battle simulation ────────────────────────────────────
warrior = Warrior("Thor", 120, 25, 20)
mage = Mage( "Merlin", 80, 15, 100, 50)
rogue = Rogue( "Shadow", 90, 30, 0.4)
party = [warrior, mage, rogue]
print("── Party Status ────────────────────────────────")
for hero in party:
print(hero.status())
print("\n── Battle Round ────────────────────────────────")
for hero in party:
hero.perform_attack()
print("\n── Taking Damage ───────────────────────────────")
for hero in party:
hero.take_damage(30)
print("\n── Level Up! ───────────────────────────────────")
for hero in party:
hero.level_up()
print("\n── Updated Status ──────────────────────────────")
for hero in party:
print(hero.status())
⚠️ Preventing Override — Convention
Python has no final keyword, but you can signal "do not override" using conventions or raise errors:python example
class Base:
def important_method(self):
"""Do NOT override this method."""
return "Critical base logic"
def _sealed_operation(self):
# Raise error if child tries to call super's version
raise NotImplementedError("This method must not be overridden.")
# Or use a decorator convention:
def final(method):
"""Decorator marking a method as 'final' (no override)."""
method.__is_final__ = True
return method
class Base2:
@final
def calculate(self):
return 42
class Child2(Base2):
def calculate(self): # overriding anyway — but code reviewer can check __is_final__
return 99
# Check at runtime:
print(getattr(Base2.calculate, "__is_final__", False)) # True🔀 Cooperative Multiple Inheritance with super()
Example
class LogMixin:
def save(self):
print(f" [LogMixin] Logging save operation for {self.__class__.__name__}")
super().save() # cooperatively calls next in MRO
class ValidationMixin:
def save(self):
print(f" [ValidationMixin] Validating data before save...")
super().save() # cooperatively calls next in MRO
class CacheMixin:
def save(self):
print(f" [CacheMixin] Clearing cache after save...")
super().save()
class BaseModel:
def save(self):
print(f" [BaseModel] Actually saving to database. ✅")
class UserModel(LogMixin, ValidationMixin, CacheMixin, BaseModel):
def save(self):
print("UserModel.save() called — delegating to MRO chain:")
super().save()
user = UserModel()
user.save()
print(f"\nMRO: {[c.__name__ for c in UserModel.__mro__]}")
Output:
Example
UserModel.save() called — delegating to MRO chain:
[LogMixin] Logging save operation for UserModel
[ValidationMixin] Validating data before save...
[CacheMixin] Clearing cache after save...
[BaseModel] Actually saving to database. ✅
MRO: ['UserModel', 'LogMixin', 'ValidationMixin', 'CacheMixin', 'BaseModel', 'object']
🇮🇳 Hindi Explanation (हिंदी में समझें)
Method Overriding kya hai? When a child class redefines a method with the same name as its parent class — to provide new or modified behavior — that's method overriding. This is how runtime polymorphism works.
Why do we usesuper()in overriding? Often you need both the parent's work (super().method()) and your own extra logic on top.super()lets you reuse the parent's work without wasting it — you reuse and extend.
How doessuper()work in multiple inheritance?super()works according to MRO (Method Resolution Order) — it doesn't call the "parent" class, but the next class in the MRO. That's why cooperative patterns withsuper()are important in multiple inheritance.
❓ Interview Questions
Q1: What is method overriding? How is it different from overloading?
Answer:
- Overriding: Child class redefines a parent class method with the same name and signature. Runtime polymorphism — which version runs depends on the actual object type.
- Overloading: Same method name, different parameters (Python doesn't support true overloading — use defaults/
*argsinstead).
Q2: When should you call super() in an overriding method?
Answer: Call super() when you want to extend (not replace) the parent's behavior. Examples: __init__ almost always needs super().__init__() to initialize parent attributes. Business methods should call super() when base logic should still run plus new logic.
Q3: What happens if a child class doesn't call super().__init__()?
Answer: The parent's __init__ never runs, so parent attributes are never initialized. Calling any inherited method that depends on those attributes will raise AttributeError. Always call super().__init__() unless you deliberately want to skip parent initialization.
Q4: Can you call a grandparent's method directly, skipping the parent?
Answer: Yes, explicitly: GrandParent.method(self). But this defeats the purpose of cooperative inheritance and breaks MRO. Prefer super() and design the hierarchy so MRO does the right thing.
Q5: What is cooperative multiple inheritance?
Answer: Each class in the MRO chain calls super().method(), passing control cooperatively down the chain. Every class's version of the method runs once, in MRO order, until object is reached. This requires all classes to use super() consistently.
Q6: How can you check if a method has been overridden?
Answer:
python example
Dog.speak is Animal.speak # False — overridden
Cat.speak is Animal.speak # False
# or
type(obj).speak is Animal.speak # False means overriddenQ7: What is method shadowing vs method overriding?
Answer: Same concept — a subclass defines a method with the same name as the parent. "Shadowing" emphasizes that the parent's version is hidden (shadowed) by the child's version. In Python, they're the same thing.
🧪 Practice Exercises
- Animal Symphony: Create
Animalwithspeak()returning a generic sound. Override inDog,Cat,Lion,Parrotwith specific sounds + emoji. AddGoldenRetriever(Dog)that callssuper().speak()then adds "...and wags tail!". - Tax Calculator:
Employee.tax()= 10%. Override inSeniorEmployee(8%),Director(15%),Contractor(20%). All callsuper()and add a role-specific surcharge. - Logging Mixin Chain: Stack 3 mixins on a
DatabaseModel.save()—AuditMixin(timestamp),ValidationMixin(check required fields),CacheMixin(invalidate cache). All use cooperativesuper(). - Vending Machine: Base
VendingMachine.dispense()— override inSnackMachine,DrinkMachine,CoffeeMachine. Each callssuper()for base checks then adds product-specific logic. - Shipping Cost: Override
calculate_cost()in a 4-level hierarchy:BaseShipping→DomesticShipping→ExpressShipping→SameDayShippingwith each callingsuper()and adding its surcharge.
💡 Next Topic → Magic Methods: Unlock Python's full power with dunder methods —__init__,__str__,__repr__,__len__,__add__,__eq__,__lt__,__getitem__,__iter__and more!
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Method Overriding 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 ProgrammingInheritance in PythonMaster Python inheritance — single, multiple, multilevel, and hierarchical inheritance, MRO (Method Resolution Order), super(), mixins, and real-world class hierarchies.Object Oriented ProgrammingMagic Methods (Dunder Methods) in PythonMaster Python