{"id":2879,"date":"2021-11-13T15:28:40","date_gmt":"2021-11-13T15:28:40","guid":{"rendered":"https:\/\/www.pythontutorial.net\/?page_id=2879"},"modified":"2021-11-13T16:07:47","modified_gmt":"2021-11-13T16:07:47","slug":"python-__new__","status":"publish","type":"page","link":"https:\/\/www.pythontutorial.net\/python-oop\/python-__new__\/","title":{"rendered":"Python __new__"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn about the Python __new__ method and understand how Python uses it to create a new object.<\/p>\n\n\n\n

Introduction to the Python __new__ method #<\/a><\/h2>\n\n\n\n

When you create an instance of a class<\/a>, Python first calls the __new__()<\/code> method to create the object and then calls the __init__()<\/a><\/code> method to initialize the object’s attributes.<\/p>\n\n\n\n

The __new__()<\/code> is a static method<\/a> of the object<\/code> class. It has the following signature:<\/p>\n\n\n

object.__new__(class<\/span>, *args<\/span>, **kwargs<\/span>)<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The first argument of the __new__<\/code> method is the class<\/code> of the new object that you want to create.<\/p>\n\n\n\n
The *args<\/code> and **kwargs<\/code> parameters must match the parameters of the __init__()<\/code> of the class. However, the __new__()<\/code> method does use them.<\/p>\n\n\n\n
The __new__()<\/code> method should return a new object of the class. But it doesn’t have to.<\/p>\n\n\n\n
When you define a new class, that class implicitly inherits from the object<\/code> class. It means that you can override the __new__<\/code> static method and do something before and after creating a new instance of the class.<\/p>\n\n\n\n
To create the object of a class, you call the super().__new__()<\/code> method.<\/p>\n\n\n\n
Technically, you can call the object.__new__()<\/code> method to create an object manually. However, you need to call the __init__()<\/code> yourself manually after. Python will not call the __init__()<\/code> method automatically if you explicitly create a new object using the object.__new__()<\/code> method.<\/p>\n\n\n\n
Python __new__ method example #<\/a><\/h2>\n\n\n\n
The following defines the Person<\/code> class with the name<\/code> attribute and create a new instance of the Person<\/code> class:<\/p>\n\n\n
class<\/span> Person<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self, name)<\/span>:<\/span>\n        self.name = name\n\n\nperson = Person('John'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
person = Person('John'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Python will call the __new__()<\/code> and __init__()<\/code> methods. It’s equivalent to the following method calls:<\/p>\n\n\n
person = object.__new__(Person, 'John'<\/span>)\nperson.__init__('John'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The following shows the contents of the __dict__<\/code> of the person<\/code> object after calling the __new__()<\/code> and __init__()<\/code> methods:<\/p>\n\n\n
person = object.__new__(Person, 'John'<\/span>)\nprint(person.__dict__)\n\nperson.__init__('John'<\/span>)\nprint(person.__dict__)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
{}\n{'name'<\/span>: 'John'<\/span>}<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
As you can see clearly from the output, after calling the __new__()<\/code> method, the person.__dict__<\/code> is empty. And after calling the __init__()<\/code> method, the person.__dict__<\/code> contains the name<\/code> attribute with the value ‘John'<\/code>.<\/p>\n\n\n\n
The following illustrates the sequence which Python calls the __new__<\/code> and __init__<\/code> method when you create a new object by calling the class:<\/p>\n\n\n
class<\/span> Person<\/span>:<\/span>\n    def<\/span> __new__<\/span>(cls, name)<\/span>:<\/span>\n        print(f'Creating a new {cls.__name__}<\/span> object...'<\/span>)\n        obj = object.__new__(cls)\n        return<\/span> obj\n\n    def<\/span> __init__<\/span>(self, name)<\/span>:<\/span>\n        print(f'Initializing the person object...'<\/span>)\n        self.name = name\n\n\nperson = Person('John'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Creating a new Person object...\nInitializing the person object...<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, Python calls the __new__ method and the __init__ method after that.<\/p>\n\n\n\n
When using the __new__ method #<\/a><\/h2>\n\n\n\n
The following example defines the SquareNumber<\/code> class that inherits from the built-in int type:<\/p>\n\n\n
class<\/span> SquareNumber<\/span>(int)<\/span>:<\/span>\n    def<\/span> __new__<\/span>(cls, value)<\/span>:<\/span>\n        return<\/span> super().__new__(cls, value ** 2<\/span>)\n\n\nx = SquareNumber(3<\/span>)\nprint(x)  # 9<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, the __new__()<\/code> method of the SquareNumber<\/code> class accepts an integer and returns the square number. x<\/code> is an instance of the SquareNumber<\/code> class and also an instance of the int<\/code> built-in type:<\/p>\n\n\n
print(isinstance(x, int)) # True<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Note that you cannot do this by using the __init__()<\/code> method because the __init__()<\/code> method of the built-in int<\/code> takes no argument. The following code will result in an error:<\/p>\n\n\n
class<\/span> SquareNumber<\/span>(int)<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self, value)<\/span>:<\/span>\n        super().__init__(value ** 2<\/span>)\n\n\nx = SquareNumber(3<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Error:<\/p>\n\n\n
TypeError: object.__init__() takes exactly one argument (the instance to initialize)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In practice, you use the __new__()<\/code> method when you want to tweak the object at the instantiated time. <\/p>\n\n\n\n
For example, the following defines the Person<\/code> class and uses the __new__<\/code>method to inject the full_name<\/code> attribute to the Person’s object:<\/p>\n\n\n
class<\/span> Person<\/span>:<\/span>\n    def<\/span> __new__<\/span>(cls, first_name, last_name)<\/span>:<\/span>\n        # create a new object<\/span>\n        obj = super().__new__(cls)\n\n        # initialize attributes<\/span>\n        obj.first_name = first_name\n        obj.last_name = last_name\n\n        # inject new attribute<\/span>\n        obj.full_name = f'{first_name}<\/span> {last_name}<\/span>'<\/span>\n        return<\/span> obj\n\n\nperson = Person('John'<\/span>, 'Doe'<\/span>)\nprint(person.full_name)\n\nprint(person.__dict__)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
John Doe\n{'first_name'<\/span>: 'John'<\/span>, 'last_name'<\/span>: 'Doe'<\/span>, 'full_name'<\/span>: 'John Doe'<\/span>}<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Typically, when you override the __new__()<\/code> method, you don’t need to define the __init__()<\/code> method because everything you can do in the __init__()<\/code> method, you can do it in the __new__()<\/code> method.<\/p>\n\n\n\n
Summary #<\/a><\/h2>\n\n\n\n
  • The __new__()<\/code> is a static method of the object<\/code> class.<\/li>
  • When you create a new object by calling the class, Python calls the __new__()<\/code> method to create the object first and then calls the __init__()<\/code> method to initialize the object’s attributes.<\/li>
  • Override the __new__()<\/code> method if you want to tweak the object at creation time.<\/li><\/ul>\n
    \n\t
    \n\t\t
    Was this tutorial helpful ?<\/div>\n\t\t
    \n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t Yes <\/span>\n\t\t\t<\/button>\n\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t No <\/span>\n\t\t\t<\/button>\n\t\t<\/div>\n\t<\/header>\n\n\t
    \n\t\t
    \n\t\t\t
    <\/div>\n\t\t\t
In Python, a class is callable<\/a>. When you call the class to create a new object:<\/p>\n\n\n