Constructors (__init__)

Introduction

In the previous lesson, you used __init__ briefly to set instance attributes when creating objects. This lesson goes much deeper: you will learn exactly what a constructor is, how to give parameters default values, how to validate arguments before storing them, and how __init__ relates to two other special methods, __new__ and __del__.

What is a Constructor?

A constructor is a special method that runs automatically when a new object is created, used to set up that object's initial state. In Python, this role is filled by the __init__ method, which stands for "initialize."

The __init__ Method

When you write ClassName(arguments), Python automatically calls __init__ behind the scenes, passing self plus whatever arguments you provided. This is why __init__ always has self as its first parameter, exactly like every other instance method.

class BankAccount:
    def __init__(self, owner, balance):
        print("Constructor is running...")
        self.owner = owner
        self.balance = balance

account = BankAccount("Priya", 5000)
print(account.owner, account.balance)

Constructor is running...
Priya 5000

Notice that "Constructor is running..." prints before you even see the object's attributes — __init__ genuinely runs the instant BankAccount("Priya", 5000) is evaluated.

Default Parameter Values in __init__

Just like regular functions, __init__ parameters can have default values. This lets you create an object without providing every single argument, falling back to sensible defaults instead.

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

account1 = BankAccount("Priya", 5000)
account2 = BankAccount("Aarav")  # balance defaults to 0

print(account1.owner, account1.balance)
print(account2.owner, account2.balance)

Priya 5000
Aarav 0

account2 was created with only a name, so balance automatically used its default value of 0. Remember from the previous lesson: never use a mutable default like a list directly as a parameter default without care, since defaults are evaluated only once when the function is defined.

Validating and Processing Arguments

Since __init__ is regular Python code, you can add logic to check that the arguments make sense before storing them, raising an exception if something is invalid. This combines directly with what you learned in the exception handling lesson.

class BankAccount:
    def __init__(self, owner, balance=0):
        if not owner:
            raise ValueError("Owner name cannot be empty.")
        if balance < 0:
            raise ValueError("Initial balance cannot be negative.")

        self.owner = owner.strip().title()  # process/clean the argument
        self.balance = balance

account = BankAccount("  priya  ", 1000)
print(account.owner, account.balance)

try:
    bad_account = BankAccount("Aarav", -500)
except ValueError as error:
    print("Error:", error)

Priya 1000
Error: Initial balance cannot be negative.

The constructor both validates balance (rejecting negative numbers) and processes owner (trimming whitespace and standardizing capitalization) before the values are ever stored as attributes.

__new__ vs __init__

Python actually splits object creation into two separate steps, handled by two different special methods. __new__ is responsible for actually creating the new, empty object, while __init__ is responsible for initializing that already-created object with data. You will almost never need to override __new__ yourself as a beginner, but knowing it exists clarifies what __init__ really does.

class Demo:
    def __new__(cls):
        print("__new__ runs first: creates the object")
        instance = super().__new__(cls)
        return instance

    def __init__(self):
        print("__init__ runs second: initializes the object")

obj = Demo()

__new__ runs first: creates the object
__init__ runs second: initializes the object

The __del__ Destructor (Brief Introduction)

Just as __init__ runs when an object is created, __del__ is a destructor that runs when an object is about to be destroyed — typically when it is no longer referenced anywhere and Python's memory manager cleans it up. It is used far less often than __init__ and its exact timing is not always predictable, so it is only briefly introduced here.

class Connection:
    def __init__(self, name):
        self.name = name
        print(f"Connection '{self.name}' opened.")

    def __del__(self):
        print(f"Connection '{self.name}' closed.")

conn = Connection("Database")
del conn  # explicitly remove the reference

Connection 'Database' opened.
Connection 'Database' closed.

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

You went deep on __init__, Python's constructor, learning how to set default parameter values and validate arguments before storing them. You also saw how __new__ handles object creation before __init__ runs, and got a brief look at the __del__ destructor.