_new_ in Python

Python enables the creation and manipulation of objects, making it an object-oriented programming (OOP) language. Since objects are instances of classes, they are capable of holding data and methods that manipulate it. Because it arranges code into objects rather than a sequence of procedural procedures, this method of programming is known as OOP.

Double underscore methods in Python are referred to as "dunder methods," which is short for "dunder". These are unique Python methods, like __init__ or __str__, that contain a double underscore before and after the method name.

Python places a special emphasis on dunder methods since they let you alter objects' behaviour in specified ways. When an object is formed, for instance, the __init__ method is used to set its attributes, while the __str__ method is used to return a string representation of the object.

_new_ Operator

In Python, a class instance is created with the _new_ operator. Classes in Python are formed by using the _new_ operator and are defined using the class keyword. When a new instance of a class is created, a unique method called the _new_ operator is invoked, and it is in charge of initialising the object's attributes.

In Python, the _new_ method is not frequently used since it is mostly used to manage the formation of the object and carry out customised initializations. The class instance is created and returned using the _new_ method by default.

Take the following class definition, for instance:

Code

Use the following syntax to make a new instance of the Person class:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

Code

Python uses the default implementation because the _new_ method isn't explicitly specified in this case. The attributes of the object are then initialised by using the __init__ function.

You may construct a special _new_ method to override the object's creation procedure, though. For instance:

Code

class Person:
    def __new__(cls, name, age):
        print("Creating a new instance of the Person class")
        instance = object.__new__(cls)
        return instance

    def __init__(self, name, age):
        self.name = name
        self.age = age

When a new instance of the Person class is created, the _new_ method, which is specified in this example, will be invoked. The _new_ function invokes the object class's __new__ method to create a new instance after printing a message indicating that a new instance of the class is being produced.

The __init__ function is then invoked to initialise the object's attributes once the new instance has been returned. Although Python's _new_ function is a potent tool for managing object creation, it should only be used sparingly. It is advised to utilise the _new_ method only when necessary because improper usage of it might result in unexpected behaviour and issues.

In conclusion, Python's _new_ operator is used to construct a class instance, and it is used each time a new class instance is generated. The _new_ function can be modified to modify how the object is created; by default, it produces a new instance of the class and returns it. The _new_ method is a strong tool, but it should be used with care since misuse might result in problems and unexpected behaviour.

Example Program:

Here is an illustration of how to utilise Python's __new__ function.:

Code

class MyClass:
    def __new__(cls):
        print("Creating instance of MyClass")
        return super().__new__(cls)

obj = MyClass()

Output:

Creating instance of MyClass

Explanation

The __new__ function of MyClass in this illustration outputs a message whenever a new instance of the class is created. The freshly generated object's reference is returned by the __new__ method, which is invoked before the __init__ function. The __init__ function may be used to initialise the attributes of the object using this reference, which is then supplied to it. In this example, we called the __new__ method of the parent class, which is the built-in object class in Python, using the super() function.

It's crucial to understand that using the __new__ function directly is not its intended use. Instead, Python automatically invokes it whenever a new instance of the class is created. However, you may override the __new__ function to define your own unique behaviour if you wish to alter how instances of your class are produced.

Next TopicAppend (key: value) Pair to Dictionary

← prev next →