When caching a class will all future instances refer to the exact same id as the original cached instance?

I was looking at how caching of classes works as I thought it would be a reasonable solution to one of the issues in the code I'm currently working on.

I've been testing the instance creation using this simple class:

from functools import lru_cache

@lru_cache
class Foo:
    def __init__(self, a: int):
        self.a = a
        self.b = sum(i**2 for i in range(self.a))

What I see is that all is working as expected and when using the same input as the one already cached, the initialisation time is 0:

import datetime as dt

start_1 = dt.datetime.now()
bar = Foo(10_000)
elapsed_1 = (dt.datetime.now() - start_1)   # 4008 ms

start_2 = dt.datetime.now()
baz = Foo(5_000)
elapsed_2 = (dt.datetime.now() - start_2)   # 3003 ms

start_3 = dt.datetime.now()
boo = Foo(15_000)
elapsed_3 = (dt.datetime.now() - start_3)   # 5002 ms

start_4 = dt.datetime.now()
bbb = Foo(10_000)
elapsed_4 = (dt.datetime.now() - start_4)   # 0 ms

But in the last case I see that no new object is created, just a new reference to an already existing one:

id(bar) == id(bbb)   # True

Obviously, if we remove @lru_cache from class definition then we get two different objects for the case of a=10_000 and this same test (above) comes back as False.

Is this a guaranteed behaviour when caching classes that the new object will always reference the same originally cached id?

Yes, when you cache a class using functools.lru_cache, all future instances of that class with the same set of input arguments will refer to the exact same object as the original cached instance.

This is because lru_cache stores the cached instances of the class in a cache dictionary, with the input arguments as the key. When a new instance of the class is requested with the same input arguments, lru_cache checks the cache dictionary to see if an instance with those input arguments already exists. If it does, it returns that instance, otherwise it creates a new instance and adds it to the cache dictionary.

Since the cache dictionary is shared among all instances of the class, all instances with the same input arguments will reference the same object in memory, which is the cached instance.

It's worth noting that this behavior is not specific to caching classes with lru_cache in Python, but is a general behavior of caching objects in memory. If you cache an object in memory and retrieve it using the same key, you will always get the exact same object instance in memory.