Python: Modifying an object by assigning it to another object

Question

I'm new to Python (coming from C++), and understand that roughly speaking, all variables (names) are references to Python objects. Some of these objects are mutable (lists), while others aren't (tuples, although you can change its elements if they themselves are mutable).

For mutable objects, I can modify them by accessing their modifier functions (such as .append()) through the name(s) they're bound to. For example:

myList = [1,2,3,4]
myList.append(5)

However, I know that simply assigning myList to a second list just instantiates this second list and reassigns myList to it; The original list [1,2,3,4] still exists, until garbage collection cleans it up (or not if another name is assigned to it).

MY QUESTION:

Lets say I have a Point class:

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

p1 = Point(1,1)
p1.x = 2
p1.y = 2

How can I replace p1.x = 2 and p1.y = 2 with a single command that just assigns my Point(1,1) object to a Point(2,2) object? Clearly, p1 = Point(2,2) doesn't work as this just reassigns the p1 name to a new and different Point(2,2) object (which is not what I need!).

Is there a built-in way to do this or do I need to define an additional modifier function in Point:

def changePoint(self, newPoint):
    self.x = newPoint.x
    self.y = newPoint.y

in order to do this in a single command (i.e. via p1.changePoint(Point(2,2)))? In C++ you can often just use a class' implicitly defined overloaded assignment operator (operator=) and accomplish this in a single command:

SimpleNameClass* objectPtr = new SimpleNameClass("Bob");
//Dereferencing objectPtr and assigning new object:
*objectPtr = SimpleNameClass("Jim");

//Now objectPtr still points to (references) the same address in memory,
//but the underlying object is completely different.

Overall, it seems tedious to have to change every attribute individually when I want to transform my object into a new one, especially if my object contains many attributes!

EDIT:

Adding to Jainil's answer, it turns out I don't even need to change the definition of init at all, I can just use the above version. Then, you can transform a Point object to another one with a single command, like so:

p1.__init__(2,2) #Replaces p1.x = 2, p1.y = 2

It works since the original init takes to 2 args. So a standard, vanilla init method basically already enables changing the underlying object, in addition to instantiating it (at least in this case). Yipee.

Answer 1

class Point:
    def __init__(self, *args):
        if(len(args)==2):
            self.x = args[0]
            self.y = args[1]
        elif(len(args)==1):
            self.x=args[0].x
            self.y=args[0].y




p1 = Point(1,1)
p1.x = 2
p1.y = 2
p1.__init__(Point(3,3))
print(p1.x," ",p1.y)

it is just what you want , but in python way.

in python = can't be overloaded and it is not an operator in python, it is delimeter in python. see https://docs.python.org/3/reference/lexical_analysis.html#delimiters