Constructors in Python

Analogy categoryAnalogies

1. Introduction

A constructor is the mechanism responsible for creating and initializing a new object when a class is instantiated. In Python, the method most people call "the constructor" is __init__, which sets up the initial state (attributes) of a newly created object. It runs automatically every time you instantiate a class.

🏏

Cricket analogy: When a new player is registered for a team, __init__ automatically runs to set their jersey number and batting position right away, just as a real player isn't allowed on the field before their registration paperwork is filled in.

Constructors let you guarantee that every object starts in a valid state — for example, ensuring a BankAccount always begins with a non-negative balance, rather than relying on the caller to set attributes manually after creation.

🏏

Cricket analogy: A team's registration form forces every new player's fitness score to be validated before they're added to the squad, rather than trusting a scout to check it later, just as __init__ guarantees a BankAccount always starts with a non-negative balance.

2. Syntax

python

class ClassName:
    def __init__(self, param1, param2=default_value):
        self.attr1 = param1
        self.attr2 = param2


obj = ClassName(value1)          # param2 uses default_value
obj2 = ClassName(value1, value2) # both provided explicitly

3. Explanation

__init__ takes self as its first parameter (referring to the newly created object) plus any additional parameters needed to configure the object. Inside __init__, you typically assign parameters to self.attribute to store them as instance state. Parameters can have default values, making them optional at call time.

🏏

Cricket analogy: __init__(self, name, role='Batsman') takes the new player plus a role that defaults to 'Batsman' if not specified, and stores it as self.role, so registering a player without stating a role still gives them a valid position.

__init__ never needs an explicit return statement — Python enforces that it returns None. If you try to return a non-None value from __init__, Python raises a TypeError at call time.

🏏

Cricket analogy: Just as a player's registration process can't 'return' a trophy at sign-up — it only sets up the player's record — Python enforces that __init__ returns None, and trying to return anything else raises a TypeError.

Technically, __init__ is not the real constructor — it is the initializer. The actual object-creation method is __new__, which allocates memory and returns the new (still uninitialized) instance. Python calls __new__ first, then passes the resulting object as self to __init__ to fill in its state. You rarely need to override __new__ except for advanced patterns like singletons or immutable subclasses.

4. Example

python

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance
        print(f"Account created for {self.owner} with balance {self.balance}")

    def deposit(self, amount):
        self.balance += amount


acc1 = BankAccount("Priya")
acc2 = BankAccount("Arjun", 500)

acc1.deposit(150)

print("acc1 balance:", acc1.balance)
print("acc2 balance:", acc2.balance)
print("__init__ return value:", BankAccount.__init__(acc1, "Priya", 100))

5. Output

text

Account created for Priya with balance 0
Account created for Arjun with balance 500
acc1 balance: 150
acc2 balance: 500
Account created for Priya with balance 100
__init__ return value: None

6. Key Takeaways

__init__ initializes a newly created object's attributes; it runs automatically on instantiation.
__new__, not __init__, is Python's true constructor — it allocates and returns the raw object.
__init__ must always return None; returning any other value raises a TypeError.
Constructor parameters can have default values to make some arguments optional.
Calling __init__ directly on an existing object re-runs initialization on that same object.