What Does __init__ Do in Python?

__init__ is the initialiser. The interpreter calls it automatically after the object has been created, and its job is to set the object's initial state.

class Rectangle:
    def __init__(self, width, height):
        if width <= 0 or height <= 0:
            raise ValueError("dimensions must be positive")
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height


rect = Rectangle(3, 4)
print(rect.area())          # 12

# __init__ is a normal method - it can be called explicitly
Rectangle.__init__(rect, 5, 6)
print(rect.area())          # 30

Calling Rectangle(3, 4) creates the object and then runs __init__ on it. The method itself returns None — its job is the side effect of setting attributes, and the object comes from the class call, not from the return value of __init__.

The last two lines show that __init__ is an ordinary method, not a special hook that only the interpreter can trigger. Calling it directly on an existing object re-initialises it, which works but is rarely what you want; normally you would just assign the attributes.

Two rules about its signature. It must return None, and if you define it you should always accept self as the first parameter. There is also no automatic return value — a class without an __init__ gets a default one that accepts no arguments, which is why Rectangle() with no arguments raises a TypeError rather than creating an empty object.

__init__ initialises an object that has already been created. When you call a class, Python does two things in order: it calls __new__ to allocate the object, and then it calls __init__ on that new object to set its state. Your code almost always lives in __init__; __new__ is rarely written by hand.

__new__ is the constructor in the strict sense. It is a static method — it receives the class as its first argument rather than an instance — and its job is to allocate and return the object. The default implementation calls type.__new__ and hands back an instance with an empty instance dictionary, which is why __init__ then has something to fill in. You write __new__ when you need to control the creation itself: returning a cached instance, returning a different type, or using a factory pattern. The rule to remember is that __new__ must return an instance of the class, or of a subclass, or the call fails with a TypeError.

__post_init__ is a dataclass feature and only exists when you use the dataclasses decorator. The decorator generates an __init__ for you from the field declarations, and if your class defines __post_init__, it is called automatically at the end of that generated __init__. It is the place for validation that depends on several fields together, since each field's own __post_init__ would not see the others.

For an interview, the summary is: __new__ creates, __init__ initialises, __post_init__ validates after a dataclass has been built. And the practical rule is to write __init__ and leave the other two alone unless you have a specific reason.