Where is it better to declare variables within a Python class?

Question

When I write a class, I declare a some variables within the __init__ method and some other in the other functions. So, I usually end up with something like this:

class Foo:
    def __init__(self,a, b):
        self.a=a
        self.b=b
    def foo1(self,c, d)
        sum=self.a+self.b+c+d
        foo2(sum)
    def foo2(self,sum)
        print ("The sum is ", sum)

I find this way a bit messy because it gets difficult to keep track of all variables. In contrary, managing variables when they are declared within the __init__ method becomes more easy. So, instead of the previous form, we would have:

class Foo:
    def __init__(self,a, b, c, d, sum):
        self.a=a
        self.b=b
        self.c=c
        self.d=d
        self.sum=sum
    def foo1(self)
        self.sum=self.a+self.b+self.c+self.d
        foo2(self.sum)
    def foo2(self)
        print ("The sum is ", self.sum)

Which one would you choose and why? Do you think declaring all the variables of all functions of the class in the __init__ method would be a better practice?

Answer 1

Your sum is a good candidate for a computed value i.e. method that acts like class variable (not method). This can be done by @property

class Foo(object):
    def __init__(self, a, b):
        self.a = a
        self.b = b

    @property
    def sum(self)
        return self.a + self.b

f = Foo(1, 2)
print 'The sum is' + f.sum

http://docs.python.org/2/library/functions.html#property

Answer 2

There are at least three aspects to this:

• From a design standpoint your constructor should only define variables, that are used at least in two methods in your class or that convey an essential characteristic of the thing you try to model.
• From a performance point of view, you should use variables with the smallest scope possible, it saves lookups.
• Keeping the variables local, keeps the cognitive load low.