# Understanding Code

Peter Otten __peter__ at web.de
Tue Nov 13 11:41:55 CET 2012

```subhabangalore at gmail.com wrote:

> Dear Group,
> To improve my code writing I am trying to read good codes. Now, I have
> received a code,as given below,(apology for slight indentation errors) the
> code is running well. Now to comprehend the code, I am looking to
> understand it completely.
>
> class Calculate:
>       def __init__(self):
>         self.prior = {}
>         self.total = {}
>         self.count = 0
>         self.prior[cls] = self.prior.get(cls, 0) + 1
>         for idx, val in enumerate(obs):
>             key = cls, idx, val
>             self.total[key] = self.total.get(key, 0) + 1
>         self.count += 1
>       def discr(self, cls, obs):
>         result = self.prior[cls]/self.count
>         for idx, val in enumerate(obs):
>             freq = self.total.get((cls, idx, val), 0)
>             result *= freq/self.prior[cls]
>         return result
>       def classify(self, obs):
>         candidates = [(self.discr(c, obs), c) for c in self.prior]
>         return max(candidates)[1]
>
> I am not understanding many parts of it, I am understanding many parts of
> it also.
>
> So I am looking for an exercise what are the things I should know to
> understand it, (please do not give answers I would get back with the
> answers in a week and would discuss even how to write better than this).

Start with running the code for the simplest piece of the class:
>>> c = Calculate()

Then inspect the attributes:

>>> c.prior
{'x': 1}
>>> c.total
{('x', 2, 3): 1, ('x', 1, 2): 1, ('x', 0, 1): 1}
>>> c.count

>         self.prior[cls] = self.prior.get(cls, 0) + 1

does? Experiment with a dict and its get() method in the interactive
interpreter. Next to the loop.

>         for idx, val in enumerate(obs):
>             key = cls, idx, val
>             self.total[key] = self.total.get(key, 0) + 1
>         self.count += 1

Do you understand what enumerate() does? If not read its documentation with

>>> help(enumerate)

Do you understand what key looks like? If you don't add a print statement

>         for idx, val in enumerate(obs):
>             key = cls, idx, val
print key
>             self.total[key] = self.total.get(key, 0) + 1
>         self.count += 1

What does

>             self.total[key] = self.total.get(key, 0) + 1

do? Note that this line is very similar to

>         self.prior[cls] = self.prior.get(cls, 0) + 1

which you have studied before.

>         self.count += 1

This like the rest of your class is left as an exercise. The routine is
always the same:

- break parts that you don't understand into smaller parts
- consult the documentation on unknown classes, functions, methods,
preferrably with help(some_obj) or dir(some_obj)
- run portions of the code or similar code in the interactive interpreter or
with a little throw-away script.
- add print statements to inspect variables at interesting points in your
script.

```