I want to create a decorator that works like a property, only it calls the decorated function only once, and on subsequent calls always return the result of the first call. An example:

def SomeClass(object):@LazilyInitializedPropertydef foo(self):print "Now initializing"return 5>>> x = SomeClass()
>>> x.foo
Now initializing
5
>>> x.foo
5

My idea was to write a custom decorator for this. So i started, and this is how far I came:

class LazilyInitializedProperty(object):def __init__(self, function):self._function = functiondef __set__(self, obj, value):raise AttributeError("This property is read-only")def __get__(self, obj, type):# problem: where to store the value once we have calculated it?

As you can see, I do not know where to store the cached value. The simplest solution seems to be to just maintain a dictionary, but I am wondering if there is a more elegant solution for this.

EDIT Sorry for that, I forgot to mention that I want the property to be read-only.

Denis Otkidach's CachedAttribute is a method decorator which makes attributes lazy (computed once, accessible many). To make it also read-only, I added a __set__ method. To retain the ability to recalculate (see below) I added a __delete__ method:

class ReadOnlyCachedAttribute(object):    '''Computes attribute value and caches it in the instance.Source: Python Cookbook Author: Denis Otkidach https://stackoverflow.com/users/168352/denis-otkidachThis decorator allows you to create a property which can be computed once andaccessed many times. Sort of like memoization'''def __init__(self, method, name=None):self.method = methodself.name = name or method.__name__self.__doc__ = method.__doc__def __get__(self, inst, cls): if inst is None:return selfelif self.name in inst.__dict__:return inst.__dict__[self.name]else:result = self.method(inst)inst.__dict__[self.name]=resultreturn result    def __set__(self, inst, value):raise AttributeError("This property is read-only")def __delete__(self,inst):del inst.__dict__[self.name]

For example:

if __name__=='__main__':class Foo(object):@ReadOnlyCachedAttribute# @read_only_lazypropdef bar(self):print 'Calculating self.bar'  return 42foo=Foo()print(foo.bar)# Calculating self.bar# 42print(foo.bar)    # 42try:foo.bar=1except AttributeError as err:print(err)# This property is read-onlydel(foo.bar)print(foo.bar)# Calculating self.bar# 42

One of the beautiful things about CachedAttribute (and ReadOnlyCachedAttribute) is that if you del foo.bar, then the next time you access foo.bar, the value is re-calculated. (This magic is made possible by the fact that del foo.bar removes 'bar' from foo.__dict__ but the property bar remains in Foo.__dict__.)

If you don't need or don't want this ability to recalculate, then the following (based on Mike Boers' lazyprop) is a simpler way to make a read-only lazy property.

def read_only_lazyprop(fn):attr_name = '_lazy_' + fn.__name__@propertydef _lazyprop(self):if not hasattr(self, attr_name):setattr(self, attr_name, fn(self))return getattr(self, attr_name)@_lazyprop.setterdef _lazyprop(self,value):raise AttributeError("This property is read-only")return _lazyprop