detly detly - 1 year ago 61
Python Question

Python memoising/deferred lookup property decorator

Recently I've gone through an existing code base containing many classes where instance attributes reflect values stored in a database. I've refactored a lot of these attributes to have their database lookups be deferred, ie. not be initialised in the constructor but only upon first read. These attributes do not change over the lifetime of the instance, but they're a real bottleneck to calculate that first time and only really accessed for special cases. Hence they can also be cached after they've been retrieved from the database (this therefore fits the definition of memoisation where the input is simply "no input").

I find myself typing the following snippet of code over and over again for various attributes across various classes:

class testA(object):

def __init__(self):
self._a = None
self._b = None

def a(self):
if self._a is None:
# Calculate the attribute now
self._a = 7
return self._a

def b(self):

Is there an existing decorator to do this already in Python that I'm simply unaware of? Or, is there a reasonably simple way to define a decorator that does this?

I'm working under Python 2.5, but 2.6 answers might still be interesting if they are significantly different.


This question was asked before Python included a lot of ready-made decorators for this. I have updated it only to correct terminology.

Answer Source

Here is an example implementation of a lazy property decorator:

def lazyprop(fn):
    attr_name = '_lazy_' + fn.__name__
    def _lazyprop(self):
        if not hasattr(self, attr_name):
            setattr(self, attr_name, fn(self))
        return getattr(self, attr_name)
    return _lazyprop

class Test(object):

    def a(self):
        print 'generating "a"'
        return range(5)

Interactive session:

>>> t = Test()
>>> t.__dict__
>>> t.a
generating "a"
[0, 1, 2, 3, 4]
>>> t.__dict__
{'_lazy_a': [0, 1, 2, 3, 4]}
>>> t.a
[0, 1, 2, 3, 4]