The Constructor: Initializing Objects with __init__

A Complete Object Lifecycle

An object is not just a value that appears and disappears. It passes through a lifecycle: Python creates it, initializes it, lets your program use it, and eventually destroys it. The special method __init__ participates at the beginning of that lifecycle. If a class defines __del__, that method participates at the end.

When you create an instance, Python allocates memory for the object and calls its __init__ method automatically. The method gives the class a place to establish sensible starting values. After initialization, the object can be used through its methods and attributes. Later, when the object is no longer needed, Python destroys it and calls __del__ if the class defines that method.

Creation Before Use

A class defines the behavior and structure from which instances are created. An instance is one individual object made from that class. When an instance is created, Python automatically calls __init__. You do not normally call __init__ yourself to begin the object's lifecycle.

class User:
    def __init__(self, name):
        self.name = name
        self.active = True

user = User("Mina")

In this example, User is the class and user is an instance. When User("Mina") creates the instance, Python calls __init__ automatically. The self parameter identifies that particular instance. The assignments create instance attributes named name and active, so this instance begins with name set to "Mina" and active set to True.

Building Initial State

The main job of __init__ is to make an instance ready for predictable use. An instance attribute is data attached to one particular object. Writing self.name = name attaches the value from the parameter name to the current object identified by self. Because each instance receives its own call to __init__, each instance has its own separate set of initialized attributes.

Destruction Triggers

The destructor __del__ is called when an object is about to be destroyed. The source identifies three common triggers: a variable holding the object is reassigned, a variable goes out of scope, or the program terminates. In each case, Python decides that the object is no longer needed and gives __del__ a final opportunity to perform cleanup.

class Marker:
    def __init__(self, label):
        self.label = label
        print("created", self.label)

    def __del__(self):
        print("destroyed", self.label)

marker = Marker("first")
marker = 42

created first
destroyed first

The first assignment creates a Marker instance, so __init__ runs and stores the label. The second assignment replaces the object held by marker with the value 42. The original Marker object is then no longer needed in this simple sequence, so Python destroys it and calls __del__.

Cleanup Responsibilities

Most Python objects do not need a destructor. Python's garbage collector handles memory automatically when objects are no longer in use. A destructor becomes useful when an object manages an external resource, such as an open file handle, a database connection, or a network socket.

class Connection:
    def __init__(self, name):
        self.name = name
        print("connection prepared", self.name)

    def __del__(self):
        print("connection cleanup", self.name)

This example illustrates the intended division of responsibility: __init__ prepares the object and any resources it needs, while __del__ provides a final chance to release resources before the object vanishes. You cannot stop the object from being destroyed. You can only use __del__ for cleanup at that final moment.

Mistakes with Initialization and Destruction

• Treating __init__ as a normal method that must be called manually.

  Python already calls __init__ when the instance is created. Calling it again repeats initialization and is not needed for ordinary object creation.

  Fix: Create the instance and let Python invoke __init__ automatically.

• Assigning to a local name instead of an instance attribute.

  This does not attach the value to the object. The instance needs an assignment using self, such as self.name = name.

  Fix: Use self.attribute_name when storing data on the current instance.

• Assuming all instances share one set of instance attributes.

  Each instance receives its own call to __init__ and its own separate set of attributes.

  Fix: Think of the class as the shared definition and each instance as an individual object with independently initialized attributes.

• Adding __del__ to every class without managing an external resource.

  Most objects do not need explicit cleanup because Python automatically manages memory.

  Fix: Use __del__ when the object manages an external resource such as a file handle, database connection, or network socket.

Trace the Lifecycle

Key Takeaways

1. __init__ runs automatically when Python creates an instance.
2. The self parameter identifies the particular instance being initialized.
3. Assignments such as self.name = name create or set instance attributes.
4. Each instance has its own separately initialized attributes.
5. __del__ runs when an object is about to be destroyed, including after reassignment, when a variable leaves scope, or when the program ends.
6. Most objects do not need __del__; it is mainly useful for final cleanup of external resources.