human
I am working on the file "Section 1 - Core Python/Chapter 09 - Classes & OOPS/01_Classes_and_OOPS.ipynb".
The first task is:
__new__
__new__ is called for new Class type, 
Overriding the new method
As per "https://www.python.org/download/releases/2.2/descrintro/#new"
Here are some rules for __new__:

__new__ is a static method. When defining it, you don't need to (but may!) use the phrase "__new__ = staticmethod(__new__)", because this is implied by its name (it is special-cased by the class constructor).
The first argument to __new__ must be a class.
the remaining arguments are the arguments as seen by the constructor call.
A __new__ method that overrides a base class's __new__ method may call that base class's __new__ method. The first argument to the base class's __new__ method call should be the class argument to the overriding __new__ method, not the base class.
if you were to pass in the base class, you would get an instance of the base class.
Unless you want to play games like those described in the next two bullets, a __new__ method must call its base class's __new__ method.
that's the only way to create an instance of your object. The subclass __new__ can do two things to affect the resulting object: pass different arguments to the base class __new__, and modify the resulting object after it's been created (for example to initialize essential instance variables).
__new__ must return an object. There's nothing that requires that it return a new object that is an instance of its class argument, although that is the convention. If you return an existing object, the constructor call will still call its __init__ method. If you return an object of a different class, its __init__ method will be called. If you forget to return something, Python will unhelpfully return None, and your caller will probably be very confused.
For immutable classes, your __new__ may return a cached reference to an existing object with the same value.
this is what the int, str and tuple types do for small values. This is one of the reasons why their __init__ does nothing: cached objects would be re-initialized over and over. (The other reason is that...
Can you write Python code for it?

=====
Here the int, str and tuple types do for small values?
assistant
#Here the int, str and tuple types do for small values.

class MyTest:
    def __new__(self):
        print("in new")
        
    def __init__(self):
        print("in init")

mnt = MyTest()

class MyNewTest:
    def __new__(self):
        print("in new")

    def __new__(self, name):
        print("in new", name)
        
    def __init__(self, name):
        print("in init", name)

mnt = MyNewTest("Hari Hari")