How can I memoize a class instantiation in Python?

Question

Ok, here is the real world scenario: I'm writing an application, and I have a class that represents a certain type of files (in my case this is photographs but that detail is irrelevant to the problem). Each instance of the Photograph class should be unique to the photo's filename. The problem is, when a user tells my application to load a file, I need to be able to identify when files are already loaded, and use the existing instance for that filename, rather than create duplicate instances on the same filename. To me this seems like a good situation to use memoization, and there's a lot of examples of that out there, but in this case I'm not just memoizing an ordinary function, I need to be memoizing `__init__()`. This poses a problem, because by the time `__init__()` gets called it's already too late as there's a new instance created already. In my research I found Python's `__new__()` method, and I was actually able to write a working trivial example, but it fell apart when I trie…

Accepted Answer

Let us see two points about your question.

Using memoize

You can use memoization, but you should decorate the class, not the `__init__` method. Suppose we have this memoizator:

```
def get_id_tuple(f, args, kwargs, mark=object()):
    """ 
    Some quick'n'dirty way to generate a unique key for an specific call.
    """
    l = [id(f)]
    for arg in args:
        l.append(id(arg))
    l.append(id(mark))
    for k, v in kwargs:
        l.append(k)
        l.append(id(v))
    return tuple(l)

_memoized = {}
def memoize(f):
    """ 
    Some basic memoizer
    """
    def memoized(*args, **kwargs):
        key = get_id_tuple(f, args, kwargs)
        if key not in _memoized:
            _memoized[key] = f(*args, **kwargs)
        return _memoized[key]
    return memoized
```

Now you just need to decorate the class:

```
@memoize
class Test(object):
    def __init__(self, somevalue):
        self.somevalue = somevalue
```

Let us see a test?

```
tests = [Test(1), Test(2), Test(3), Test(2), Test(4)]
for test in tests:
    print test.somevalue, id(test)
```

The output is below. Note that the same parameters yield the same id of the returned object:

```
1 3072319660
2 3072319692
3 3072319724
2 3072319692
4 3072319756
```

Anyway, I would prefer to create a function to generate the objects and memoize it. Seems cleaner to me, but it may be some irrelevant pet peeve:

```
class Test(object):
    def __init__(self, somevalue):
        self.somevalue = somevalue

@memoize
def get_test_from_value(somevalue):
    return Test(somevalue)
```

Using `__new__`:

Or, of course, you can override `__new__`. Some days ago I posted an answer about the ins, outs and best practices of overriding `__new__` that can be helpful. Basically, it says to always pass `*args, **kwargs` to your `__new__` method.

I, for one, would prefer to memoize a function which creates the objects, or even write a specific function which would take care of never recreating a object to the same parameter. Of course, however, this is mostly a opinion of mine, not a rule.

How can I memoize a class instantiation in Python?

Solution

Problem

Related problems