questions about programming styles

[Arvind Singh]

On 5/20/07, fdu.xiaojf at gmail.com <fdu.xiaojf at gmail.com> wrote:
> which is the better way to calculate the value of attributes of a class ?
> for example:
>
>  (A)
>     def cal_attr(self, args):
>         #do some calculations
>         self.attr = calculated_value
> and then if the vlue of attribute is needed,
>     self.cal_attr(args)
>     some_var = self.attr
> or I can define cal_attr() as follows:
>  (B)
>     def cal_attr(self, args):
>         #do some calculations
>         return calculated_value
> and then, if the value of attribute is needed,
>     self.attr = self.cal_attr(args)
>     some_var = self.attr

The way, I get it: you are trying to *cache* the value of an
*expensive* calculation. You should worry about it if only if:
a. It is *really* expensive to calculate the value.
b. The value is read more often then it can change.

Otherwise, just don't bother with it (i.e.use some_var = obj.cal_value(*args) ).

But if you really want to cache the value, maybe you should keep track
if the value is valid:

class C(object):
    def calc_attr(self, *args):
        """Calculates value of "attr".
        """
        self._attr = calculated_value
        self._attr_valid = True

    def get_attr(self, *args):
        """Use this to get values."""
        self._attr_valid or self.calc_attr(*args)
        return self._attr

    def another_method(self, *args):
        """Does some calculations which invalidate *cached* value of "attr".
        """
        # do something
        self._attr_valid = False

> (2)
> when to use class methods and when to use functions ?
>
> In my opinion, both of class methods and functions have advantages and
> disadvantages. I have to pass many arguments to a function, which is
> annoying. When using class methods, the arguments can be stored as
> attributes of the class, which is convenient for later use. But I have
> to create an object in advance.


I hope you know about all of it, but here it is, anyway:

- In Python, *everything* is an object.
- Whenever Python finds a class definition, it creates a *class object*.
- A class objects acts as a *template* to create new objects called
*instances* (of that class).
- The template and the instance can both have *attributes* (to store data).
- *Class attributes* can be accessed by both -- class as well as its instances.
- *Instance attributes* can only be accesses by instances (because
class doesn't have to know about these).
- All the class attributes are shared among all the instances. If you
change an attribute of a class, all the instances of that class
(irrespective of when they were instantiated) will see the change.

That gives us:
- *Instance methods* (or simply, "methods") can access: class
attributes, instance attributes, class methods, and instance methods.
(And are accessible via an instance only.)
- *Class methods* can ONLY access class attributes or other class
methods. (And are accessible via the class or its instance.)
- The first argument to instance methods is traditionally called
"self" (which is an *instance object*) and that of class methods is
called "cls" (which is a *class object*).


Design choices:
- The data which is to be shared by all the instances (and is mostly
immutable) should be kept as class attribute (to minimize memory
consumption).
- The methods which should produce same result for all instances (and
don't need to access instance attributes) should be declared as class
methods.
- Class attributes are also useful to *share state* among various
instances (so that they can co-operate). Such "sharing functionality"
is mostly implemented as class methods.


It's just whatever I could recollect and thought might be relevant. I
hope it helps.

Arvind


PS: Defining something as "property" suggests (to the class users)
that it is inexpensive to access that value -- just a matter of style.