one-time initialization of class members

[James Turk]

Hi,

I have a situation where I have some class members that should only be
done once. Essentially my problem looks like this:

class Base(object):
dataset = None

def __init__(self, param):
if type(self).dataset is None:
# code to load dataset based on param, expensive

class ChildClass1(Base):
def __init__(self):
Base.__init__(self, data_params)

class AnotherChildClass(Base):
def __init__(self):
Base.__init__(self, other_data_params)

This seems to work, initialization is only done at the first creation
of either class. I was just wondering if this is the 'pythonic' way
to do this as my solution does feel a bit hackish.

[Steven Bethard]

What should happen with code like::

ChildClass1('foo')
ChildClass1('bar')

The 'param' is different, but 'dataset' should only get set the first time?

STeVe

[James Turk]

ChildClass doesn't take the parameter in it's constructor, it supplies
it for the BaseClass. Every ChildClass of the same type should use
the same dataset.

[Larry Bates]

I could be missing something but dataset is shared among all the class
instances. If you reset it based on param it will be reset every time
you create a new instance of the Base class with a different param. Is
that really what you want to do? If so just use:

class Base(object):
dataset = None

def __init__(self, param):
if self.dataset is None:

# code to load dataset based on param, expensive

-Larry

[James Turk]

I'm sorry, I somehow omitted the fact that the dataset does indeed
need to vary based on the child class, actually this is the main
difference between child classes.

[Steven D'Aprano]

Then each type of ChildClass should be a sub-class, and provide it's own
dataset:

class BaseClass:
dataset = None
# blah blah blah...

class ChildClass1(BaseClass):
dataset = SomethingUseful

class ChildClass2(BaseClass):
dataset = SomethingElse

--
Steven.

[Gabriel Genellina]

En Wed, 13 Jun 2007 22:03:50 -0300, Steven D'Aprano
<st...@REMOVE.THIS.cybersource.com.au> escribió:

> On Wed, 13 Jun 2007 23:55:02 +0000, James Turk wrote:
>>> James Turk wrote:
>>>
>>> > I have a situation where I have some class members that should only
>>> be
>>> > done once. Essentially my problem looks like this:
>>>

>> ChildClass doesn't take the parameter in it's constructor, it supplies
>> it for the BaseClass. Every ChildClass of the same type should use
>> the same dataset.
>
> Then each type of ChildClass should be a sub-class, and provide it's own
> dataset:
>
>
> class BaseClass:
> dataset = None
> # blah blah blah...
>
>
> class ChildClass1(BaseClass):
> dataset = SomethingUseful
> class ChildClass2(BaseClass):
> dataset = SomethingElse

But the OP also stated that creating the dataset is expensive. The
original code does what you say (each ChildClass is a subclass and
provides its own dataset) so I think is an acceptable solution:

py> def build_dataset(x):
... print "building dataset:",x
... return [x]
...
py> class Base(object):
... dataset = None
... def __init__(self, param):
... if type(self).dataset is None:
... type(self).dataset = build_dataset(param)
...
py> class ChildClass1(Base):
... def __init__(self):
... Base.__init__(self, "Params for ChildClass1")
...
py> class AnotherChildClass(Base):
... def __init__(self):
... Base.__init__(self, "Params for AnotherChildClass")
...
py> c1 = ChildClass1()
building dataset: Params for ChildClass1
py> c2 = AnotherChildClass()
building dataset: Params for AnotherChildClass
py> c3 = ChildClass1()
py> print Base.dataset
None
py> print ChildClass1.dataset
['Params for ChildClass1']
py> print AnotherChildClass.dataset
['Params for AnotherChildClass']
py> print c1.dataset
['Params for ChildClass1']
py> print c3.dataset
['Params for ChildClass1']
py> print c1.dataset is c3.dataset
True
py>

--
Gabriel Genellina

[James Turk]

On Jun 13, 9:03 pm, Steven D'Aprano

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). I believe I have two options:

1) put each ChildClass in a separate file
2) in each ChildClass constructor put a check if the dataset has been
loaded yet, so that the first time an instance is created it can call
the BaseClass.loadData

for now I have chosen the second option, which is to change the child
classes to resemble

class ChildClass(BaseClass):

dataset = None

def __init__(self):
if BaseClass.dataset is None:
self(type).dataset = BaseClass.loadData(params)

I am still doing the self(type) access, but I like it more now that
I've taken it out of the BaseClass constructor.

[Steven Bethard]

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

[James Turk]

This is a pretty interesting idea, I hadn't thought of using a
decorator to get this behavior. I'm evaluating it and will see if it
fits in with the rest of the system well, but it certainly is a unique
solution to this problem.