Python's `__init__` vs. `__new__`

Have you ever wondered how instances are created in Python? When working with classes, two special methods, __init__ and __new__, play crucial roles in the instance creation process. At first glance, they may seem similar, but they have distinct purposes and behaviors. In this article, we will demystify __init__ and __new__ in Python and shed light on their differences.

Understanding __init__

The __init__ method is known as the initializer or constructor of a class. It gets called automatically when a new instance of a class is created. Its primary role is to initialize the attributes of the object. Let's look at an example:

Copycopy code to clipboard
1class Person:
2    def __init__(self, name, age):
3        self.name = name
4        self.age = age
5
6john = Person("John", 25)
7print(john.name)  # Output: John
8print(john.age)   # Output: 25

In the above code snippet, the __init__ method takes name and age as parameters and assigns them to the instance variables self.name and self.age, respectively. When creating a new instance of the Person class using john = Person("John", 25), the __init__ method is automatically invoked, initializing the attributes of the john object.

Exploring __new__

While __init__ takes care of instance initialization, the __new__ method is responsible for creating and returning a new instance of a class. It is called before __init__ and receives the class itself as its first argument, followed by any additional arguments passed during instance creation. Here's an example:

Copycopy code to clipboard
1class Singleton:
2    instance = None
3
4    def __new__(cls):
5        if cls.instance is None:
6            cls.instance = super().__new__(cls)
7        return cls.instance
8
9obj1 = Singleton()
10obj2 = Singleton()
11
12print(obj1 is obj2)  # Output: True

In this example, we define a Singleton class that ensures only one instance is created throughout the program's execution. The __new__ method checks if the instance attribute is None. If it is, it creates a new instance of the class using super().__new__(cls) and assigns it to cls.instance. Subsequent calls to Singleton() will return the same instance, as demonstrated by obj1 is obj2 evaluating to True.

Differentiating __init__ and __new__

Now that we have a basic understanding of both methods, let's summarize their differences:

• __new__ is responsible for creating and returning a new instance of a class, while __init__ initializes the attributes of the object after it has been created.
• __new__ is a static method, whereas __init__ is an instance method. This means that __new__ is called on the class itself, while __init__ is called on the newly created instance.
• __new__ is typically used in scenarios where you need fine-grained control over instance creation, such as implementing singletons or custom metaclasses. On the other hand, __init__ is commonly used to initialize instance variables and perform any required setup.

Understanding these distinctions is essential for effective object-oriented programming in Python. By leveraging the power of __new__ and __init__, you can create instances tailored to your specific needs.

In conclusion, Python's __init__ and __new__ methods serve distinct purposes in the instance creation process. While __new__ handles object creation, __init__ takes care of initialization. By leveraging these methods appropriately, you can achieve greater control and flexibility when working with classes and objects in Python.