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
Top 25+ Python OOP interview questions covering classes, objects, inheritance, polymorphism, encapsulation, abstraction, decorators, and design patterns with Hindi explanations.
Introduction
Object-Oriented Programming interviews mein yeh questions hamesha pooche jaate hain. Sab kuch examples ke saath explain kiya gaya hai.
Q2: Class aur Object mein kya fark hai?
Answer: Class ek blueprint/template hai. Object us blueprint ka ek instance hai.
python example
# Class = Blueprint
class Car:
# Class variable — shared by all instances
total_cars = 0
def __init__(self, brand, model, year):
# Instance variables — unique to each object
self.brand = brand
self.model = model
self.year = year
Car.total_cars += 1
def describe(self):
return f"{self.year} {self.brand} {self.model}"
# Objects = Instances
car1 = Car("Toyota", "Camry", 2024)
car2 = Car("Honda", "Civic", 2023)
print(car1.describe()) # 2024 Toyota Camry
print(car2.describe()) # 2023 Honda Civic
print(Car.total_cars) # 2
# Each object has its own copy of instance variables
print(id(car1) == id(car2)) # False — different objects!
print(car1.brand != car2.brand) # True — different data📝 Hindi Explanation
Class ek cookie-cutter (cookie shape) hai, Object us cutter se bani cookie. Ek class se infinite objects create kar sakte ho — har object apna independent data rakhta hai.
Q3: Inheritance kya hai? Types explain karo.
python example
# 1. Single Inheritance
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
return "..."
def eat(self):
return f"{self.name} is eating"
class Dog(Animal):
def speak(self): # Override
return "Woof!"
# 2. Multiple Inheritance
class Flyable:
def fly(self):
return "I can fly!"
class Swimmable:
def swim(self):
return "I can swim!"
class Duck(Animal, Flyable, Swimmable): # Multiple inheritance
def speak(self):
return "Quack!"
duck = Duck("Donald")
print(duck.speak()) # Quack!
print(duck.fly()) # I can fly!
print(duck.swim()) # I can swim!
print(duck.eat()) # Donald is eating (inherited from Animal)
# 3. Multilevel Inheritance
class Vehicle:
def start(self):
return "Engine started"
class Car(Vehicle):
def drive(self):
return "Driving..."
class ElectricCar(Car):
def charge(self):
return "Charging battery"
tesla = ElectricCar()
print(tesla.start()) # From Vehicle
print(tesla.drive()) # From Car
print(tesla.charge()) # Own method
# 4. Hierarchical Inheritance
class Shape:
def area(self):
return 0
class Circle(Shape):
def __init__(self, r): self.r = r
def area(self): return 3.14 * self.r**2
class Square(Shape):
def __init__(self, s): self.s = s
def area(self): return self.s ** 2Q4: super() kya karta hai?
python example
class Animal:
def __init__(self, name, species):
self.name = name
self.species = species
print(f"Animal.__init__ called: {name}")
def describe(self):
return f"{self.name} is a {self.species}"
class Dog(Animal):
def __init__(self, name, breed):
super().__init__(name, "Canine") # Parent's __init__ call karo
self.breed = breed
print(f"Dog.__init__ called: {breed}")
def describe(self):
base = super().describe() # Parent's describe call karo
return f"{base}, breed: {self.breed}"
dog = Dog("Rex", "German Shepherd")
print(dog.describe())
# Output:
# Animal.__init__ called: Rex
# Dog.__init__ called: German Shepherd
# Rex is a Canine, breed: German Shepherd
# super() with multiple inheritance
class A:
def hello(self):
return "Hello from A"
class B(A):
def hello(self):
return f"{super().hello()} + B"
class C(A):
def hello(self):
return f"{super().hello()} + C"
class D(B, C):
def hello(self):
return f"{super().hello()} + D"
d = D()
print(d.hello())
# Hello from A + C + B + D (MRO determines order)
print(D.__mro__) # (D, B, C, A, object)Q5: MRO (Method Resolution Order) kya hai?
Example
class A:
def method(self):
return "A"
class B(A):
def method(self):
return "B"
class C(A):
def method(self):
return "C"
class D(B, C):
pass
# MRO — C3 Linearization algorithm
print(D.__mro__)
# (<class 'D'>, <class 'B'>, <class 'C'>, <class 'A'>, <class 'object'>)
d = D()
print(d.method()) # "B" — B comes before C in MRO
# mro() method bhi use kar sakte ho
print([cls.__name__ for cls in D.mro()])
# ['D', 'B', 'C', 'A', 'object']
# Diamond problem
# A
# / \
# B C
# \ /
# D
# Python C3 algorithm: D -> B -> C -> A -> object
# Always check leftmost first, then right
📝 Hindi Explanation
MRO (Method Resolution Order) determine karta hai ki multiple inheritance mein method kahan se liya jaayega. Python C3 Linearization algorithm use karta hai. Simple rule: left to right, depth first, but common ancestors baad mein aate hain.
Q6: Encapsulation — Private aur Protected attributes kya hain?
python example
class BankAccount:
def __init__(self, owner, balance):
self.owner = owner # Public
self._account_type = "savings" # Protected (convention: _)
self.__balance = balance # Private (name mangling: __)
@property
def balance(self):
"""Read-only property"""
return self.__balance
def deposit(self, amount):
if amount > 0:
self.__balance += amount
print(f"Deposited ₹{amount}. New balance: ₹{self.__balance}")
else:
raise ValueError("Deposit amount must be positive!")
def withdraw(self, amount):
if 0 < amount <= self.__balance:
self.__balance -= amount
print(f"Withdrew ₹{amount}. New balance: ₹{self.__balance}")
else:
raise ValueError("Invalid withdrawal amount!")
acc = BankAccount("Alice", 10000)
acc.deposit(5000)
acc.withdraw(2000)
print(f"Balance: {acc.balance}") # Via property — read only
# Direct access to private — NOT recommended
# print(acc.__balance) # AttributeError!
print(acc._BankAccount__balance) # Works but bad practice! Name mangling
# Protected — accessible, but "please don't" convention
print(acc._account_type) # "savings" — accessible but convention says don't
# Correct: via methods onlyQ7: Polymorphism kya hai? Duck typing kya hai?
Example
# Method Overriding — Polymorphism
class Shape:
def area(self):
return 0
class Circle(Shape):
def __init__(self, r):
self.r = r
def area(self):
return 3.14159 * self.r ** 2
class Rectangle(Shape):
def __init__(self, w, h):
self.w = w
self.h = h
def area(self):
return self.w * self.h
# Polymorphic function
def print_area(shape):
print(f"{shape.__class__.__name__}: {shape.area():.2f}")
shapes = [Circle(5), Rectangle(4, 6), Circle(3)]
for shape in shapes:
print_area(shape) # Same call, different behavior!
# Duck Typing — "if it quacks like a duck, it IS a duck"
class Dog:
def speak(self):
return "Woof!"
class Cat:
def speak(self):
return "Meow!"
class Robot: # Not an Animal, but has speak()
def speak(self):
return "Beep boop!"
def make_it_speak(thing):
print(thing.speak()) # Works for any object with speak()!
make_it_speak(Dog()) # Woof!
make_it_speak(Cat()) # Meow!
make_it_speak(Robot()) # Beep boop!
# Python doesn't check inheritance — just checks if method exists!
Q8: Abstract Classes kya hain?
python example
from abc import ABC, abstractmethod
class Vehicle(ABC):
"""Abstract base class — directly instantiate nahi kar sakte"""
def __init__(self, brand, model):
self.brand = brand
self.model = model
@abstractmethod
def start_engine(self):
"""Subclasses must implement this"""
pass
@abstractmethod
def fuel_type(self):
pass
def describe(self): # Concrete method — can be inherited
return f"{self.brand} {self.model} ({self.fuel_type()})"
class PetrolCar(Vehicle):
def start_engine(self):
return "Vroooom! (Petrol engine started)"
def fuel_type(self):
return "Petrol"
class ElectricCar(Vehicle):
def start_engine(self):
return "Hmmmm... (Electric motor started)"
def fuel_type(self):
return "Electric"
# Can't instantiate abstract class!
try:
v = Vehicle("Generic", "Vehicle")
except TypeError as e:
print(f"Error: {e}")
# Error: Can't instantiate abstract class Vehicle with abstract methods...
petrol = PetrolCar("Toyota", "Camry")
electric = ElectricCar("Tesla", "Model 3")
print(petrol.describe()) # Toyota Camry (Petrol)
print(electric.describe()) # Tesla Model 3 (Electric)
print(petrol.start_engine()) # Vroooom!
print(electric.start_engine()) # Hmmmm...Q9: Property decorator kaise use karte hain?
python example
class Temperature:
def __init__(self, celsius=0):
self._celsius = celsius
@property
def celsius(self):
"""Getter"""
return self._celsius
@celsius.setter
def celsius(self, value):
"""Setter with validation"""
if value < -273.15:
raise ValueError(f"Temperature {value}°C is below absolute zero!")
self._celsius = value
@celsius.deleter
def celsius(self):
"""Deleter"""
print("Deleting temperature!")
del self._celsius
@property
def fahrenheit(self):
"""Read-only derived property"""
return self._celsius * 9/5 + 32
@property
def kelvin(self):
return self._celsius + 273.15
t = Temperature(25)
print(f"Celsius: {t.celsius}") # 25
print(f"Fahrenheit: {t.fahrenheit}") # 77.0
print(f"Kelvin: {t.kelvin}") # 298.15
t.celsius = 100
print(f"New Fahrenheit: {t.fahrenheit}") # 212.0
try:
t.celsius = -300 # ValueError!
except ValueError as e:
print(f"Error: {e}")
del t.celsius # Calls deleterQ10: Dunder (Magic) Methods kya hain?
Example
class Vector:
"""2D Vector class with dunder methods"""
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return f"Vector({self.x}, {self.y})"
def __str__(self):
return f"({self.x}, {self.y})"
def __add__(self, other):
return Vector(self.x + other.x, self.y + other.y)
def __sub__(self, other):
return Vector(self.x - other.x, self.y - other.y)
def __mul__(self, scalar):
return Vector(self.x * scalar, self.y * scalar)
def __rmul__(self, scalar):
return self.__mul__(scalar)
def __eq__(self, other):
return self.x == other.x and self.y == other.y
def __len__(self):
return 2
def __abs__(self):
return (self.x**2 + self.y**2) ** 0.5
def __iter__(self):
yield self.x
yield self.y
def __contains__(self, value):
return value in (self.x, self.y)
v1 = Vector(3, 4)
v2 = Vector(1, 2)
print(v1) # (3, 4)
print(repr(v1)) # Vector(3, 4)
print(v1 + v2) # (4, 6)
print(v1 - v2) # (2, 2)
print(v1 * 2) # (6, 8)
print(3 * v1) # (9, 12)
print(abs(v1)) # 5.0
print(list(v1)) # [3, 4]
print(3 in v1) # True
print(len(v1)) # 2
Q11: Composition vs Inheritance kab use karo?
python example
# Inheritance: "IS-A" relationship
class Animal:
def breathe(self):
return "Breathing..."
class Dog(Animal): # Dog IS-A Animal ✅
def bark(self):
return "Woof!"
# Composition: "HAS-A" relationship
class Engine:
def __init__(self, horsepower):
self.hp = horsepower
def start(self):
return f"Engine ({self.hp}hp) started"
class Wheels:
def __init__(self, count):
self.count = count
def rotate(self):
return f"{self.count} wheels rotating"
class Car: # Car HAS-A Engine, HAS-A Wheels (not IS-A Engine)
def __init__(self, brand, hp, wheel_count=4):
self.brand = brand
self.engine = Engine(hp) # Composition
self.wheels = Wheels(wheel_count) # Composition
def drive(self):
engine_status = self.engine.start()
wheel_status = self.wheels.rotate()
return f"{self.brand}: {engine_status}, {wheel_status}"
car = Car("BMW", 300)
print(car.drive())
# Favor composition over inheritance (FCoI principle)
# Inheritance: tight coupling, deep hierarchies = problems
# Composition: loose coupling, flexible, easier to testQ12: Singleton Design Pattern
python example
class Singleton:
"""Only one instance allowed"""
_instance = None
def __new__(cls):
if cls._instance is None:
cls._instance = super().__new__(cls)
cls._instance.initialized = False
return cls._instance
def __init__(self):
if not self.initialized:
self.value = 0
self.initialized = True
def increment(self):
self.value += 1
s1 = Singleton()
s2 = Singleton()
print(s1 is s2) # True — same instance!
s1.increment()
s1.increment()
print(s2.value) # 2 — same object!
# Thread-safe Singleton
import threading
class ThreadSafeSingleton:
_instance = None
_lock = threading.Lock()
def __new__(cls):
with cls._lock:
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instanceQ13: Factory Design Pattern
Example
from abc import ABC, abstractmethod
class Notification(ABC):
@abstractmethod
def send(self, message, recipient):
pass
class EmailNotification(Notification):
def send(self, message, recipient):
print(f"EMAIL to {recipient}: {message}")
class SMSNotification(Notification):
def send(self, message, recipient):
print(f"SMS to {recipient}: {message}")
class PushNotification(Notification):
def send(self, message, recipient):
print(f"PUSH to {recipient}: {message}")
# Factory method
class NotificationFactory:
@staticmethod
def create(notification_type: str) -> Notification:
types = {
"email": EmailNotification,
"sms": SMSNotification,
"push": PushNotification,
}
if notification_type not in types:
raise ValueError(f"Unknown notification type: {notification_type}")
return types[notification_type]()
# Usage — client code doesn't know which class is instantiated
factory = NotificationFactory()
email = factory.create("email")
sms = factory.create("sms")
push = factory.create("push")
email.send("Welcome!", "alice@example.com")
sms.send("OTP: 123456", "+91-9876543210")
push.send("New message!", "device_token_xyz")
Q14: Observer Pattern
Example
from abc import ABC, abstractmethod
class Observer(ABC):
@abstractmethod
def update(self, event, data):
pass
class Subject:
"""Observable — observers ko notify karo"""
def __init__(self):
self._observers = []
def subscribe(self, observer):
self._observers.append(observer)
def unsubscribe(self, observer):
self._observers.remove(observer)
def notify(self, event, data=None):
for observer in self._observers:
observer.update(event, data)
class StockMarket(Subject):
def __init__(self):
super().__init__()
self._prices = {}
def update_price(self, symbol, price):
self._prices[symbol] = price
self.notify("price_update", {"symbol": symbol, "price": price})
class PriceAlertApp(Observer):
def __init__(self, threshold):
self.threshold = threshold
def update(self, event, data):
if event == "price_update" and data["price"] > self.threshold:
print(f"ALERT! {data['symbol']} crossed ₹{self.threshold}: ₹{data['price']}")
class PriceLogger(Observer):
def update(self, event, data):
print(f"LOG: {event} - {data}")
market = StockMarket()
market.subscribe(PriceAlertApp(threshold=1500))
market.subscribe(PriceLogger())
market.update_price("RELIANCE", 2800)
market.update_price("TCS", 3500)
Q15: __slots__ for Memory Optimization
Example
import sys
class Student:
def __init__(self, name, marks, roll_no):
self.name = name
self.marks = marks
self.roll_no = roll_no
class StudentOptimized:
__slots__ = ['name', 'marks', 'roll_no']
def __init__(self, name, marks, roll_no):
self.name = name
self.marks = marks
self.roll_no = roll_no
s1 = Student("Alice", 95, 101)
s2 = StudentOptimized("Alice", 95, 101)
print(f"Regular: {sys.getsizeof(s1.__dict__) + sys.getsizeof(s1)} bytes")
print(f"Slotted: {sys.getsizeof(s2)} bytes") # Smaller!
# 1 million instances comparison
import time
start = time.time()
regular = [Student(f"Student{i}", 80, i) for i in range(100000)]
print(f"Regular: {time.time()-start:.3f}s")
start = time.time()
optimized = [StudentOptimized(f"Student{i}", 80, i) for i in range(100000)]
print(f"Optimized: {time.time()-start:.3f}s") # Faster!
Q16: Metaclasses kya hain?
Example
# Class bhi ek object hai — class ka class = metaclass
print(type(int)) # <class 'type'>
print(type(str)) # <class 'type'>
print(type(list)) # <class 'type'>
print(type(type)) # <class 'type'> — type is its own metaclass!
# Custom metaclass — classes create hone pe kuch karo
class SingletonMeta(type):
_instances = {}
def __call__(cls, *args, **kwargs):
if cls not in cls._instances:
cls._instances[cls] = super().__call__(*args, **kwargs)
return cls._instances[cls]
class Config(metaclass=SingletonMeta):
def __init__(self, data=None):
self.data = data or {}
c1 = Config({"debug": True})
c2 = Config({"debug": False})
print(c1 is c2) # True — Singleton!
print(c1.data) # {'debug': True}
# Metaclass for validation
class ValidatedMeta(type):
def __new__(mcs, name, bases, namespace):
# Check all public methods have docstrings
for key, value in namespace.items():
if callable(value) and not key.startswith('_'):
if not value.__doc__:
raise TypeError(f"Method '{key}' in '{name}' must have a docstring!")
return super().__new__(mcs, name, bases, namespace)
class GoodClass(metaclass=ValidatedMeta):
def good_method(self):
"""This has a docstring."""
pass
# class BadClass(metaclass=ValidatedMeta):
# def bad_method(self): # No docstring — TypeError!
# pass
Q17: Mixin Classes kya hain?
Example
# Mixin — functionality add karo without full inheritance
class JSONMixin:
"""Any class mein JSON serialization add karo"""
def to_json(self):
import json
return json.dumps(self.__dict__, default=str)
@classmethod
def from_json(cls, json_str):
import json
data = json.loads(json_str)
obj = cls.__new__(cls)
obj.__dict__.update(data)
return obj
class LogMixin:
"""Logging capability add karo"""
def log(self, message):
import datetime
print(f"[{datetime.datetime.now().strftime('%H:%M:%S')}] [{self.__class__.__name__}] {message}")
class ValidateMixin:
"""Validation capability add karo"""
def validate(self):
for field, validator in getattr(self, '_validators', {}).items():
value = getattr(self, field, None)
if not validator(value):
raise ValueError(f"Validation failed for field '{field}': {value}")
return True
class User(JSONMixin, LogMixin, ValidateMixin):
_validators = {
"age": lambda x: x is not None and 0 < x < 150,
"email": lambda x: x and "@" in x,
}
def __init__(self, name, email, age):
self.name = name
self.email = email
self.age = age
user = User("Alice", "alice@example.com", 25)
print(user.to_json())
user.log("User created!")
user.validate() # Passes validation
Q18: Dataclasses kya hain?
Example
from dataclasses import dataclass, field, asdict, astuple
from typing import List
@dataclass
class Address:
street: str
city: str
pincode: str
@dataclass(order=True)
class Employee:
name: str
department: str
salary: float
skills: List[str] = field(default_factory=list)
address: Address = field(default=None)
# Comparison uses name (first field) for order=True
sort_index: float = field(init=False, repr=False)
def __post_init__(self):
self.sort_index = self.salary
def get_details(self):
return f"{self.name} ({self.department}): ₹{self.salary:,.0f}"
emp1 = Employee("Alice", "Engineering", 90000, ["Python", "SQL"])
emp2 = Employee("Bob", "Marketing", 75000, ["Excel", "Marketing"])
print(emp1)
print(emp1 > emp2) # True — salary comparison
print(sorted([emp2, emp1])) # Sorted by salary
# Convert to dict/tuple
print(asdict(emp1)) # Dict representation
Q19: Iterator Protocol in Classes
Example
class NumberRange:
"""Iterable class with separate iterator"""
def __init__(self, start, stop, step=1):
self.start = start
self.stop = stop
self.step = step
def __iter__(self):
return NumberRangeIterator(self.start, self.stop, self.step)
class NumberRangeIterator:
def __init__(self, start, stop, step):
self.current = start
self.stop = stop
self.step = step
def __iter__(self):
return self
def __next__(self):
if self.current >= self.stop:
raise StopIteration
value = self.current
self.current += self.step
return value
# Multiple independent iterations!
nums = NumberRange(1, 6)
print(list(nums)) # [1, 2, 3, 4, 5]
print(list(nums)) # [1, 2, 3, 4, 5] — fresh each time!
print(sum(nums)) # 15
# Two independent iterators
it1 = iter(nums)
it2 = iter(nums)
print(next(it1), next(it2)) # 1, 1 — independent!
Q20: Context Managers as Classes
python example
class DatabaseTransaction:
def __init__(self, db_name):
self.db_name = db_name
self.operations = []
self.connection = None
def __enter__(self):
print(f"Starting transaction on {self.db_name}")
self.connection = f"conn_{self.db_name}"
return self
def execute(self, query):
self.operations.append(query)
print(f" Queued: {query}")
def __exit__(self, exc_type, exc_val, exc_tb):
if exc_type is None:
print(f"Committing {len(self.operations)} operations")
else:
print(f"Rolling back due to: {exc_val}")
self.connection = None
return False # Don't suppress exceptions
with DatabaseTransaction("school_db") as txn:
txn.execute("INSERT INTO students VALUES (1, 'Alice')")
txn.execute("UPDATE grades SET score=95 WHERE student_id=1")
# Output:
# Starting transaction on school_db
# Queued: INSERT INTO students VALUES (1, 'Alice')
# Queued: UPDATE grades SET score=95 WHERE student_id=1
# Committing 2 operationsQ21: Protocol classes (Structural Subtyping)
python example
from typing import Protocol, runtime_checkable
# Protocol — duck typing with type hints!
@runtime_checkable
class Drawable(Protocol):
def draw(self) -> str: ...
def resize(self, factor: float) -> None: ...
class Circle:
def draw(self) -> str:
return "Drawing circle"
def resize(self, factor: float) -> None:
self.radius *= factor
def __init__(self):
self.radius = 1.0
class Square:
def draw(self) -> str:
return "Drawing square"
def resize(self, factor: float) -> None:
self.side *= factor
def __init__(self):
self.side = 1.0
# Protocol check
print(isinstance(Circle(), Drawable)) # True
print(isinstance(Square(), Drawable)) # True
def render(shape: Drawable):
print(shape.draw())
render(Circle()) # Works — implements protocol!
render(Square()) # Works — implements protocol!Q22: SOLID Principles in Python
python example
# S — Single Responsibility Principle
class OrderProcessor:
def process(self, order):
pass # Only processes orders
class EmailSender:
def send(self, email):
pass # Only sends emails
# O — Open/Closed Principle
class Discount:
def calculate(self, price, discount_type):
if discount_type == "student": return price * 0.9
if discount_type == "senior": return price * 0.85
# Adding new type requires modifying class — violates OCP!
# Better: Open for extension, closed for modification
from abc import ABC, abstractmethod
class DiscountStrategy(ABC):
@abstractmethod
def apply(self, price): pass
class StudentDiscount(DiscountStrategy):
def apply(self, price): return price * 0.9
class SeniorDiscount(DiscountStrategy):
def apply(self, price): return price * 0.85
# New discounts without modifying existing code!
class VIPDiscount(DiscountStrategy):
def apply(self, price): return price * 0.7
# L — Liskov Substitution Principle
class Bird:
def fly(self): return "flying"
class Penguin(Bird):
def fly(self):
raise NotImplementedError("Penguins can't fly!")
# VIOLATION! Penguin can't substitute Bird
# Better:
class BirdBase:
def breathe(self): return "breathing"
class FlyingBird(BirdBase):
def fly(self): return "flying"
class Penguin(BirdBase):
def swim(self): return "swimming"
# I — Interface Segregation Principle (many small interfaces > one big)
# D — Dependency Inversion (depend on abstractions, not concretions)Q23: Method Overloading vs Overriding
Example
# Python mein method overloading natively supported nahi hai
# But functools.singledispatch se simulate kar sakte hain
from functools import singledispatch
@singledispatch
def process(data):
return f"Unknown type: {type(data)}"
@process.register(int)
def _(data):
return f"Integer: {data * 2}"
@process.register(str)
def _(data):
return f"String: {data.upper()}"
@process.register(list)
def _(data):
return f"List: {sorted(data)}"
print(process(5)) # Integer: 10
print(process("hello")) # String: HELLO
print(process([3, 1, 2])) # List: [1, 2, 3]
# Method Overriding — child class overwrites parent method
class Animal:
def sound(self):
return "Generic animal sound"
class Dog(Animal):
def sound(self): # Override — same name, new implementation
return "Woof!"
class Cat(Animal):
def sound(self): # Override
return "Meow!"
animals = [Animal(), Dog(), Cat()]
for animal in animals:
print(animal.sound()) # Polymorphic — different outputs!
Quick Reference — Important OOP Concepts
| Concept | Keyword/Tool |
|---|---|
| Class creation | class ClassName: |
| Inheritance | class Child(Parent): |
| Multiple inheritance | class D(B, C): |
| Method override | Same method name in child |
| Abstract class | from abc import ABC, abstractmethod |
| Properties | @property, @x.setter |
| Class method | @classmethod |
| Static method | @staticmethod |
| Singleton | __new__, _instance |
| Context manager | __enter__, __exit__ |
| Magic methods | __init__, __str__, __add__ etc. |
OOP Interview Tip: Always explain concepts with real-world examples. Use code to demonstrate. Discuss pros/cons of each approach. Show understanding of when to use Inheritance vs Composition.
📤 Output Examples
Yahan par har important code example ka expected output diya gaya hai — interviews mein yeh predict karna aana chahiye! 🎯
Q2 Output: Class vs Object
Output
2024 Toyota Camry 2023 Honda Civic 2 False True
Q3 Output: Inheritance Types
Output
Quack! I can fly! I can swim! Donald is eating Engine started Driving... Charging battery
Q4 Output: super()
Output
Animal.__init__ called: Rex Dog.__init__ called: German Shepherd Rex is a Canine, breed: German Shepherd Hello from A + C + B + D (<class 'D'>, <class 'B'>, <class 'C'>, <class 'A'>, <class 'object'>)
Q5 Output: MRO
Output
(<class 'D'>, <class 'B'>, <class 'C'>, <class 'A'>, <class 'object'>) B ['D', 'B', 'C', 'A', 'object']
Q6 Output: Encapsulation
Output
Deposited ₹5000. New balance: ₹15000 Withdrew ₹2000. New balance: ₹13000 Balance: 13000 13000 savings
Q7 Output: Polymorphism & Duck Typing
Output
Circle: 78.54 Rectangle: 24.00 Circle: 28.27 Woof! Meow! Beep boop!
Q8 Output: Abstract Classes
Output
Error: Can't instantiate abstract class Vehicle with abstract methods fuel_type, start_engine Toyota Camry (Petrol) Tesla Model 3 (Electric) Vroooom! (Petrol engine started) Hmmmm... (Electric motor started)
Q9 Output: Property Decorator
Output
Celsius: 25 Fahrenheit: 77.0 Kelvin: 298.15 New Fahrenheit: 212.0 Error: Temperature -300°C is below absolute zero! Deleting temperature!
Q10 Output: Dunder Methods
Output
(3, 4) Vector(3, 4) (4, 6) (2, 2) (6, 8) (9, 12) 5.0 [3, 4] True 2
Q11 Output: Composition
Output
BMW: Engine (300hp) started, 4 wheels rotating
Q12 Output: Singleton Pattern
Output
True 2
Q13 Output: Factory Pattern
Output
EMAIL to alice@example.com: Welcome! SMS to +91-9876543210: OTP: 123456 PUSH to device_token_xyz: New message!
Q14 Output: Observer Pattern
Output
ALERT! RELIANCE crossed ₹1500: ₹2800
LOG: price_update - {'symbol': 'RELIANCE', 'price': 2800}
ALERT! TCS crossed ₹1500: ₹3500
LOG: price_update - {'symbol': 'TCS', 'price': 3500}Q16 Output: Metaclasses
Output
<class 'type'>
<class 'type'>
<class 'type'>
<class 'type'>
True
{'debug': True}Q19 Output: Iterator Protocol
Output
[1, 2, 3, 4, 5] [1, 2, 3, 4, 5] 15 1 1
Q20 Output: Context Manager
Output
Starting transaction on school_db Queued: INSERT INTO students VALUES (1, 'Alice') Queued: UPDATE grades SET score=95 WHERE student_id=1 Committing 2 operations
Q21 Output: Protocol Classes
Output
True True Drawing circle Drawing square
Q23 Output: Overloading vs Overriding
Output
Integer: 10 String: HELLO List: [1, 2, 3] Generic animal sound Woof! Meow!
⚠️ Common Mistakes
Interview mein OOP questions answer karte waqt yeh galtiyan sabse zyada hoti hain — avoid karo! 🚫
1. ❌ Mutable Default Arguments in __init__
python example
# WRONG ❌ — shared mutable default
class Student:
def __init__(self, name, grades=[]): # Same list shared by ALL instances!
self.name = name
self.grades = grades
# CORRECT ✅ — use None + create inside
class Student:
def __init__(self, name, grades=None):
self.name = name
self.grades = grades if grades is not None else []Hindi:[]ya{}ko default argument mein directly mat do — yeh sab instances share karenge!Noneuse karo aur andar nayi list banao.
2. ❌ super().__init__() Call Bhoolna
python example
# WRONG ❌ — parent __init__ call nahi kiya
class Dog(Animal):
def __init__(self, name, breed):
self.breed = breed # self.name set nahi hoga!
# CORRECT ✅
class Dog(Animal):
def __init__(self, name, breed):
super().__init__(name) # Parent ka __init__ call karo!
self.breed = breedHindi: Jab bhi child class mein__init__likhte ho,super().__init__()zaroor call karo — warna parent ke attributes initialize nahi honge.
3. ❌ Class Variable vs Instance Variable Confusion
python example
# WRONG ❌ — class variable mutable object
class Team:
members = [] # Shared by ALL instances!
def add_member(self, name):
self.members.append(name) # All teams get same list!
# CORRECT ✅
class Team:
def __init__(self):
self.members = [] # Each instance gets its own listHindi: Mutable objects (list, dict) ko class variable mat banao — har instance same object share karega. Hamesha __init__ mein assign karo.4. ❌ __repr__ vs __str__ Confuse Karna
python example
# __str__ → user-friendly display (print, str())
# __repr__ → developer-friendly, unambiguous (debugging, repr())
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self): # For developers
return f"Point({self.x}, {self.y})"
def __str__(self): # For users
return f"({self.x}, {self.y})"Hindi:__repr__pehle define karo — agar__str__nahi hai toh Python__repr__use karega.__str__optional hai,__repr__essential hai.
5. ❌ Circular Inheritance / Diamond Problem Ignore Karna
python example
# PROBLEM: Diamond problem mein __init__ multiple baar call hota hai
class A:
def __init__(self):
print("A init")
super().__init__()
class B(A):
def __init__(self):
print("B init")
super().__init__() # super() ensures correct MRO!
class C(A):
def __init__(self):
print("C init")
super().__init__()
class D(B, C):
def __init__(self):
print("D init")
super().__init__() # Calls B → C → A (each once!)
D() # D init → B init → C init → A init ✅Hindi: Multiple inheritance mein hameshasuper()use karo — direct parent call (e.g.,B.__init__(self)) mat karo warna same init multiple baar call hoga.
6. ❌ Private Variable ko Truly Private Samajhna
python example
class SecretVault:
def __init__(self):
self.__pin_code = "4567" # "Private" — but not truly!
s = SecretVault()
# print(s.__pin_code) # AttributeError
print(s._SecretVault__pin_code) # "4567" — Name mangling, not encryption!Hindi: Python mein koi bhi cheez truly private nahi hai!__prefix sirf name mangling karta hai (_ClassName__var). Yeh convention hai, security nahi.
7. ❌ Abstract Method mein Body Likhna aur Samajhna ki Woh Call Hoga
python example
from abc import ABC, abstractmethod
class Base(ABC):
@abstractmethod
def process(self):
# Yeh body child class automatically inherit NAHI karti!
print("Base processing")
class Child(Base):
def process(self):
super().process() # Explicitly call karna padta hai!
print("Child processing")Hindi: Abstract method mein body likh sakte ho, lekin child class ko explicitly super().process() call karna padega — automatically nahi milta.✅ Key Takeaways
Yeh points yaad rakhoge toh OOP interviews mein confident feel karoge! 💪
- ✅ 4 Pillars yaad rakho: Encapsulation, Abstraction, Inheritance, Polymorphism — har pillar ka ek real-world example tayyar rakho
- ✅ Composition over Inheritance: Jab "HAS-A" relationship ho toh composition use karo, "IS-A" ke liye inheritance — interviewer yeh difference zaroor poochhega
- ✅
super()hamesha use karo: Multiple inheritance meinsuper()MRO follow karta hai — direct parent call mat karo - ✅ MRO samjho: C3 Linearization — left to right, depth first, common ancestor last.
ClassName.__mro__se verify karo - ✅ Duck Typing Python ki taaqat hai: "If it quacks like a duck..." — Python type nahi check karta, method existence check karta hai
- ✅ Property decorators use karo: Direct attribute access ki jagah
@property— validation, computed values, read-only attributes ke liye - ✅ Dunder methods se classes powerful banao:
__repr__,__str__,__eq__,__lt__— built-in operations override kar sakte ho - ✅ Design Patterns jaano: Singleton, Factory, Observer — kam se kam yeh teen patterns explain kar paana chahiye with code
- ✅
__slots__performance ke liye: Lakhon objects banane ho toh__slots__memory aur speed dono improve karta hai - ✅ Dataclasses modern Python hai: Boilerplate reduce karo —
@dataclassautomatic__init__,__repr__,__eq__deta hai
❓ FAQ
Q: Python mein method overloading kaise karte hain? 🤔
A: Python mein traditional overloading (same name, different parameters) nahi hoti — last definition hi count hoti hai. Lekin functools.singledispatch ya default arguments se similar behavior achieve kar sakte ho. Interview mein bolo: *"Python uses duck typing and doesn't support traditional overloading, but we can use singledispatch or default parameters."*
Q: Abstract class aur Interface mein kya fark hai Python mein? 🧩
A: Python mein formal "interface" keyword nahi hai. ABC with all abstract methods = Interface jaisa behave karta hai. Abstract class mein kuch concrete methods bhi ho sakte hain. Python 3.8+ mein Protocol (typing module) structural subtyping deta hai — yeh closest hai to interfaces. Interview mein Protocol mention karna bonus point hai!
Q: __new__ aur __init__ mein kya fark hai? 🏗️
A: __new__ object CREATE karta hai (memory allocate), __init__ object INITIALIZE karta hai (values set). __new__ pehle call hota hai, __init__ baad mein. Singleton pattern mein __new__ override karte hain kyunki object creation control karna hai. Normal use mein sirf __init__ kaafi hai.
Q: Multiple Inheritance safe hai Python mein? ⚠️
A: Haan, lekin carefully use karo! Python ka C3 Linearization algorithm MRO determine karta hai. Problems tab aati hain jab: (1) diamond problem ignore karo, (2) super() consistently use na karo, (3) conflicting method names ho. Best practice: Mixins use karo — small, focused classes jo ek hi functionality add karti hain.
Q: Composition vs Inheritance kab use karo — simple rule? 🎯
A: Simple rule: "Is-A" = Inheritance, "Has-A" = Composition. Dog IS-A Animal → inheritance. Car HAS-A Engine → composition. Jab doubt ho — composition choose karo! Yeh zyada flexible, testable, aur maintainable hota hai. Interview mein "Favor Composition over Inheritance" principle mention karo.
Q: @classmethod vs @staticmethod mein kya fark hai? 🔄
A: @classmethod ko class (cls) milta hai as first argument — yeh class state access kar sakta hai, alternative constructors banaata hai. @staticmethod ko na self milta hai na cls — yeh utility function hai jo logically class se related hai but instance/class state use nahi karta. Interview example: Date.from_string("2026-01-15") = classmethod.
Q: Metaclass kab use karna chahiye? 🧠
A: 99% cases mein metaclass ki zaroorat NAHI padti! Use karo jab: (1) class creation time pe validation chahiye, (2) automatic registration chahiye, (3) framework/library bana rahe ho (Django, SQLAlchemy metaclasses use karte hain). Interview mein bolo: *"Metaclasses are powerful but rarely needed in application code — class decorators or __init_subclass__ are simpler alternatives."*
Q: Python mein true encapsulation possible hai? 🔒
A: Nahi! Python mein koi bhi attribute truly private nahi hota. __ prefix sirf name mangling karta hai (_ClassName__attr) — access still possible hai. Python "we are all consenting adults" philosophy follow karta hai. Interview mein bolo: *"Python relies on convention over enforcement — single underscore means 'internal', double underscore triggers name mangling but isn't true access control."*
🎯 Interview Tips
In tips ko follow karoge toh OOP round crack karna easy ho jaayega! 🚀
- 🗣️ Explain before coding: Pehle concept explain karo 2-3 lines mein, phir code likho. Interviewer ko dikhao ki tum samajhte ho "kyun" use karte hain, sirf "kaise" nahi.
- 🌍 Real-world analogy do: "Class is like a blueprint of a house, Object is the actual house built from it." Analogies se interviewer ko lagta hai ki tum deeply samajhte ho.
- 📊 Trade-offs discuss karo: Inheritance vs Composition, ABC vs Protocol,
__slots__vs normal — har approach ke pros aur cons batao. Yeh senior-level thinking dikhata hai.
- 🔗 SOLID principles link karo: Har answer mein agar relevant ho toh SOLID ka mention karo. Example: "This follows Open/Closed Principle because..." — instant bonus points!
- 💻 Code dry-run karo: Jab code likho toh output predict karo line by line. Interviewer output poochh sakta hai — especially MRO, super() chain, aur dunder methods ke liye.
- 🐍 Pythonic way batao: Python-specific features highlight karo — Duck typing, Protocols, dataclasses, property decorators. Generic OOP nahi, Python OOP dikhao.
- ⚡ Performance mention karo:
__slots__memory save karta hai,@lru_cachemethods optimize karta hai, Composition testing easy banata hai — performance-aware answers impress karte hain.
- 🧪 Testing angle cover karo: "This design is easily testable because we can mock the dependency" — testing mention karna shows production experience.
- ❌ Anti-patterns bhi batao: Sirf correct approach mat batao — galat approach bhi mention karo aur explain karo kyun galat hai. Example: "Deep inheritance hierarchies are fragile because..."
- 📝 Design Pattern naam lo: Agar tumhara solution kisi design pattern follow karta hai toh naam lo — "This is essentially the Strategy Pattern" — shows awareness of established patterns.
Final Tip 💡: OOP interview mein sabse important cheez hai — concepts ko connect karna. Sirf isolated definitions mat do. Dikhao ki Encapsulation + Abstraction milke data hiding achieve karta hai, Inheritance + Polymorphism milke extensible code banate hain. Connected thinking = Senior developer thinking! 🌟
Continue the lesson path
Study next in this module
01Interview PreparationPython Coding Interview QuestionsTop 25+ Python coding interview problems with solutions - arrays, strings, linked lists, sorting, searching, dynamic programming, and algorithmic challenges with Hindi explanations.02Interview PreparationPython Master CheatsheetComprehensive Python cheatsheet covering all important syntax, data structures, functions, OOP, libraries, and interview tips in one place with Hindi explanations.03Interview PreparationPython Interview Questions and AnswersTop 25+ Python interview questions and detailed answers covering Python basics, OOP, data structures, exceptions, and advanced topics with Hindi explanations for job interviews.04Advanced PythonPython Asynchronous Programming with asyncioDeep dive into Python async/await, asyncio event loop, coroutines, tasks, async generators, aiohttp, and real-world asynchronous patterns with Hindi explanations.