Proper class initialization

[Christoph Zwerschke]

Usually, you initialize class variables like that:

class A:
sum = 45

But what is the proper way to initialize class variables if they are the
result of some computation or processing as in the following silly
example (representative for more:

class A:
sum = 0
for i in range(10):
sum += i

The problem is that this makes any auxiliary variables (like "i" in this
silly example) also class variables, which is not desired.

Of course, I could call a function external to the class

def calc_sum(n):
...

class A:
sum = calc_sum(10)

But I wonder whether it is possible to put all this init code into one
class initialization method, something like that:

class A:

@classmethod
def init_class(self ):
sum = 0
for i in range(10):
sum += i
self.sum = sum

init_class()

However, this does not work, I get
TypeError: 'classmethod' object is not callable

Is there another way to put an initialization method for the class A
somewhere *inside* the class A?

-- Christoph

[Jack Diederich]

On Wed, Mar 01, 2006 at 09:25:36PM +0100, Christoph Zwerschke wrote:

Usually, you initialize class variables like that:

class A:
sum = 45

But what is the proper way to initialize class variables if they are the
result of some computation or processing as in the following silly
example (representative for more:

class A:
sum = 0
for i in range(10):
sum += i

The problem is that this makes any auxiliary variables (like "i" in this
silly example) also class variables, which is not desired.

Of course, I could call a function external to the class

def calc_sum(n):
...

class A:
sum = calc_sum(10)

But I wonder whether it is possible to put all this init code into one
class initialization method, something like that:
Yes, it is called a meta class.
class A:

@classmethod
def init_class(self ):
sum = 0
for i in range(10):
sum += i
self.sum = sum

init_class()

However, this does not work

What we normally think of as an instance is an instance of a class.
Classes are actually instances of metaclasses. What you are looking for
is __init__, but not the __init__ defined after 'class A...' you want
the __init__ that is called when you type 'class A....'

Python 2.4.1 (#2, Mar 30 2005, 21:51:10)
[GCC 3.3.5 (Debian 1:3.3.5-8ubuntu2)] on linux2
Type "help", "copyright" , "credits" or "license" for more information.

class MyMeta(type): .... def __init__(cls, *ignored):
.... cls.sum = 0
.... for (i) in range(10):
.... cls.sum += i
.... class A(object): .... __metaclass__ = MyMeta
.... print A.sum 45 print A.i Traceback (most recent call last):
File "<stdin>", line 1, in ?
AttributeError: type object 'A' has no attribute 'i'

For something as simple as this example it is easier and cleaner
to move the loop into a function and do the one-liner assignment.
Because the metaclass can do _anything_ to the class the reader
is obliged to go read its code. The simple assignment from a
function obviously has no side effects.

Hope that helps,

-jackdied

[Larry Bates]

Christoph Zwerschke wrote:

Usually, you initialize class variables like that:

class A:
sum = 45

But what is the proper way to initialize class variables if they are the
result of some computation or processing as in the following silly
example (representative for more:

class A:
sum = 0
for i in range(10):
sum += i

The problem is that this makes any auxiliary variables (like "i" in this
silly example) also class variables, which is not desired.

Of course, I could call a function external to the class

def calc_sum(n):
...

class A:
sum = calc_sum(10)

But I wonder whether it is possible to put all this init code into one
class initialization method, something like that:

class A:

@classmethod
def init_class(self ):
sum = 0
for i in range(10):
sum += i
self.sum = sum

init_class()

However, this does not work, I get
TypeError: 'classmethod' object is not callable

Is there another way to put an initialization method for the class A
somewhere *inside* the class A?

-- Christoph

Although I've never had the need for something like this,
this works:

class A:
sum=0
for i in range(10):
sum+=i
del i

or moving the initialization into __init__ method isn't
terribly inefficient unless are are creating LOTS of
instances of the same class.

class A:
def __init__(self):
self.sum=0
for i in range(10):
self.sum+=i
or you can do the do it before you instantiate the class

class A:
def __init__(self, initialvalue=No ne):
if initialvalue is not None: self.sum=initia lvalue
else: self.sum=0
for i in range(10):
sum+=i

b=A(sum)
c=A(sum)

-Larry Bates

[Christoph Zwerschke]

Jack Diederich wrote:

... __metaclass__ = MyMeta

Thanks. I was not aware of the __metaclass__ attribute. Still a bit
complicated and as you said, difficult to read, as the other workarounds
already proposed. Anyway, this is probably not needed so often.

-- Christoph

[Steven Bethard]

Christoph Zwerschke wrote:

But I wonder whether it is possible to put all this init code into one
class initialization method, something like that:

class A:

@classmethod
def init_class(self ):
sum = 0
for i in range(10):
sum += i
self.sum = sum

init_class()

I don't run into this often, but when I do, I usually go Jack
Diederich's route::

class A(object):
class __metaclass__(t ype):
def __init__(cls, name, bases, classdict):
cls.sum = sum(xrange(10))

But you can also go something more akin to your route::

class A(object):
def _get_sum():
return sum(xrange(10))
sum = _get_sum()

Note that you don't need to declare _get_sum() as a classmethod, because
it's not actually a classmethod -- it's getting used before the class
yet exists. Just write it as a normal function and use it as such --
that is, no ``self`` or ``cls`` parameter.

STeVe

[Leif K-Brooks]

Steven Bethard wrote:

class A(object):
def _get_sum():
return sum(xrange(10))
sum = _get_sum()

What's wrong with sum = sum(xrange(10)) ?

[Steven Bethard]

Leif K-Brooks wrote:

Steven Bethard wrote:

class A(object):
def _get_sum():
return sum(xrange(10))
sum = _get_sum()

What's wrong with sum = sum(xrange(10)) ?

Nothing, except that it probably doesn't answer the OP's question. The
OP presented a "silly example":

class A:
sum = 0
for i in range(10):
sum += i

I assume the intention was to indicate that the initialization required
multiple statements. I just couldn't bring myself to write that
horrible for-loop when the sum() function is builtin. ;)

STeVe

[Christoph Zwerschke]

Steven Bethard wrote:

I assume the intention was to indicate that the initialization required
multiple statements. I just couldn't bring myself to write that
horrible for-loop when the sum() function is builtin. ;)

Yes, this was just dummy code standing for something that really
requires multiple statements and auxiliary variables.

-- Christoph

[Christoph Zwerschke]

Steven Bethard wrote:

I don't run into this often, but when I do, I usually go Jack
Diederich's route::

class A(object):
class __metaclass__(t ype):
def __init__(cls, name, bases, classdict):
cls.sum = sum(xrange(10))
Good idea, that is really nice and readable. Now all the init code is
defined inline at the top of the class definition.
But you can also go something more akin to your route::

class A(object):
def _get_sum():
return sum(xrange(10))
sum = _get_sum()

Note that you don't need to declare _get_sum() as a classmethod, because
it's not actually a classmethod -- it's getting used before the class
yet exists. Just write it as a normal function and use it as such --
that is, no ``self`` or ``cls`` parameter.

Often it's so simple ;-) But the disadvantage is then that you cannot
set the class variables directly inside that function. So if you have to
initialize several of them, you need to define several functions, or
return them as a tuple and it gets a bit ugly. In this case, the first
solution may be better.

-- Christoph

[Kent Johnson]

Steven Bethard wrote:

I don't run into this often, but when I do, I usually go Jack
Diederich's route::

class A(object):
class __metaclass__(t ype):
def __init__(cls, name, bases, classdict):
cls.sum = sum(xrange(10))

I think you should call the superclass __init__ as well:

class __metaclass__(t ype):
def __init__(cls, name, bases, classdict):
super(__metacla ss__, cls).__init__(n ame, bases, classdict)
cls.sum = sum(xrange(10))

Kent