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
🧠 Real-World Analogy — Superpowers
Think of a superhero suit — Tony Stark's Iron Man armor. The suit itself is an object. When Tony raises both hands, repulsors fire. When he raises one hand, a laser fires. Each specific gesture triggers a different ability. These special gestures are like Python's magic methods — special methods that automatically trigger when you use specific Python syntax or built-in functions. They start and end with double underscores (dunder = double underscore): __method__1️⃣ __init__ — Constructor / Initializer
python example
class Book:
def __init__(self, title, author, pages, price):
"""Called automatically when Book(...) is created."""
self.title = title
self.author = author
self.pages = pages
self.price = price
self._id = id(self) # unique Python object id
# We'll add more dunders below...Already covered in detail in constructors.mdx. Here we focus on how it interacts with other magic methods.2️⃣ __str__ and __repr__
Example
class Book:
def __init__(self, title, author, pages, price):
self.title = title
self.author = author
self.pages = pages
self.price = price
def __str__(self):
"""Human-readable: used by print(), str()"""
return f'"{self.title}" by {self.author} ({self.pages} pages) — ₹{self.price}'
def __repr__(self):
"""Developer-readable: used by repr(), REPL, debugging"""
return (f"Book(title={self.title!r}, author={self.author!r}, "
f"pages={self.pages}, price={self.price})")
book = Book("Python Mastery", "WoHoTech", 450, 599)
print(book) # calls __str__
print(str(book)) # calls __str__
print(repr(book)) # calls __repr__
# In a list, repr() is used:
library = [book, Book("Clean Code", "Robert Martin", 464, 799)]
print(library)
Output:
Example
"Python Mastery" by WoHoTech (450 pages) — ₹599
"Python Mastery" by WoHoTech (450 pages) — ₹599
Book(title='Python Mastery', author='WoHoTech', pages=450, price=599)
[Book(title='Python Mastery', ...), Book(title='Clean Code', ...)]
Rule of thumb:__repr__should return a string that, when passed toeval(), recreates the object.__str__is for end users.
3️⃣ __len__ — Length
Example
class Playlist:
def __init__(self, name):
self.name = name
self._songs = []
def add(self, song):
self._songs.append(song)
def __len__(self):
"""Called by len(playlist)"""
return len(self._songs)
def __str__(self):
return f"Playlist '{self.name}' [{len(self)} songs]"
def __bool__(self):
"""Called in boolean context — True if not empty"""
return len(self) > 0
p = Playlist("Chill Vibes")
print(f"Empty: {bool(p)}") # False
print(f"Len: {len(p)}") # 0
p.add("Tum Hi Ho")
p.add("Kal Ho Na Ho")
p.add("Raabta")
print(f"Len: {len(p)}") # 3
print(f"Empty: {bool(p)}") # True
print(p)
Output:
| Empty | False |
| Len | 0 |
| Len | 3 |
| Empty | True |
4️⃣ __add__, __sub__, __mul__ — Arithmetic
python example
class Fraction:
"""Rational number with full arithmetic support."""
from math import gcd as _gcd
def __init__(self, numerator, denominator=1):
if denominator == 0:
raise ZeroDivisionError("Denominator cannot be zero.")
from math import gcd
common = gcd(abs(numerator), abs(denominator))
sign = -1 if denominator < 0 else 1
self.num = sign * numerator // common
self.den = sign * denominator // common
def __add__(self, other): # self + other
if isinstance(other, int):
other = Fraction(other)
return Fraction(self.num * other.den + other.num * self.den,
self.den * other.den)
def __radd__(self, other): # other + self (e.g., 1 + Fraction)
return self.__add__(other)
def __sub__(self, other): # self - other
if isinstance(other, int):
other = Fraction(other)
return Fraction(self.num * other.den - other.num * self.den,
self.den * other.den)
def __mul__(self, other): # self * other
if isinstance(other, int):
other = Fraction(other)
return Fraction(self.num * other.num, self.den * other.den)
def __truediv__(self, other): # self / other
if isinstance(other, int):
other = Fraction(other)
return Fraction(self.num * other.den, self.den * other.num)
def __neg__(self): # -self
return Fraction(-self.num, self.den)
def __abs__(self): # abs(self)
return Fraction(abs(self.num), self.den)
def __float__(self): # float(self)
return self.num / self.den
def __str__(self):
if self.den == 1: return str(self.num)
return f"{self.num}/{self.den}"
def __repr__(self):
return f"Fraction({self.num}, {self.den})"
a = Fraction(1, 2) # 1/2
b = Fraction(1, 3) # 1/3
c = Fraction(3, 4) # 3/4
print(f"a = {a}")
print(f"b = {b}")
print(f"a + b = {a + b}") # 1/2 + 1/3 = 5/6
print(f"a - b = {a - b}") # 1/2 - 1/3 = 1/6
print(f"a * b = {a * b}") # 1/2 * 1/3 = 1/6
print(f"a / b = {a / b}") # 1/2 / 1/3 = 3/2
print(f"a + 1 = {a + 1}") # 1/2 + 1 = 3/2
print(f"1 + a = {1 + a}") # uses __radd__
print(f"-a = {-a}")
print(f"abs(-a) = {abs(-a)}")
print(f"float(a) = {float(a)}")
print(f"a + b + c = {a + b + c}") # chained additionOutput:
Example
a = 1/2
b = 1/3
a + b = 5/6
a - b = 1/6
a * b = 1/6
a / b = 3/2
a + 1 = 3/2
1 + a = 3/2
-a = -1/2
abs(-a) = 1/2
float(a) = 0.5
a + b + c = 19/12
5️⃣ __eq__, __lt__ — Comparison (Rich Comparison)
Example
from functools import total_ordering
@total_ordering # auto-generates <=, >, >= from __eq__ and __lt__
class Student:
def __init__(self, name, gpa):
self.name = name
self.gpa = gpa
def __eq__(self, other):
if not isinstance(other, Student):
return NotImplemented
return self.gpa == other.gpa
def __lt__(self, other):
if not isinstance(other, Student):
return NotImplemented
return self.gpa < other.gpa
def __hash__(self): # required when __eq__ is defined
return hash((self.name, self.gpa))
def __str__(self):
return f"{self.name} (GPA: {self.gpa:.2f})"
def __repr__(self):
return f"Student({self.name!r}, {self.gpa})"
students = [
Student("Arjun", 8.9),
Student("Priya", 9.4),
Student("Rahul", 7.5),
Student("Sneha", 9.4),
Student("Vikas", 8.1),
]
print("Unsorted:")
for s in students: print(f" {s}")
sorted_students = sorted(students, reverse=True)
print("\nSorted (high → low GPA):")
for s in sorted_students: print(f" {s}")
best = max(students)
print(f"\nTop student: {best}")
# All @total_ordering generated comparisons work:
a, b = students[0], students[1]
print(f"\n{a} == {b}: {a == b}")
print(f"{a} < {b}: {a < b}")
print(f"{a} > {b}: {a > b}")
print(f"{a} <= {b}: {a <= b}")
print(f"{a} >= {b}: {a >= b}")
# Use in set (requires __hash__)
top_students = {s for s in students if s.gpa >= 9.0}
print(f"\nTop students (GPA ≥ 9.0): {top_students}")
Output:
| Arjun (GPA | 8.90) |
| Priya (GPA | 9.40) |
| Rahul (GPA | 7.50) |
| Sneha (GPA | 9.40) |
| Vikas (GPA | 8.10) |
| Sorted (high | low GPA): |
| Priya (GPA | 9.40) |
| Sneha (GPA | 9.40) |
| Arjun (GPA | 8.90) |
| Vikas (GPA | 8.10) |
| Rahul (GPA | 7.50) |
| Top student | Priya (GPA: 9.40) |
| Arjun (GPA | 8.90) == Priya (GPA: 9.40): False |
| Arjun (GPA | 8.90) < Priya (GPA: 9.40): True |
| Arjun (GPA | 8.90) > Priya (GPA: 9.40): False |
| Arjun (GPA | 8.90) <= Priya (GPA: 9.40): True |
| Arjun (GPA | 8.90) >= Priya (GPA: 9.40): False |
| Top students (GPA ≥ 9.0) | {Student('Priya', 9.4), Student('Sneha', 9.4)} |
6️⃣ __getitem__, __setitem__, __delitem__ — Container Protocol
Example
class Matrix:
"""2D matrix with dict-style access."""
def __init__(self, rows, cols, default=0):
self.rows = rows
self.cols = cols
self._data = [[default] * cols for _ in range(rows)]
def _validate(self, row, col):
if not (0 <= row < self.rows and 0 <= col < self.cols):
raise IndexError(f"Index ({row},{col}) out of bounds "
f"for {self.rows}×{self.cols} matrix.")
def __getitem__(self, key):
"""m[row, col] or m[row]"""
if isinstance(key, tuple):
row, col = key
self._validate(row, col)
return self._data[row][col]
return self._data[key]
def __setitem__(self, key, value):
"""m[row, col] = value"""
if isinstance(key, tuple):
row, col = key
self._validate(row, col)
self._data[row][col] = value
else:
self._data[key] = value
def __delitem__(self, key):
"""del m[row, col] — resets to 0"""
if isinstance(key, tuple):
row, col = key
self._validate(row, col)
self._data[row][col] = 0
def __len__(self):
return self.rows * self.cols
def __str__(self):
lines = []
for row in self._data:
lines.append(" | " + " ".join(f"{v:4}" for v in row) + " |")
return "\n".join(lines)
m = Matrix(3, 3)
# Set values
m[0, 0] = 1; m[0, 1] = 2; m[0, 2] = 3
m[1, 0] = 4; m[1, 1] = 5; m[1, 2] = 6
m[2, 0] = 7; m[2, 1] = 8; m[2, 2] = 9
print("Matrix:")
print(m)
print(f"\nm[1, 1] = {m[1, 1]}") # 5
print(f"m[0] = {m[0]}") # [1, 2, 3]
del m[1, 1] # reset to 0
print(f"\nAfter del m[1,1]:")
print(m)
Output:
Example
Matrix:
| 1 2 3 |
| 4 5 6 |
| 7 8 9 |
m[1, 1] = 5
m[0] = [1, 2, 3]
After del m[1,1]:
| 1 2 3 |
| 4 0 6 |
| 7 8 9 |
7️⃣ __iter__ and __next__ — Iterator Protocol
Example
class NumberRange:
"""Custom range object — iterable and iterator."""
def __init__(self, start, stop, step=1):
self.start = start
self.stop = stop
self.step = step
def __iter__(self):
"""Return iterator object (self is its own iterator)."""
self._current = self.start
return self
def __next__(self):
"""Return next value, or raise StopIteration."""
if (self.step > 0 and self._current >= self.stop) or \
(self.step < 0 and self._current <= self.stop):
raise StopIteration
value = self._current
self._current += self.step
return value
def __len__(self):
if self.step > 0:
return max(0, (self.stop - self.start + self.step - 1) // self.step)
return max(0, (self.start - self.stop - self.step - 1) // (-self.step))
def __contains__(self, item):
if self.step > 0:
return self.start <= item < self.stop and (item - self.start) % self.step == 0
return self.stop < item <= self.start and (self.start - item) % (-self.step) == 0
def __repr__(self):
return f"NumberRange({self.start}, {self.stop}, {self.step})"
# for loop
evens = NumberRange(0, 20, 2)
print("Even numbers:", list(evens))
# in operator
print(f"10 in evens: {10 in evens}") # True
print(f"7 in evens: {7 in evens}") # False
# len
print(f"len(evens): {len(evens)}") # 10
# Countdown
countdown = NumberRange(5, 0, -1)
print("Countdown:", end=" ")
for n in countdown:
print(n, end=" ")
print("🚀")
# list comprehension
squares = [x**2 for x in NumberRange(1, 6)]
print(f"Squares: {squares}")
Output:
| Even numbers | [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] |
| 10 in evens | True |
| 7 in evens | False |
| len(evens) | 10 |
| Countdown | 5 4 3 2 1 🚀 |
| Squares | [1, 4, 9, 16, 25] |
8️⃣ __call__ — Make Objects Callable
Example
class Multiplier:
"""A callable object — works like a function!"""
def __init__(self, factor):
self.factor = factor
def __call__(self, value):
return value * self.factor
def __repr__(self):
return f"Multiplier(×{self.factor})"
double = Multiplier(2)
triple = Multiplier(3)
percent = Multiplier(0.01)
print(double(5)) # 10
print(triple(7)) # 21
print(percent(1500)) # 15.0
# Use in map/filter — just like a function!
numbers = [1, 2, 3, 4, 5]
print(list(map(double, numbers))) # [2, 4, 6, 8, 10]
# More practical: Memoized function decorator
class Memoize:
def __init__(self, func):
self.func = func
self.cache = {}
def __call__(self, *args):
if args not in self.cache:
self.cache[args] = self.func(*args)
return self.cache[args]
def __repr__(self):
return f"Memoize({self.func.__name__}, {len(self.cache)} cached)"
@Memoize
def fibonacci(n):
if n < 2: return n
return fibonacci(n-1) + fibonacci(n-2)
print(fibonacci(10)) # 55
print(fibonacci(30)) # 832040
print(fibonacci(50)) # computed instantly due to memoization
print(fibonacci) # Memoize(fibonacci, ... cached)
9️⃣ __enter__ and __exit__ — Context Manager
python example
class DatabaseTransaction:
"""Context manager for database transactions."""
def __init__(self, db_name):
self.db_name = db_name
self._operations = []
self._committed = False
def __enter__(self):
print(f"🔓 BEGIN TRANSACTION on '{self.db_name}'")
return self # returned as 'as' variable
def execute(self, sql):
self._operations.append(sql)
print(f" 📝 Queued: {sql}")
def __exit__(self, exc_type, exc_val, exc_tb):
if exc_type is None:
# No exception — commit
print(f" ✅ COMMIT: {len(self._operations)} operations committed.")
self._committed = True
else:
# Exception occurred — rollback
print(f" ❌ ROLLBACK: {exc_type.__name__}: {exc_val}")
self._operations.clear()
print(f"🔒 END TRANSACTION on '{self.db_name}'")
return True # suppress exception (return False to propagate)
# Successful transaction
with DatabaseTransaction("users_db") as tx:
tx.execute("INSERT INTO users (name) VALUES ('Arjun')")
tx.execute("UPDATE balance SET amount = 5000 WHERE user_id = 1")
print()
# Failed transaction — auto rollback
with DatabaseTransaction("orders_db") as tx:
tx.execute("INSERT INTO orders VALUES (101, 'Laptop')")
raise ValueError("Payment gateway timeout!")
tx.execute("UPDATE inventory SET qty = qty - 1") # never reached
print("\nProgram continues after handled exception ✅")Output:
| 📝 Queued | INSERT INTO users (name) VALUES ('Arjun') |
| 📝 Queued | UPDATE balance SET amount = 5000 WHERE user_id = 1 |
| ✅ COMMIT | 2 operations committed. |
| 📝 Queued | INSERT INTO orders VALUES (101, 'Laptop') |
| ❌ ROLLBACK | ValueError: Payment gateway timeout! |
🏆 Complete Example — ShoppingCart
Example
from functools import total_ordering
@total_ordering
class CartItem:
def __init__(self, name, price, qty=1):
self.name = name
self.price = price
self.qty = qty
@property
def total(self): return self.price * self.qty
def __eq__(self, other): return self.total == other.total
def __lt__(self, other): return self.total < other.total
def __str__(self): return f"{self.name:25s} ₹{self.price:>7.2f} × {self.qty:>3} = ₹{self.total:>9.2f}"
def __repr__(self): return f"CartItem({self.name!r}, {self.price}, {self.qty})"
class ShoppingCart:
def __init__(self, customer):
self.customer = customer
self._items = []
def __len__(self): # len(cart)
return len(self._items)
def __bool__(self): # if cart:
return len(self) > 0
def __iter__(self): # for item in cart:
return iter(self._items)
def __getitem__(self, idx): # cart[0]
return self._items[idx]
def __contains__(self, name): # "item" in cart
return any(i.name == name for i in self._items)
def __add__(self, other): # cart1 + cart2 (merge carts)
merged = ShoppingCart(f"{self.customer}+{other.customer}")
merged._items = self._items + other._items
return merged
def __str__(self):
if not self:
return f"🛒 {self.customer}'s cart is empty."
lines = [f"🛒 {self.customer}'s Cart ({len(self)} items)"]
lines.append("─" * 55)
for item in sorted(self._items, reverse=True):
lines.append(f" {item}")
lines.append("─" * 55)
lines.append(f" {'TOTAL':25s} {'':>22} ₹{self.subtotal:>9.2f}")
return "\n".join(lines)
@property
def subtotal(self):
return sum(i.total for i in self._items)
def add(self, item):
self._items.append(item)
def remove(self, name):
self._items = [i for i in self._items if i.name != name]
# ── Build a cart ────────────────────────────────────────
cart = ShoppingCart("Arjun Sharma")
cart.add(CartItem("Python Mastery Book", 599, 2))
cart.add(CartItem("USB-C Hub", 1299, 1))
cart.add(CartItem("Laptop Stand", 1499, 1))
cart.add(CartItem("Mechanical Keyboard", 3499, 1))
cart.add(CartItem("Mouse Pad XL", 399, 1))
print(cart)
print(f"\n'USB-C Hub' in cart: {'USB-C Hub' in cart}")
print(f"cart[0]: {cart[0]}")
print(f"Most expensive: {max(cart)}")
# Merge two carts
cart2 = ShoppingCart("Priya")
cart2.add(CartItem("Python Stickers Pack", 99, 5))
cart2.add(CartItem("Notepad", 149, 3))
merged = cart + cart2
print(f"\nMerged cart has {len(merged)} items, subtotal ₹{merged.subtotal:,.2f}")
Output:
| 'USB-C Hub' in cart | True |
| cart[0] | Python Mastery Book ₹ 599.00 × 2 = ₹ 1198.00 |
| Most expensive | Mechanical Keyboard ₹ 3499.00 × 1 = ₹ 3499.00 |
🇮🇳 Hindi Explanation (हिंदी में समझें)
Magic methods kya hain? Magic methods (dunder methods) are special methods that Python calls automatically when you perform specific operations — like using+, callinglen(), or running aforloop. They let you define how your objects behave with Python's built-in syntax.
What is the difference between__str__and__repr__?__str__provides user-readable output (what shows up in print).__repr__provides developer-oriented technical output — ideally a string that can recreate the object viaeval().
Why do we use__iter__and__next__? By defining these, you can use your class objects inforloops,list(),sum()and everywhere else.__iter__returns the iterator,__next__yields one value at a time, and raisesStopIterationat the end.
@total_orderingkya karta hai? If you only define__eq__and__lt__,@total_orderingautomatically generates<=,>,>=for you. Very convenient!
❓ Interview Questions
Q1: What are dunder/magic methods? Give 5 examples.
Answer: Magic methods are special methods with double underscores (__method__) that Python calls automatically for specific operations:
__init__: object construction__str__: string representation (print())__len__: length (len())__add__: addition (+)__iter__: iteration (forloop)
Q2: What is the difference between __str__ and __repr__?
Answer:
__str__: User-friendly string — used byprint(),str(). Should be readable.__repr__: Developer-facing, unambiguous string — used byrepr(), REPL, list display. Should ideally recreate the object viaeval().
If __str__ is not defined, Python falls back to __repr__.
Q3: When do you need to define __hash__ along with __eq__?
Answer: When you define __eq__, Python automatically sets __hash__ = None, making objects unhashable (can't be used in sets or as dict keys). To allow hashing, explicitly define __hash__. A good rule: hash() should be consistent with equality: a == b ⟹ hash(a) == hash(b).
Q4: What does __call__ do? Give a use case.
Answer: __call__ makes an instance callable like a function (obj(args)). Use cases: callable objects with state (memoization, counters), function decorators as classes, strategy pattern objects.
Q5: Explain the context manager protocol (__enter__, __exit__).
Answer:
__enter__: Called whenwithblock starts. Returns the object bound toas.__exit__(exc_type, exc_val, exc_tb): Called when block exits (normally or via exception). ReturnTrueto suppress the exception;False/Noneto propagate it.
Use cases: file handling, database transactions, lock management.
Q6: What is @total_ordering?
Answer: A class decorator from functools. If you define __eq__ and one of (__lt__, __le__, __gt__, __ge__), @total_ordering automatically generates the remaining comparison methods. Saves writing 4 extra methods.
Q7: What is __contains__? How does it relate to __iter__?
Answer: __contains__ is called when you use item in obj. If not defined, Python falls back to iterating with __iter__ and checking each element. Define __contains__ for O(1) membership testing (e.g., hash-based lookup) instead of O(n) linear scan.
Q8: What happens if __iter__ returns self vs a new iterator?
Answer:
- Returns
self: The object is both iterable AND iterator. Can only be iterated once (callingforloop again restarts only if__iter__resets state). - Returns new object: Iterable produces fresh iterators each time — multiple independent loops work correctly.
Best practice for containers: __iter__ returns iter(self._data) (fresh iterator each call).
📊 Complete Magic Methods Reference
| Category | Method | Triggered by |
|---|---|---|
| Construction | __new__, __init__, __del__ | Class(), garbage collection |
| Representation | __str__, __repr__, __format__ | print(), repr(), f-strings |
| Numeric | __int__, __float__, __bool__, __abs__, __neg__ | int(), float(), bool(), abs(), unary - |
| Arithmetic | __add__, __sub__, __mul__, __truediv__, __mod__, __pow__ | +, -, *, /, %, ** |
| Comparison | __eq__, __ne__, __lt__, __le__, __gt__, __ge__ | ==, !=, <, <=, >, >= |
| Container | __len__, __getitem__, __setitem__, __delitem__, __contains__ | len(), obj[k], obj[k]=v, del obj[k], in |
| Iteration | __iter__, __next__ | for, iter(), next() |
| Context | __enter__, __exit__ | with statement |
| Callable | __call__ | obj(args) |
| Attribute | __getattr__, __setattr__, __delattr__ | obj.x, obj.x=v, del obj.x |
| Hashing | __hash__ | hash(), dict keys, sets |
🧪 Practice Exercises
- Money Class: Implement
Money(amount, currency)with__add__,__sub__,__mul__,__eq__,__lt__,__str__,__repr__. RaiseTypeErrorfor cross-currency ops. - Inventory System: Build
Inventorywith__getitem__(by name),__setitem__,__delitem__,__contains__,__iter__,__len__,__str__. - Polynomial: Create a
Polynomialclass with coefficient list. Implement__add__,__mul__,__call__(evaluate at x),__str__(format nicely like "3x² + 2x + 1"). - Lazy File Reader: Implement
LazyFileReader(filename)as an iterator —__iter__opens the file,__next__yields one line at a time, closes onStopIteration. - Rate Limiter (callable): Create a
RateLimiter(max_calls, period)callable class that allows at mostmax_callsinvocations perperiodseconds, raisingRuntimeErrorotherwise.
🎉 Congratulations! You've completed the entire OOP section of the Python Master Course. What's Next? → File I/O, Exception Handling, Decorators, Generators, and Python Standard Library!
Continue the lesson path
Study next in this module
01Object Oriented ProgrammingInheritance in PythonMaster Python inheritance — single, multiple, multilevel, and hierarchical inheritance, MRO (Method Resolution Order), super(), mixins, and real-world class hierarchies.02Object 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.03Object Oriented ProgrammingEncapsulation in PythonLearn encapsulation in Python — public, protected, and private attributes, name mangling, getter/setter methods, the @property decorator, and data validation patterns.04Object Oriented ProgrammingPolymorphism in PythonUnderstand polymorphism in Python — method overriding, duck typing, operator overloading, runtime polymorphism, and how to write flexible, reusable code with real-world examples.