James Turk wrote:
> It actually occured to me that I could use a @classmethod to do the
> loading and take that out of the BaseClass constructor. What I have
> makes more sense and eliminates the unecessary constructors.
>> ie.
>> class BaseClass:
> @classmethod
> def loadData(params):
> #expensive load here
>> class ChildClass1(BaseClass):
> dataset = BaseClass.loadData(params)
>> This is pretty much along the lines of what you suggested, thank you
> for the hint in the right direction.
>> I realized that this still doesn't meet my needs exactly as I only
> want the expensive dataset to be loaded if/when a class is actually
> used (there are potentially many of these and only a few will be
> used).
Seems like you want a lazy class attribute. How about something like::
>>> class LazyClassAttribute(object):
... def __init__(self, func):
... self.func = func
... def __get__(self, obj, cls=None):
... value = self.func(cls)
... setattr(cls, self.func.__name__, value)
... return value
...
>>> class Base(object):
... @LazyClassAttribute
... def dataset(cls):
... print 'calculating dataset'
... return 'dataset(%s)' % cls.params
...
>>> class Child1(Base):
... params = 'foo'
...
>>> class Child2(Base):
... params = 'bar'
...
>>> Child1.dataset
calculating dataset
'dataset(foo)'
>>> Child1.dataset
'dataset(foo)'
>>> Child2.dataset
calculating dataset
'dataset(bar)'
>>> Child2.dataset
'dataset(bar)'
The idea is basically similar to the @classmethod approach except that
instead of @classmethod, we use a custom descriptor that calls the
method the first time it's accessed and then stores that value
afterwards. This means that instead of explicitly calling the
@classmethod, the method will be called whenever the attribute is first
accessed.
STeVe