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 abstraction in Python — abstract base classes (ABC), @abstractmethod, interface design, abstract properties, concrete vs abstract classes, and real-world design patterns.
🧠 Real-World Analogy — Smartphone
You use your smartphone — making calls, taking photos, running apps. Do you know how the processor's exact circuit works inside? The battery's chemistry? The signal processing? No — and you don't need to. This is abstraction. This is Abstraction — hiding internal complexity and exposing only the necessary interface. In code: an Abstract Class defines a contract — "what to do" — without specifying "how to do it."
📦 The abc Module
python example
from abc import ABC, abstractmethod, abstractproperty| Tool | Purpose |
|---|---|
ABC | Base class to inherit from for abstract classes |
@abstractmethod | Marks a method as abstract (must be overridden) |
ABCMeta | Metaclass alternative to ABC |
✅ Example 1 — Shape Interface
Example
from abc import ABC, abstractmethod
import math
class Shape(ABC): # abstract class — cannot instantiate directly
"""Abstract interface for all geometric shapes."""
def __init__(self, color="white"):
self.color = color
@abstractmethod
def area(self) -> float: # MUST be overridden in subclasses
"""Return the area of the shape."""
...
@abstractmethod
def perimeter(self) -> float:
"""Return the perimeter of the shape."""
...
@abstractmethod
def draw(self) -> str:
"""Return ASCII representation."""
...
# Concrete method — shared by ALL shapes
def describe(self):
print(f"Shape: {self.__class__.__name__:12} | Color: {self.color:8} "
f"| Area: {self.area():8.2f} | Perimeter: {self.perimeter():.2f}")
# ── Concrete implementations ──────────────────────────────
class Circle(Shape):
def __init__(self, radius, color="white"):
super().__init__(color)
self.radius = radius
def area(self) -> float:
return math.pi * self.radius ** 2
def perimeter(self) -> float:
return 2 * math.pi * self.radius
def draw(self) -> str:
return " ○ "
class Rectangle(Shape):
def __init__(self, length, width, color="white"):
super().__init__(color)
self.length, self.width = length, width
def area(self) -> float:
return self.length * self.width
def perimeter(self) -> float:
return 2 * (self.length + self.width)
def draw(self) -> str:
return " ■ "
class Triangle(Shape):
def __init__(self, a, b, c, color="white"):
super().__init__(color)
if a + b <= c or a + c <= b or b + c <= a:
raise ValueError("Invalid triangle sides.")
self.a, self.b, self.c = a, b, c
def area(self) -> float:
s = (self.a + self.b + self.c) / 2
return math.sqrt(s*(s-self.a)*(s-self.b)*(s-self.c))
def perimeter(self) -> float:
return self.a + self.b + self.c
def draw(self) -> str:
return " △ "
# ── Cannot instantiate abstract class ────────────────────
try:
s = Shape()
except TypeError as e:
print(f"Error: {e}")
# ── Using concrete classes polymorphically ────────────────
shapes = [
Circle(7, "red"),
Rectangle(10, 5, "blue"),
Triangle(3, 4, 5, "green"),
Circle(3, "yellow"),
]
for shape in shapes:
shape.describe()
print(f" {shape.draw()}")
total_area = sum(s.area() for s in shapes)
print(f"\nTotal area: {total_area:.2f} sq units")
Output:
| Error | Can't instantiate abstract class Shape with abstract methods area, draw, perimeter |
| Shape | Circle | Color: red | Area: 153.94 | Perimeter: 43.98 |
| Shape | Rectangle | Color: blue | Area: 50.00 | Perimeter: 30.00 |
| Shape | Triangle | Color: green | Area: 6.00 | Perimeter: 12.00 |
| Shape | Circle | Color: yellow | Area: 28.27 | Perimeter: 18.85 |
| Total area | 238.21 sq units |
🗄️ Example 2 — Database Driver Abstraction
Example
from abc import ABC, abstractmethod
from typing import List, Dict, Any
class DatabaseDriver(ABC):
"""Abstract interface for database drivers."""
def __init__(self, host: str, port: int):
self.host = host
self.port = port
self._connected = False
@abstractmethod
def connect(self) -> bool: ...
@abstractmethod
def execute(self, query: str, params: tuple = ()) -> Any: ...
@abstractmethod
def fetch_all(self) -> List[Dict]: ...
@abstractmethod
def close(self) -> None: ...
# Concrete method in abstract class
def ping(self) -> bool:
print(f"[{self.__class__.__name__}] Pinging {self.host}:{self.port}...")
return self._connected
def __enter__(self):
self.connect()
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.close()
return False
class PostgreSQLDriver(DatabaseDriver):
def __init__(self, host, port=5432, database=""):
super().__init__(host, port)
self.database = database
self._cursor = None
def connect(self) -> bool:
print(f"🐘 PostgreSQL: Connecting to {self.host}:{self.port}/{self.database}...")
self._connected = True
print(" ✅ PostgreSQL connected.")
return True
def execute(self, query, params=()):
print(f" 📝 [PG] Executing: {query} | params={params}")
self._cursor = f"PG_CURSOR_{hash(query) % 1000}"
return self._cursor
def fetch_all(self) -> List[Dict]:
print(f" 📦 [PG] Fetching results from {self._cursor}...")
return [{"id": 1, "name": "Arjun"}, {"id": 2, "name": "Priya"}]
def close(self):
self._connected = False
print(" 🔒 PostgreSQL connection closed.")
class MySQLDriver(DatabaseDriver):
def __init__(self, host, port=3306, database=""):
super().__init__(host, port)
self.database = database
def connect(self) -> bool:
print(f"🐬 MySQL: Connecting to {self.host}:{self.port}/{self.database}...")
self._connected = True
print(" ✅ MySQL connected.")
return True
def execute(self, query, params=()):
print(f" 📝 [MySQL] Executing: {query} | params={params}")
return "MYSQL_RESULT_SET"
def fetch_all(self) -> List[Dict]:
print(" 📦 [MySQL] Fetching results...")
return [{"id": 10, "user": "Rahul"}, {"id": 20, "user": "Sneha"}]
def close(self):
self._connected = False
print(" 🔒 MySQL connection closed.")
def run_user_query(driver: DatabaseDriver):
"""Works with ANY database driver — abstraction in action!"""
with driver:
driver.ping()
driver.execute("SELECT * FROM users WHERE active = %s", (True,))
results = driver.fetch_all()
print(f" Got {len(results)} records: {results}\n")
print("=" * 55)
run_user_query(PostgreSQLDriver("db.wohotech.com", database="app_db"))
run_user_query(MySQLDriver("mysql.wohotech.com", database="users_db"))
Output:
| 🐘 PostgreSQL | Connecting to db.wohotech.com:5432/app_db... |
| [PostgreSQLDriver] Pinging db.wohotech.com | 5432... |
| 📝 [PG] Executing | SELECT * FROM users WHERE active = %s | params=(True,) |
| Got 2 records | [{'id': 1, 'name': 'Arjun'}, {'id': 2, 'name': 'Priya'}] |
| 🐬 MySQL | Connecting to mysql.wohotech.com:3306/users_db... |
| [MySQLDriver] Pinging mysql.wohotech.com | 3306... |
| 📝 [MySQL] Executing | SELECT * FROM users WHERE active = %s | params=(True,) |
| Got 2 records | [{'id': 10, 'user': 'Rahul'}, {'id': 20, 'user': 'Sneha'}] |
🔔 Example 3 — Notification System
Example
from abc import ABC, abstractmethod
class NotificationService(ABC):
@abstractmethod
def send(self, recipient: str, message: str) -> bool: ...
@abstractmethod
def validate_recipient(self, recipient: str) -> bool: ...
# Template method — defines the algorithm skeleton
def notify(self, recipient: str, message: str) -> bool:
print(f"\n[{self.__class__.__name__}] Sending to: {recipient}")
if not self.validate_recipient(recipient):
print(f" ❌ Invalid recipient format.")
return False
result = self.send(recipient, message)
if result:
print(f" ✅ Sent: '{message[:40]}...'")
return result
class EmailService(NotificationService):
def validate_recipient(self, email: str) -> bool:
return "@" in email and "." in email.split("@")[-1]
def send(self, email: str, message: str) -> bool:
print(f" 📧 Email → {email}")
return True
class SMSService(NotificationService):
def validate_recipient(self, phone: str) -> bool:
return phone.startswith("+") and len(phone) >= 10
def send(self, phone: str, message: str) -> bool:
print(f" 📱 SMS → {phone} | {len(message)} chars")
return True
class SlackService(NotificationService):
def validate_recipient(self, channel: str) -> bool:
return channel.startswith("#")
def send(self, channel: str, message: str) -> bool:
print(f" 💬 Slack → {channel}")
return True
# Polymorphic usage
services = [
EmailService(),
SMSService(),
SlackService(),
]
alerts = [
("arjun@wohotech.com", "Your order #1234 has been shipped!"),
("+919876543210", "OTP: 482910. Valid for 5 minutes."),
("#alerts", "🚨 Server CPU > 90% on prod-server-01"),
("bad-email", "This should fail validation"),
("bad-phone", "This should also fail"),
]
for (service, (recipient, msg)) in zip(services * 2, alerts):
service.notify(recipient, msg)
🔌 Abstract Properties
Example
from abc import ABC, abstractmethod
class Vehicle(ABC):
@property
@abstractmethod
def fuel_type(self) -> str: ... # abstract property
@property
@abstractmethod
def max_speed(self) -> int: ...
@abstractmethod
def start_engine(self) -> str: ...
def info(self):
return (f"{self.__class__.__name__}: "
f"Fuel={self.fuel_type}, MaxSpeed={self.max_speed} km/h")
class PetrolCar(Vehicle):
@property
def fuel_type(self) -> str: return "Petrol"
@property
def max_speed(self) -> int: return 200
def start_engine(self) -> str: return "Vroom! 🔥"
class ElectricCar(Vehicle):
@property
def fuel_type(self) -> str: return "Electric"
@property
def max_speed(self) -> int: return 250
def start_engine(self) -> str: return "Whirr... ⚡"
vehicles = [PetrolCar(), ElectricCar()]
for v in vehicles:
print(v.info())
print(f" Engine: {v.start_engine()}")
Output:
| PetrolCar | Fuel=Petrol, MaxSpeed=200 km/h |
| Engine | Vroom! 🔥 |
| ElectricCar | Fuel=Electric, MaxSpeed=250 km/h |
| Engine | Whirr... ⚡ |
🇮🇳 Hindi Explanation (हिंदी में समझें)
Abstraction kya hai? Abstraction means hiding complexity and showing only the essentials. Just as you drive a car without knowing engine mechanics — an abstract class does the same: it tells you "what" methods must exist, child classes decide "how".How to useABCand@abstractmethod? Importfrom abc import ABC, abstractmethod. Make your base class inherit fromABC. Decorate the methods that MUST be implemented in every subclass with@abstractmethod.
Why can't we directly instantiate an abstract class? Because an abstract class is incomplete — some methods only have a "name" but no implementation. If you instantiate it directly, those methods won't work. Python therefore throws TypeError to prevent incomplete objects.What is the difference between an abstract class and an interface? Python doesn't have a formal "interface" keyword (unlike Java). ABC serves as Python's interface. Abstract classes can also have concrete methods (partial implementation), whereas a pure interface only has method signatures.❓ Interview Questions
Q1: What is abstraction? How is it different from encapsulation?
Answer:
- Abstraction: Hiding *complexity* — showing only what's necessary (what an object does, not how). Implemented via abstract classes.
- Encapsulation: Hiding *data* — bundling data and methods, restricting direct access. Implemented via private/protected attributes.
"Abstraction is about design; encapsulation is about implementation."
Q2: What is an abstract class? Can you instantiate it?
Answer: An abstract class (inheriting ABC) contains at least one @abstractmethod. It cannot be instantiated directly — doing so raises TypeError. It serves as a contract that all concrete subclasses must fulfill.
Q3: What is the difference between @abstractmethod and raise NotImplementedError?
Answer:
@abstractmethod: Enforced at class creation time — Python raisesTypeErrorif a subclass doesn't implement it.raise NotImplementedError: Only raises if the method is actually called at runtime. No compile-time check.
@abstractmethod is strictly safer and preferred.
Q4: Can an abstract class have concrete methods?
Answer: Yes! An abstract class can have both abstract methods (must be overridden) and concrete methods (provide default implementations). This is the Template Method pattern — the abstract class defines the algorithm skeleton, subclasses fill in the blanks.
Q5: How do you create an abstract property?
Answer:
python example
from abc import ABC, abstractmethod
class Shape(ABC):
@property
@abstractmethod
def area(self) -> float: ...Both @property and @abstractmethod decorators are needed, in that order.
Q6: What is the difference between an abstract class and a protocol (typing.Protocol)?
Answer:
ABCrequires explicit inheritance:class Dog(Animal):typing.Protocolsupports structural subtyping (duck typing): any class with the required methods qualifies, no explicit inheritance needed — useful for type hints andmypy.
Q7: Can a subclass of an abstract class still be abstract?
Answer: Yes. If a subclass doesn't implement all abstract methods of its parent, it is itself abstract and also cannot be instantiated. You can build multi-level abstract hierarchies this way.
🧪 Practice Exercises
- Plugin System: Create an abstract
Pluginclass withname,version(abstract properties), andexecute(data)(abstract method). ImplementLogPlugin,FilterPlugin,TransformPlugin. - Report Generator: Abstract
ReportGeneratorwithfetch_data(),format_data(),render(). ImplementPDFReport,HTMLReport,CSVReport. - Authentication: Abstract
Authenticatorwithauthenticate(username, password). ImplementPasswordAuth,OTPAuth,BiometricAuth. - Serializer: Abstract
Serializerwithserialize(obj)anddeserialize(data). ImplementJSONSerializer,XMLSerializer,BinarySerializer. - Game Character: Abstract
GameCharacterwith abstract propertieshealth,attack_power,speedand abstract methodsattack(),defend(),move().
💡 Next Topic → Method Overriding: Deep dive into overriding in depth — super(), cooperative inheritance, and best practices.Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Abstraction 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 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 PythonObject Oriented ProgrammingMethod Overriding in PythonDeep dive into Python method overriding — redefining parent class methods in child classes, using super(), cooperative multiple inheritance, MRO interaction, and real-world design patterns.