one-time initialization of class members

1 view
Skip to first unread message

James Turk

unread,
Jun 13, 2007, 6:08:14 PM6/13/07
to
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

unread,
Jun 13, 2007, 6:54:01 PM6/13/07
to

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

unread,
Jun 13, 2007, 7:55:02 PM6/13/07
to

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

unread,
Jun 13, 2007, 8:00:08 PM6/13/07
to
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

unread,
Jun 13, 2007, 8:12:48 PM6/13/07
to

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

unread,
Jun 13, 2007, 9:03:50 PM6/13/07
to

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

unread,
Jun 13, 2007, 9:18:04 PM6/13/07
to pytho...@python.org
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

unread,
Jun 13, 2007, 9:43:04 PM6/13/07
to
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

unread,
Jun 13, 2007, 11:42:36 PM6/13/07
to
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

unread,
Jun 14, 2007, 10:22:36 AM6/14/07
to

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.

Reply all
Reply to author
Forward
0 new messages