Python Notes
HubHistory of Python - Complete Guide 2026Python Applications - Complete Guide 2026Python Features - Complete Guide 2026What is Python? - Complete Guide 2026Why Learn Python? - Complete Guide 2026Your First Python Program – Hello World & Beyond 2026How to Install Python on Windows, Mac & Linux – Complete Guide 2026Install VS Code for Python – Complete Setup Guide with Extensions 2026Python Environment Setup – Virtual Environments, pip & Project Structure 2026Python IDLE – Complete Guide for Beginners 2026Python CommentsPython Data TypesPython Input and OutputPython OperatorsPython SyntaxPython Strings BasicsPython Type CastingPython VariablesBreak, Continue and Pass in PythonElif Statement in PythonFor Loop in PythonIf-Else Statement in PythonIf Statement in PythonNested If in PythonPattern Programs in PythonWhile Loop in PythonDecorators in PythonFunction Arguments in PythonFunctions Basics in PythonGenerators in PythonLambda Functions in PythonRecursive Functions in PythonReturn Statement in PythonScope of Variables in PythonAbstraction in PythonClasses and Objects in PythonConstructors in PythonEncapsulation in PythonInheritance in PythonMagic Methods (Dunder Methods) in PythonMethod Overriding in PythonPolymorphism in PythonPython Comprehensions – List, Dict, Set & GeneratorPython Dictionaries – Key-Value StorePython Dictionary Methods – Complete ReferencePython List Methods – All Built-in MethodsPython Lists – Complete GuidePython Set Methods – Complete ReferencePython Sets – Unordered Unique CollectionsPython Tuples – Immutable SequencesPython Asynchronous Programming with asyncioPython Context ManagersAdvanced Python DecoratorsAdvanced Python GeneratorsPython Iterators - Advanced GuidePython Memory ManagementPython MultiprocessingPython MultithreadingCRUD Operations in Python DatabasesMySQL with Python (mysql-connector-python)ORM Introduction with SQLAlchemyPostgreSQL with Python (psycopg2)SQLite3 with PythonIntroduction to DjangoDjango Models and ORMDjango REST API with DRFDjango ViewsIntroduction to FlaskFlask RoutingFlask Templates with Jinja2Email Automation with PythonPDF Automation with PythonSelenium Web Automation with PythonTask Scheduler with PythonWeb Scraping with PythonData Analysis with PythonData Cleaning with PythonData Visualization ProjectData Visualization with MatplotlibNumPy IntroductionPandas IntroductionStatistical Visualization with SeabornClassification AlgorithmsClustering AlgorithmsIntroduction to Machine LearningMachine Learning Project: Churn PredictionModel Evaluation and SelectionRegression AlgorithmsSave pipeline (includes preprocessing + model)AI Assistant ProjectCalculator ProjectChatbot ProjectExpense Tracker ProjectFace Detection ProjectPassword Generator ProjectWeather App ProjectPython Coding Interview QuestionsPython OOP Interview Questions and AnswersPython Master CheatsheetPython Interview Questions and AnswersPython Best PracticesCommon Python Errors and SolutionsPython Debugging TechniquesPython Learning Resources
Deep dive into Python constructors — __init__, __new__, default parameters, class method constructors, constructor chaining, and destructor __del__ with real-world examples.
🧠 Real-World Analogy — Hotel Check-In
When you check into a hotel, the receptionist has you fill out a form — name, ID, room preference. Filling out this form is the constructor. Until the form is filled, you don't get a room key. Similarly, until the constructor runs, the object doesn't have its initial data. A constructor is a special method that runs automatically as soon as an object is created and sets its initial state.
📐 ASCII Diagram — Object Lifecycle
Example
Car("Toyota", "Camry", 2022)
│
▼
┌───────────────────┐
│ __new__(cls) │ ← Step 1: Python allocates memory
│ creates empty │ returns a bare object
│ object │
└────────┬──────────┘
│
▼
┌───────────────────┐
│ __init__(self, │ ← Step 2: Your code fills in
│ make, model, │ attributes / state
│ year) │
└────────┬──────────┘
│
▼
Object is ready!
car1 = <Car object>
│
│ ... program runs ...
│
▼
┌───────────────────┐
│ __del__(self) │ ← Step 3: Cleanup when object
│ (destructor) │ reference count = 0
└───────────────────┘
✅ Example 1 — Basic __init__
python example
class Person:
def __init__(self, name, age, city="Unknown"):
self.name = name
self.age = age
self.city = city
print(f"✅ Person created: {self.name}")
def greet(self):
print(f"Hello! I'm {self.name}, {self.age} years old from {self.city}.")
# Creating objects
p1 = Person("Arjun", 25, "Delhi")
p2 = Person("Priya", 22, "Mumbai")
p3 = Person("Ravi", 30) # city defaults to "Unknown"
p1.greet()
p2.greet()
p3.greet()Output:
| ✅ Person created | Arjun |
| ✅ Person created | Priya |
| ✅ Person created | Ravi |
⚙️ Default Arguments in Constructor
python example
class Rectangle:
def __init__(self, length=1, width=1, color="white"):
self.length = length
self.width = width
self.color = color
def area(self):
return self.length * self.width
def perimeter(self):
return 2 * (self.length + self.width)
def describe(self):
print(f"{self.color.capitalize()} rectangle: {self.length}x{self.width} "
f"| Area={self.area()} | Perimeter={self.perimeter()}")
r1 = Rectangle() # all defaults
r2 = Rectangle(5, 3) # positional
r3 = Rectangle(10, 6, "blue") # positional
r4 = Rectangle(color="red", length=8, width=4) # keyword
r1.describe()
r2.describe()
r3.describe()
r4.describe()Output:
| White rectangle | 1x1 | Area=1 | Perimeter=4 |
| White rectangle | 5x3 | Area=15 | Perimeter=16 |
| Blue rectangle | 10x6 | Area=60 | Perimeter=32 |
| Red rectangle | 8x4 | Area=32 | Perimeter=24 |
🏭 Alternate Constructors with @classmethod
In Python, constructor overloading (same name, different signature) isn't directly possible like in Java/C++. But we can create factory methods using @classmethod — providing alternative ways to create objects.Example
class Date:
def __init__(self, day, month, year):
self.day = day
self.month = month
self.year = year
@classmethod
def from_string(cls, date_string):
"""Alternate constructor: 'DD-MM-YYYY'"""
day, month, year = map(int, date_string.split("-"))
return cls(day, month, year)
@classmethod
def from_iso(cls, iso_string):
"""Alternate constructor: 'YYYY-MM-DD'"""
year, month, day = map(int, iso_string.split("-"))
return cls(day, month, year)
@classmethod
def today(cls):
"""Alternate constructor from system date."""
import datetime
d = datetime.date.today()
return cls(d.day, d.month, d.year)
def __str__(self):
months = ["Jan","Feb","Mar","Apr","May","Jun",
"Jul","Aug","Sep","Oct","Nov","Dec"]
return f"{self.day} {months[self.month-1]} {self.year}"
# Four different ways to create a Date
d1 = Date(12, 6, 2026) # standard constructor
d2 = Date.from_string("15-08-1947") # from DD-MM-YYYY string
d3 = Date.from_iso("2026-01-26") # from ISO format
d4 = Date.today() # from system clock
print(d1) # 12 Jun 2026
print(d2) # 15 Aug 1947
print(d3) # 26 Jan 2026
print(d4) # today's date
Output:
Example
12 Jun 2026
15 Aug 1947
26 Jan 2026
12 Jun 2026
🏗️ Constructor Chaining with super()
Example
class Animal:
def __init__(self, name, sound):
self.name = name
self.sound = sound
print(f" [Animal.__init__] name={name}, sound={sound}")
class Dog(Animal):
def __init__(self, name, breed):
super().__init__(name, "Woof") # ← call parent constructor
self.breed = breed
print(f" [Dog.__init__] breed={breed}")
class GoldenRetriever(Dog):
def __init__(self, name, color="Golden"):
super().__init__(name, "Golden Retriever") # ← call Dog constructor
self.color = color
print(f" [GoldenRetriever.__init__] color={color}")
print("Creating GoldenRetriever...")
buddy = GoldenRetriever("Buddy")
print(f"\nbuddy.name={buddy.name}, buddy.sound={buddy.sound}, "
f"buddy.breed={buddy.breed}, buddy.color={buddy.color}")
Output:
Example
Creating GoldenRetriever...
[Animal.__init__] name=Buddy, sound=Woof
[Dog.__init__] breed=Golden Retriever
[GoldenRetriever.__init__] color=Golden
buddy.name=Buddy, buddy.sound=Woof, buddy.breed=Golden Retriever, buddy.color=Golden
🔒 Singleton Pattern with __new__
The Singleton pattern ensures that only one object of a class can ever exist — useful for system-wide configuration or database connections.
Example
class DatabaseConnection:
_instance = None # class-level singleton store
def __new__(cls, *args, **kwargs):
if cls._instance is None:
print("⚙️ Creating new database connection...")
cls._instance = super().__new__(cls)
else:
print("♻️ Returning existing connection.")
return cls._instance
def __init__(self, host="localhost", port=5432):
# Guard: only initialize once
if not hasattr(self, "_initialized"):
self.host = host
self.port = port
self._initialized = True
print(f" Connected to {host}:{port}")
def query(self, sql):
return f"[{self.host}:{self.port}] Result of: {sql}"
db1 = DatabaseConnection("db.wohotech.com", 5432)
db2 = DatabaseConnection("other.server.com", 3306) # ignored — reuses db1
db3 = DatabaseConnection()
print(db1 is db2) # True — same object!
print(db1 is db3) # True
print(db2.host) # db.wohotech.com (NOT other.server.com)
print(db1.query("SELECT * FROM users"))
Output:
Example
⚙️ Creating new database connection...
Connected to db.wohotech.com:5432
♻️ Returning existing connection.
♻️ Returning existing connection.
True
True
db.wohotech.com
[db.wohotech.com:5432] Result of: SELECT * FROM users
🗑️ Destructor __del__
python example
class FileHandler:
def __init__(self, filename):
self.filename = filename
self.file = open(filename, "w")
print(f"📂 Opened file: {filename}")
def write(self, text):
self.file.write(text + "\n")
def __del__(self):
if not self.file.closed:
self.file.close()
print(f"🗑️ FileHandler for '{self.filename}' destroyed, file closed.")
handler = FileHandler("temp_output.txt")
handler.write("Hello, World!")
handler.write("Python OOP is awesome!")
del handler # triggers __del__
print("Program continues...")Output:
Example
📂 Opened file: temp_output.txt
🗑️ FileHandler for 'temp_output.txt' destroyed, file closed.
Program continues...
⚠️ Best Practice: Preferwithstatement (context managers) over__del__for resource cleanup.__del__timing is not guaranteed.
🧪 Example — Student with Validation
Example
class Student:
_count = 0
def __init__(self, name, roll_no, marks):
# Input validation in constructor
if not name or not isinstance(name, str):
raise ValueError("Name must be a non-empty string.")
if not (1 <= roll_no <= 9999):
raise ValueError("Roll number must be between 1 and 9999.")
if not (0 <= marks <= 100):
raise ValueError("Marks must be between 0 and 100.")
self.name = name.strip().title()
self.roll_no = roll_no
self.marks = marks
Student._count += 1
self.student_id = f"STU{Student._count:04d}"
@classmethod
def from_dict(cls, data: dict):
return cls(data["name"], data["roll_no"], data["marks"])
@classmethod
def count(cls):
return cls._count
def grade(self):
if self.marks >= 90: return "A+"
if self.marks >= 80: return "A"
if self.marks >= 70: return "B"
if self.marks >= 60: return "C"
if self.marks >= 40: return "D"
return "F"
def __str__(self):
return (f"[{self.student_id}] {self.name:20s} "
f"Roll: {self.roll_no:04d} Marks: {self.marks} Grade: {self.grade()}")
students_data = [
{"name": "arjun sharma", "roll_no": 1, "marks": 92},
{"name": "priya mehta", "roll_no": 2, "marks": 85},
{"name": "rahul verma", "roll_no": 3, "marks": 73},
{"name": "sneha kapoor", "roll_no": 4, "marks": 61},
{"name": "vikas singh", "roll_no": 5, "marks": 38},
]
students = [Student.from_dict(d) for d in students_data]
print("── Student Report ──────────────────────────────")
for s in students:
print(s)
print(f"\nTotal students enrolled: {Student.count()}")
# Validation test
try:
bad = Student("", 6, 50)
except ValueError as e:
print(f"\n❌ Validation Error: {e}")
Output:
| [STU0001] Arjun Sharma Roll | 0001 Marks: 92 Grade: A+ |
| [STU0002] Priya Mehta Roll | 0002 Marks: 85 Grade: A |
| [STU0003] Rahul Verma Roll | 0003 Marks: 73 Grade: B |
| [STU0004] Sneha Kapoor Roll | 0004 Marks: 61 Grade: C |
| [STU0005] Vikas Singh Roll | 0005 Marks: 38 Grade: F |
| Total students enrolled | 5 |
| ❌ Validation Error | Name must be a non-empty string. |
🇮🇳 Hindi Explanation (हिंदी में समझें)
What does a constructor do? A constructor is a special method that is automatically called as soon as an object is created. Its job is to set the object's initial state — assigning default or given values to attributes.
What is the difference between__init__and__new__?__new__allocates memory (creates a new object), while__init__initializes that object (fills in values). We usually only write__init__.
Why do we use alternate constructors? Because Python doesn't have constructor overloading. If you want to create objects from different formats (string, dict, date), you create named constructors using @classmethod.Destructor__del__kab call hota hai? When an object's reference count reaches zero, Python automatically calls__del__. But its exact timing isn't guaranteed, so usewithstatements (context managers) for resource cleanup instead.
❓ Interview Questions
Q1: What is the difference between __init__ and __new__?
Answer:
__new__is called first and creates the object (allocates memory). It receives the class as the first argument and returns the new instance.__init__is called second to initialize the newly created object. It receives the instance (self) and sets up attributes.
Most developers only override __init__. __new__ is used for immutable types (like int, str) or Singleton patterns.
Q2: Does Python support constructor overloading?
Answer: Not directly. Unlike Java/C++, Python cannot have multiple __init__ methods with different signatures. Workarounds:
- Default arguments:
def __init__(self, x, y=0, z=0) - **
*args/kwargs: accept variable arguments @classmethodfactory methods:Date.from_string("15-08-1947")
Q3: Why is @classmethod used for alternate constructors?
Answer: @classmethod receives the class (cls) as the first argument rather than an instance. This lets it call cls(...) to create and return a new instance, acting as a named factory. This is more maintainable than __init__ with complex branching.
Q4: What is a destructor? When is __del__ called?
Answer: __del__ is the destructor method, called when an object's reference count drops to zero. Python's garbage collector then reclaims memory. Timing is not guaranteed (especially in CPython with cyclic references), so it should NOT be relied on for critical cleanup — use context managers (with) instead.
Q5: How can you prevent a class from being instantiated more than once (Singleton)?
Answer: Override __new__:
python example
class Singleton:
_instance = None
def __new__(cls, *a, **kw):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instanceQ6: What happens if __init__ raises an exception?
Answer: The object is created by __new__ but __init__ fails. The incomplete object has no name binding (the variable is never assigned), so it becomes immediately eligible for garbage collection. The exception propagates to the caller.
🧪 Practice Exercises
- Config Manager (Singleton): Create a
Configclass that can only have one instance and stores key-value settings. - Vector3D: Create a
Vector3D(x, y, z)class with alternate constructors:from_list([1,2,3]),from_dict({"x":1,"y":2,"z":3}), andzero()(returns origin vector). - Employee: Create an
Employeeclass with validation —namemust be non-empty,salarymust be positive,departmentmust be one of a predefined list. - Timer: Create a
Timerclass whose__del__prints how long the object existed (usetime.time()in__init__and__del__). - Pizza Builder: Create a
Pizzaclass with afrom_size(size)classmethod that sets default toppings based on pizza size.
💡 Next Topic → Inheritance: Learn how classes inherit attributes and methods, use super(), and build powerful class hierarchies.Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Constructors 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 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.