Comments

I've already spoken about comments in the 'More Sequences' section. However there are more things we can do with comments and I'll enlarge on those here:

Version history information

It ius good practice to create a file header at the start of each file. This should provide details such as the creation daye, author, date, version and a general description of the contents. Often a log of changes. This block will appear as a comment:

#############################
# Module:   Spam.py
# Author:   A.J.Gauld
# Date:     1999/09/03
# Version:  Draft 0.4
#
# Description: This module provides a Spam object which can be
# combined with any other type of Food object to create
# interesting meal combinations.
#
###############################
# Log:
# 1999/09/01    AJG - File created
# 1999/09/02    AJG - Fixed bug in pricing strategy
# 1999/09/02    AJG - Did it right this time!
# 1999/09/03    AJG - Added broiling method(cf Change Req #1234)
################################
import sys, string, food
...

Commenting out redundant code

This technique is often used to isolate a faulty section of code. For example, assume a program reads some data, processes it, prints the output and then saves the results back to the data file. If the results are not what we expect it would be useful to temporarily prevent the (erroneous)data being saved back to the file and thus corrupting it. We could simply delete the relevant code but a less radical approach is simply to convert the lines into comments like so:

data = readData(datafile)
for item in data:
    results.append(calculateResult(item))
printResults(results)
######################
# Comment out till bug in calculateResult fixed
# for item in results:
#     dataFile.save(item)
######################
print 'Program terminated'

Once the fault has been fixed we can simply delete the comment markers to make the code active once more.

Documentation strings

All languages allow you to create comments to document what a function or module does, but a few such as Python and Smalltalk go one stage further and allow you to document the function in a way that the language/environment can use to provide interactive help while programming. In Python this is done using the """documentation""" string style:

class Spam:
    """A meat for combining with other foods
    
    It can be used with other foods to make interesting meals.
    It comes with lots of nutrients and can be cooked using many
    different techniques"""
    
    def __init__(self):
        ...

print Spam.__doc__

Note: We can access the documentation string by printing the special __doc__ variable. Modules, Functions and classes/methods can all have documentation strings. For example try:

import sys
print sys.__doc__

Indentation

This is one of the most hotly debated topics in programming. It almost seems that every programmer has his/her own idea of the best way to indent code. As it turns out there have been some studies done that show that at least some factors are genuinely important beyond cosmetics - ie they actually help us understand the code better.

The reason for the debate is simple. In most programming languages the indentation is purely cosmetic; an aid to the reader. (In Python it is in fact needed and is essential to proper working of the program!) Thus:

 
FOR I = 1 TO 10
    PRINT I
NEXT I

Is exactly the same as:

FOR I = 1 TO 10
PRINT I
NEXT I

so far as the BASIC interpreter is concerned. Its just easier for us to read with indentation.

The key point is that indentation should reflect the logical structure of the code thus visually it should follow the flow of the program. To do that it helps if the blocks look like blocks thus:

XXXXXXXXXXXXXXXXXXXX
    XXXXXXXXXXXXXXXX
    XXXXXXXXXXXXXXXX
    XXXXXXXXXXXXXXXX

which reads better than:

XXXXXXXXXXXXXXXXXXXXX
  XXXXX
    XXXXXXXXXXXX
    XXXXXXXXXXXX
    XXXXXXXXXXXX
  XXXXX

because its clearly all one block. Studies have shown significant improvements in comprehension when indenting reflects the logical block structure. In the small samples we've seen so far it may not seem important but when you start writing programs with hundreds or thousands of lines it will become much more so.

Variable Names

The variable names we have used so far have been fairly meaningless, mainly because they had no meaning but simply illustrated techniques. In general its much better if your variable names reflect what you want them to represent. For example in our times table exercise we used 'multiplier' as the variable to indicate which table we were printing. That is much more meaningful than simply 'm' - which would have worked just as well and been less typing.

Its a trade-off between comprehensibility and effort. Generally the best choice is to go for short but meaningfull names. Too long a name becomes confusing and is difficult to get right consistently(for example I could have used the_table_we_are_printing instead of multiplier but it's far too long and not really much clearer.

Modular Programming

I'll explain this in more detail later but for now I simply want to describe the concept and importantly how we can use modules to save our work - currently all your programs have been lost as soon as you exit Python.

While the Python interactive interpreter prompt (>>>) is very useful for trying out ideas quickly, it loses all you type the minute you exit. In the longer term we want to be able to write programs and then run them over and over again. To do this in Python we create a text file with an extension .py (this is a convension only, you could use anything you like. But it's a good idea to stick with convention in my opinion...). You can then run your programs from a command prompt by typing:
$ python spam.py
Where spam.py is the name of your Python program file.

Note for Unix users: The first line of a Python script file should contain the sequence #! followed by the full path of python on your system. (You can find that by typing $ which python at your shell prompt.)

On my system the line looks like:
#! /usr/local/bin/python
This will allow you to run the file without calling Python at the same time:
$ spam.py
This line doesn't do any harm under Windows/Mac either, so those users can put it in too if their code is likely to ever be run on a unix box.

Note for Windows users: Under Windows you can set up an association for files ending .py within Explorer. This will allow you to run Python programs by simply double clicking the file's icon. This should already have been done by the installer. You can check by finding some .py files and trying to run them. If they start (even with a Python error message) it's set up.

The other advantage of using files to store the programs is that you can edit mistakes without having to retype the whole fragment or, in IDLE, cursor all the way up past the errors to reselect the code. IDLE supports having a file open for editing and running it from the 'Edit|Run module' menu.

From now on I won't normally be showing the >>> prompt in examples, I'll assume you are creating the programs in a separate file and running them either within IDLE or from a command prompt (my personal favourite).