Is there a way to return a previously defined object when initiating a new one?

What about using the factory pattern?

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

class NodeFactory:
    def __init__(self):
        self.nodes = set()
    
    def create_node(self, x, y):
        for node in self.nodes:
            if node.x == x and node.y == y:
                return node
        node = Node(x, y)
        self.nodes.add(node)
        return node

factory = NodeFactory()

n1 = factory.create_node(1, 5)
n2 = factory.create_node(1, 5)
n3 = factory.create_node(2, 1)

print(n1)
print(n2)
print(n3)

Output:

<__main__.Node object at 0x7fa595aa6640>
<__main__.Node object at 0x7fa595aa6640>
<__main__.Node object at 0x7fa595aa6100>

As you can see n1 and n2 are the same object here, so:

>>> n1 == n2
True

You can override the __new__ method of the class to control the creation of the nodes.

We store the existing nodes in a class attribute, a dict with the coordinates as keys and the Node objects as values.

__new__ looks if there already is a node with these coordinates in this dict. If yes, it just returns the already existing node. If not, it creates and returns a new one.

Depending on what you do in it, it may be better not to run __init__ again (or maybe not all parts of it) for already existing nodes. So, we just set an _already_initialized flag on the instance, that will be False at creation time, and that will be changed to True by __init__. This way, you can completely control what to do the first time a node is initialized, and the following times.

The code, with a few prints included to show what's going on:

class Node:

    _nodes = {} 

    def __new__(cls, x, y):
        if (x, y) in cls._nodes:
            print('Reusing', cls._nodes[(x, y)])
            return cls._nodes[(x, y)]
       
        new_node = super().__new__(cls)
        new_node._already_initialized = False
        print(f'New node created for x={x}, y={y}')

        cls._nodes[(x, y)] = new_node
        
        return new_node
    
    def __init__(self, x, y):
        if not self._already_initialized:
            self.x = x
            self.y = y
            self.set_idx(self)
            self._already_initialized = True
            print(self, 'initialized')
        else:
            print(self, 'was already initialized, leaving as it is')

    @classmethod
    def set_idx(cls, node):
        """Function to set unique index based on the number of nodes."""
        # There is a procedure to determine this index, but that does not matter for the question.
        pass

    @property
    def index(self):
        return self.__node_idx

    @property
    def coordinates(self):
        return self.x, self.y
    
    def __repr__(self):
        return f'Node: x={self.x}, y={self.y}'

Demo:

print('Creating n1')    
n1 = Node(x=0, y=0)

print('\nCreating n2')
n2 = Node(x=0, y=0)

print('\nCreating n3')
n3 = Node(1, 1)

print(f'\nn1 == n2: {n1 == n2}')
print(f'n1 is n2: {n1 is n2}')

print(f'\nNode._nodes: {Node._nodes}')

Output:

Creating n1
New node created for x=0, y=0
Node: x=0, y=0 initialized

Creating n2
Reusing Node: x=0, y=0
Node: x=0, y=0 was already initialized, leaving as it is

Creating n3
New node created for x=1, y=1
Node: x=1, y=1 initialized

n1 == n2: True
n1 is n2: True

Node._nodes: {(0, 0): Node: x=0, y=0, (1, 1): Node: x=1, y=1}



There's a built-in function for this. Use the functools.cache decorator:

import functools

@functools.cache
class Node:
    def __init__(self, x, y):
        self.__slots = __x,__y
        self.x = x
        self.y = y

n1 = Node(1,2)
n2 = Node(1,2)
print(n1 == n2, n1 is n2)

Output:

True True

Note that functools.cache caches by the original parameters to create Node, so mutating the coordinates afterward n1.x = 2 will change both n1 and n2 to Node(2,2), but n3=Node(1,2) will still return the same Node created by those parameters, resulting in print(n3) giving Node(2,2). To prevent this, make sure the coordinates can't change via property:

import functools

@functools.cache
class Node:

    def __init__(self, x, y):
        self.__x = x            # use private notation
        self.__y = y

    def __repr__(self):
        return f'Node(x={self.__x}, y={self.__y})'

    @property                # read-only property x
    def x(self):
        return self.__x

    @property                # read-only property y
    def y(self):
        return self.__y

n1 = Node(1,2)
n2 = Node(1,2)
print(n1,n2)
print(n1 == n2, n1 is n2)

Output:

Node(x=1, y=2) Node(x=1, y=2)
True True

You won't be able to mutate the node's coordinates, but you can set other attributes if desired (or use __slots__ to limit attributes if you don't).

>>> n1.x = 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: can't set attribute
>>> n1.__x = 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Node' object has no attribute '__x'