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
Understand polymorphism in Python — method overriding, duck typing, operator overloading, runtime polymorphism, and how to write flexible, reusable code with real-world examples.
🧠 Real-World Analogy — Remote Control
Think of a remote control's "Volume Up" button. Press it on a TV, volume increases. Press it on an AC, temperature increases. Press it on a music player, song volume increases. Same button, different behavior depending on the device. Same interface, different behavior — yahi Polymorphism hai. In Greek: *poly* = many, *morph* = forms. "One name, many forms."
1️⃣ Method Overriding (Runtime Polymorphism)
Example
class Shape:
def area(self):
return 0
def describe(self):
return f"I am a {self.__class__.__name__} with area = {self.area():.2f}"
class Circle(Shape):
def __init__(self, radius):
self.radius = radius
def area(self): # override
import math
return math.pi * self.radius ** 2
class Rectangle(Shape):
def __init__(self, l, w):
self.l, self.w = l, w
def area(self): # override
return self.l * self.w
class Triangle(Shape):
def __init__(self, base, height):
self.base = base
self.height = height
def area(self): # override
return 0.5 * self.base * self.height
# Polymorphic behavior — same call, different result
shapes = [Circle(7), Rectangle(8, 5), Triangle(6, 4)]
for shape in shapes:
print(shape.describe()) # works for ALL shape types!
print("\nLargest shape:", max(shapes, key=lambda s: s.area()).describe())
Output:
Example
I am a Circle with area = 153.94
I am a Rectangle with area = 40.00
I am a Triangle with area = 12.00
Largest shape: I am a Circle with area = 153.94
2️⃣ Duck Typing
In Python, duck typing means: "If an object walks like a duck and quacks like a duck, then we treat it as a duck." Meaning: No type check is needed — if the object has the required method, it will work.
Example
class Dog:
def speak(self): return "Woof!"
def move(self): return "runs on 4 legs"
class Cat:
def speak(self): return "Meow!"
def move(self): return "slinks quietly"
class Robot:
def speak(self): return "Beep boop!"
def move(self): return "rolls on wheels"
class Human:
def speak(self): return "Hello!"
def move(self): return "walks on 2 legs"
def make_noise_and_move(entity):
"""No type check needed — duck typing!"""
print(f"{entity.__class__.__name__}: '{entity.speak()}' — {entity.move()}")
entities = [Dog(), Cat(), Robot(), Human()]
for e in entities:
make_noise_and_move(e) # works for ALL of them!
Output:
| Dog | 'Woof!' — runs on 4 legs |
| Cat | 'Meow!' — slinks quietly |
| Robot | 'Beep boop!' — rolls on wheels |
| Human | 'Hello!' — walks on 2 legs |
3️⃣ Polymorphism with Built-in Functions
Example
# len() works polymorphically on any object with __len__
print(len("Hello")) # 5 — string
print(len([1, 2, 3, 4])) # 4 — list
print(len({"a": 1, "b": 2})) # 2 — dict
# + operator works differently based on type
print(5 + 3) # 8 — integer addition
print("Hello" + " World") # Hello World — string concat
print([1,2] + [3,4]) # [1, 2, 3, 4] — list merge
# sorted() works on any iterable
print(sorted([3,1,4,1,5,9])) # numbers
print(sorted(["banana","apple","cherry"])) # strings
4️⃣ Payment Gateway — Real-World Polymorphism
Example
from abc import ABC, abstractmethod
class PaymentMethod(ABC):
"""Abstract base — defines the interface."""
@abstractmethod
def pay(self, amount): pass
@abstractmethod
def refund(self, amount): pass
def receipt(self, amount):
print(f" 🧾 Receipt: ₹{amount:,.2f} via {self.__class__.__name__}")
class CreditCard(PaymentMethod):
def __init__(self, card_number, holder):
self.card_number = f"**** **** **** {card_number[-4:]}"
self.holder = holder
def pay(self, amount):
print(f" 💳 Credit Card payment of ₹{amount:,.2f} by {self.holder} ({self.card_number})")
self.receipt(amount)
def refund(self, amount):
print(f" ↩️ Refunded ₹{amount:,.2f} to card {self.card_number}")
class UPI(PaymentMethod):
def __init__(self, upi_id):
self.upi_id = upi_id
def pay(self, amount):
print(f" 📱 UPI payment of ₹{amount:,.2f} to {self.upi_id}")
self.receipt(amount)
def refund(self, amount):
print(f" ↩️ Refunded ₹{amount:,.2f} to UPI ID {self.upi_id}")
class NetBanking(PaymentMethod):
def __init__(self, bank, account_no):
self.bank = bank
self.account_no = f"XXXX{account_no[-4:]}"
def pay(self, amount):
print(f" 🏦 Net Banking payment of ₹{amount:,.2f} via {self.bank} ({self.account_no})")
self.receipt(amount)
def refund(self, amount):
print(f" ↩️ Refunded ₹{amount:,.2f} to {self.bank} account {self.account_no}")
class Wallet(PaymentMethod):
def __init__(self, name, balance):
self.name = name
self.balance = balance
def pay(self, amount):
if amount > self.balance:
print(f" ❌ Insufficient wallet balance! (Balance: ₹{self.balance:,.2f})")
return
self.balance -= amount
print(f" 👛 Wallet '{self.name}' payment ₹{amount:,.2f} | Remaining: ₹{self.balance:,.2f}")
self.receipt(amount)
def refund(self, amount):
self.balance += amount
print(f" ↩️ Refunded ₹{amount:,.2f} to {self.name} wallet. Balance: ₹{self.balance:,.2f}")
def checkout(payment_method: PaymentMethod, amount: float):
"""Single function — works with ANY payment method (polymorphism)."""
print(f"\n{'─'*50}")
print(f"Processing payment of ₹{amount:,.2f}...")
payment_method.pay(amount)
# Polymorphic usage
methods = [
CreditCard("4111111111111234", "Arjun Sharma"),
UPI("arjun@upi"),
NetBanking("HDFC Bank", "0012345678"),
Wallet("Paytm", 1500),
]
for method in methods:
checkout(method, 999)
# Refund test
print("\n── Refund Test ──────────────────────────")
methods[0].refund(999)
methods[3].pay(2000) # should fail (insufficient)
Output:
| 🧾 Receipt | ₹999.00 via CreditCard |
| 🧾 Receipt | ₹999.00 via UPI |
| 🧾 Receipt | ₹999.00 via NetBanking |
| 👛 Wallet 'Paytm' payment ₹999.00 | Remaining | ₹501.00 |
| 🧾 Receipt | ₹999.00 via Wallet |
| ❌ Insufficient wallet balance! (Balance | ₹501.00) |
5️⃣ Operator Overloading
In Python, we can give new meaning to operators like+,-,*,==,<for our own classes — this is also polymorphism.
python example
class Vector:
def __init__(self, x, y, z=0):
self.x, self.y, self.z = x, y, z
def __add__(self, other): # v1 + v2
return Vector(self.x + other.x, self.y + other.y, self.z + other.z)
def __sub__(self, other): # v1 - v2
return Vector(self.x - other.x, self.y - other.y, self.z - other.z)
def __mul__(self, scalar): # v1 * 3
return Vector(self.x * scalar, self.y * scalar, self.z * scalar)
def __rmul__(self, scalar): # 3 * v1
return self.__mul__(scalar)
def __eq__(self, other): # v1 == v2
return self.x == other.x and self.y == other.y and self.z == other.z
def __abs__(self): # abs(v1) → magnitude
import math
return math.sqrt(self.x**2 + self.y**2 + self.z**2)
def __str__(self):
return f"Vector({self.x}, {self.y}, {self.z})"
def __repr__(self):
return f"Vector(x={self.x}, y={self.y}, z={self.z})"
def dot(self, other):
return self.x*other.x + self.y*other.y + self.z*other.z
v1 = Vector(1, 2, 3)
v2 = Vector(4, 5, 6)
print(f"v1 = {v1}")
print(f"v2 = {v2}")
print(f"v1 + v2 = {v1 + v2}")
print(f"v2 - v1 = {v2 - v1}")
print(f"v1 * 3 = {v1 * 3}")
print(f"2 * v2 = {2 * v2}")
print(f"|v1| = {abs(v1):.4f}")
print(f"v1 == v1 = {v1 == v1}")
print(f"v1 == v2 = {v1 == v2}")
print(f"v1 · v2 = {v1.dot(v2)}")Output:
Example
v1 = Vector(1, 2, 3)
v2 = Vector(4, 5, 6)
v1 + v2 = Vector(5, 7, 9)
v2 - v1 = Vector(3, 3, 3)
v1 * 3 = Vector(3, 6, 9)
2 * v2 = Vector(8, 10, 12)
|v1| = 3.7417
v1 == v1 = True
v1 == v2 = False
v1 · v2 = 32
6️⃣ Polymorphism with str(), len(), repr()
python example
class Playlist:
def __init__(self, name):
self.name = name
self.songs = []
def add(self, song):
self.songs.append(song)
def __len__(self): # len(playlist)
return len(self.songs)
def __str__(self): # str(playlist) / print(playlist)
return f"Playlist '{self.name}' ({len(self)} songs)"
def __repr__(self):
return f"Playlist(name={self.name!r}, songs={self.songs!r})"
def __contains__(self, song): # "song" in playlist
return song in self.songs
def __iter__(self): # for song in playlist:
return iter(self.songs)
p = Playlist("Bollywood Hits")
p.add("Kal Ho Na Ho")
p.add("Tum Hi Ho")
p.add("Raabta")
print(p) # uses __str__
print(len(p)) # uses __len__
print("Raabta" in p) # uses __contains__
print(repr(p)) # uses __repr__
print("\nTracklist:")
for i, song in enumerate(p, 1):
print(f" {i}. {song}")Output:
Example
Playlist 'Bollywood Hits' (3 songs)
3
True
Playlist(name='Bollywood Hits', songs=['Kal Ho Na Ho', 'Tum Hi Ho', 'Raabta'])
Tracklist:
1. Kal Ho Na Ho
2. Tum Hi Ho
3. Raabta
🇮🇳 Hindi Explanation (हिंदी में समझें)
Polymorphism kya hai? Polymorphism means "one interface, many implementations." Just as thearea()method exists in Circle, Rectangle, and Triangle — but each calculates differently. You can use a single loop to callarea()on any shape without knowing the specific type.
Duck Typing kya hai? In Python, there's no need to explicitly check types. If an object has the method you need, it will work. "If it talks like a duck and walks like a duck, it's a duck."
Operator Overloading kya hai? Giving operators like+,-,*,==new meaning for your own class. This makes your code more readable and natural (like Vector addition in math).
❓ Interview Questions
Q1: What is polymorphism? Give a real-world example.
Answer: Polymorphism means "many forms" — the same interface behaves differently based on the object type. Real-world: A draw() method on Circle, Rectangle, and Triangle each draws a different shape. In code, you can loop over all shapes and call draw() without knowing the specific type.
Q2: What is duck typing? How is it different from Java's approach?
Answer: Duck typing means Python doesn't require formal type checking — if an object has the required method/attribute, it works. In Java, you must explicitly implement an interface. Python's approach is more flexible and concise. The downside: runtime errors instead of compile-time errors.
Q3: What is the difference between method overriding and method overloading?
Answer:
- Overriding: A subclass provides its own implementation of a method already defined in the parent. Runtime polymorphism.
- Overloading: Same method name with different parameters. Python does NOT support traditional overloading — use default/
*argsinstead.
Q4: How does Python implement operator overloading?
Answer: Via dunder (magic) methods: __add__ for +, __mul__ for *, __eq__ for ==, __lt__ for <, etc. When Python sees a + b, it calls a.__add__(b).
Q5: What is the Open/Closed Principle and how does polymorphism enable it?
Answer: The Open/Closed Principle (SOLID) says: "Open for extension, closed for modification." Polymorphism enables this — you can add a new PaymentMethod subclass without changing the checkout() function. The function works with any payment method that implements pay().
Q6: Can you use isinstance() to check polymorphic types?
Answer: Yes, and it's the preferred way in Python:
python example
if isinstance(obj, PaymentMethod):
obj.pay(amount)isinstance() returns True for the class AND all subclasses, making it ideal for polymorphic dispatch.
🧪 Practice Exercises
- Animal Choir: Create
Animalhierarchy withDog,Cat,Parrot,Cow. Write amake_all_speak(animals)function. - Notification System: Create
NotificationChannel(abstract) withEmail,SMS,PushNotificationsubclasses each implementingsend(message). - Fraction Math: Create a
Fractionclass with__add__,__sub__,__mul__,__truediv__,__eq__,__str__. - Shipping Calculator: Create
ShippingMethod(Standard, Express, Overnight) with polymorphiccalculate_cost(weight, distance). - File Exporter: Create
Exporterbase class withCSV,JSON,XMLsubclasses implementingexport(data, filename).
💡 Next Topic → Encapsulation: Learn to hide internal details, use private/protected attributes, getters/setters, and Python's @property decorator.Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Polymorphism 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