Constructors (__init__) in Python – Complete Guide with Examples

Introduction

In Python, constructors are special methods that are automatically executed when an object is created. The most commonly used constructor is the __init__() method. It helps initialize object attributes, assign default values, and perform setup tasks required for an object.

For example, if you create a Student object, you may want to immediately store the student’s name, age, and marks. Instead of assigning these values manually after object creation, you can use a constructor to initialize them automatically.

What is a Constructor in Python?

A constructor is a special method that is automatically called when an object is created from a class.

In Python, the constructor method is:

__init__()

The purpose of a constructor is to:

• Initialize object attributes
• Assign default values
• Prepare an object for use
• Reduce repetitive code

Example:

class Student:
    def __init__(self):
        print("Constructor Called")
student = Student()

Output:

Explanation:

• The __init__() method is executed automatically.
• No need to call it explicitly.
• It runs whenever an object is created.

Syntax of init()

Basic syntax:

class ClassName:
    def __init__(self):
        # initialization code

Example:

class Employee:
    def __init__(self):
        print("Employee Created")

Creating an object:

employee = Employee()

Output:

Understanding self in Constructors

The first parameter of the constructor is always self.

class Student:
    def __init__(self):
        print(self)

The self keyword refers to the current object.

Example:

class Student:
    def __init__(self, name):
        self.name = name

Here:

self.name

stores the value inside the object.

Constructor with Parameters

Most constructors accept parameters.

Example:

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age
student = Student("John", 20)
print(student.name)
print(student.age)

Output:

Explanation:

• name and age are constructor parameters.
• Values are assigned during object creation.
• The object becomes immediately usable.

Types of Constructors in Python

Python mainly supports two types of constructors:

1. Default Constructor

A constructor without parameters.

class Student:
    def __init__(self):
        print("Student Object Created")
student = Student()

Output:

2. Parameterized Constructor

A constructor that accepts arguments.

Example:

class Student:
    def __init__(self, name):
        self.name = name
student = Student("Emma")
print(student.name)

Output:

Parameterized constructors are more commonly used.

Example: Initializing Multiple Attributes

class Employee:
    def __init__(self, name, salary, department):
        self.name = name
        self.salary = salary
        self.department = department
employee = Employee(
    "David",
    50000,
    "IT"
)
print(employee.name)
print(employee.salary)
print(employee.department)

Output:

Constructor with Default Values

You can assign default values.

class Student:
    def __init__(self, name="Unknown"):
        self.name = name
student1 = Student()
student2 = Student("John")
print(student1.name)
print(student2.name)

Output:

This provides flexibility when values are not supplied.

Constructor Calling Methods

A constructor can call other methods.

class Student:
    def __init__(self, name):
        self.name = name
        self.display()
    def display(self):
        print("Welcome", self.name)
student = Student("John")

Output:

Constructor in Inheritance

Constructors are also used with inheritance.

Parent Class

class Person:
    def __init__(self, name):
        self.name = name

Child Class

class Student(Person):
    def __init__(self, name, course):
        super().__init__(name)
        self.course = course
student = Student(
    "John",
    "Python"
)
print(student.name)
print(student.course)

Output:

Explanation:

• super() calls the parent constructor.
• Parent attributes are initialized first.

Real-Life Examples:

1. Student Management System

class Student:
    def __init__(self, name, marks):
        self.name = name
        self.marks = marks
    def display(self):
        print("Name:", self.name)
        print("Marks:", self.marks)
student1 = Student("John", 85)
student2 = Student("Emma", 92)
student1.display()
student2.display()

Output:

Benefits:

• Data is initialized immediately.
• Objects are ready for use.
• Code is cleaner and more organized.

2. Bank Account

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner
        self.balance = balance
    def show_balance(self):
        print("Balance:", self.balance)
account = BankAccount(
    "John",
    10000
)
account.show_balance()

Output:

In banking applications, constructors initialize account information when accounts are created.

Constructor vs Normal Method

Example:

class Student:
    def __init__(self):
        print("Constructor")
    def display(self):
        print("Method")
student = Student()
student.display()

Output:

Advantages of Constructors

Common Mistakes

1. Misspelling init

Incorrect:

class Student:
    def init(self):
        pass

Correct:

class Student:
    def __init__(self):
        pass

2. Forgetting self

Incorrect:

class Student:
    def __init__(name):
        pass

Correct:

class Student:
    def __init__(self, name):
        pass

3. Not Assigning Values to self

Incorrect:

class Student:
    def __init__(self, name):
        name = name

Correct:

class Student:
    def __init__(self, name):
        self.name = name

4. Passing Incorrect Number of Arguments

Incorrect:

student = Student()

When constructor expects:

Student("John")

This causes a TypeError.

5. Writing Too Much Logic in Constructor

Avoid placing complex business logic inside constructors.

Keep them focused on initialization.

Best Practices

1. Use Constructors for Initialization

def __init__(self, name):
    self.name = name

2. Keep Constructors Simple

Initialize data only.

3. Use Meaningful Parameter Names

def __init__(self, student_name):

instead of:

def __init__(self, x):

4. Provide Default Values When Appropriate

def __init__(self, status="Active"):

5. Use super() in Inheritance

super().__init__(name)

Conclusion

Constructors are one of the most important concepts in Python’s Object-Oriented Programming model. The __init__() method allows developers to initialize object attributes automatically when objects are created.

Constructors improve code readability, reduce repetitive assignments, and ensure objects are properly configured before use.

Related Python Tutorials