Scripts and Utilities -- Python lecture

Why is Python Great?

1. It can be used as a scripting language, like Awk or Perl. However, Python has more general data types than either Awk or Perl and hence is applicable to a much broader problem domain. Python also reads like a real programming language, unlike either Awk or Perl. Consequently, someone with C experience can look at a Python program and figure out what it is doing, unlike either Awk or Perl.

2. Python is interpreted, which can save you considerable time during program development because compiling and linking are unnecessary. Python also has a command-line interpreter so you can try out Python language features and perform quick computations.

3. Python programs can be developed much more rapidly than C programs, are more concise than C programs, and are easier to read than C programs, because:
   • Python contains very high-level data types, such as lists and hash tables (called dictionaries) that allow complicated sequences in C to be expressed in single statements in Python.

   • Python groups statements using indentation rather than begin/end brackets. Hence, you do not encounter those mysterious C errors in which you've indented the code in the way you intend it to run, but because of badly placed brackets, the code runs in some other way.

   • Python does not require any variable or argument declarations. It also does not require any type declarations.

   • Python has some neat syntactic tricks that allow you to do incredibly useful things to lists and strings.

Getting Started With Python

To try out Python, type python at the Unix prompt. You will see something like:

Python 1.4 (Jun 30 1997)  [GCC 2.7.2.1]
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>> 

Learning about Python

The developer of Python, Guido van Rossum, has written an excellent introductory tutorial to Python. Rather than try to regurgitate it in the lecture notes, I will just point you to the appropriate link, http://tecfa.unige.ch/guides/python/tut.

In these lecture notes, I will concentrate on some of the really neat things that I've found I can do in Python:

Using Lists as Arrays

Lists are probably Python's most useful compound data structure. Python does not provide a general array data structure (it has specialized arrays for integers) but a list can be subscripted just like an array so I always use lists to simulate arrays. Remember that while using lists to simulate arrays may not be the most efficient thing in the world, I am interested in rapid prototyping and program development, not efficiency.

Lists are written as a list of comma-separated elements enclosed in square brackets:

>>> a = [10, 20, 'brad', 'knoxville']
>>> a
[10, 20, 'brad', 'knoxville']
>>> a[1]
20
>>> a[-1]   # a negative subscript starts from the end of the list
'knoxville'

>>> a[:2]
[10, 20]
>>> a[2:]
['brad', 'knoxville']

partition(a[i:j])

Simplified Boolean Expressions

In C, one is forever using and and or statements to construct boolean expressions. Often these and's and or's obfuscate relatively simple expressions. For example, if I want to test if a grade is between 90 and 100, I have to write:

if ((grade > 90) && (grade <= 100))

if (90 < grade <= 100)

Python can also make or conditions easier to write and understand. Suppose I want to determine if the variable x is equal to the integers 10, 20, or 30. In C I would have to write:

if ((x == 10) || (x == 20) || (x == 30))

if x in [10, 20, 30]

Iterating over Sets and Lists

A lot of algorithms that you see in textbooks require that you process every element in a set or list. Python's for statement iterates over the items in a sequence and hence makes it easy to mimic the set and list iterations one finds in a textbook. For example, a depth-first search of a graph starts from a node and visits each of its neighbors in a depth-first fashion. If we assume that each node contains a visited field and a neighbors field, which is a list of neighbors, then a depth-first search procedure can be written succinctly in Python as follows:

true = 1
false = 0

def dfs(node):
    node.visited = true
    for neighbor in node.neighbors:
	if neighbor.visited == false:
	    dfs(neighbor)

Mimicing Structs

Python does not have the C equivalent of struct, but it does support classes and a class can be used to mimic a struct. Unlike C, you can associate a function with the class (the function is actually called a method) that initializes an instance of a class when an instance is allocated. For example, suppose we want to define the node data structure for the depth-first search described above. In C the declaration might look as follows:

struct node {
    int visited;
    struct neighbor_list *neighbors;
};

class node:
    pass

x = node()
x.visited = false
x.neighbors = []

class node:
    def __init__(self):
        self.visited = false
	self.neighbors = []

x = node()

Else Clauses on Loops

Loop statements may have an else clause attached to them that is executed if either a list is exhausted in the case of a for loop or a condition becomes false in the case of a while loop. The else clause is not executed if a break causes a premature exit from the loop. Combining a break statement with an else clause allows one to avoid the inelegant code often associated with setting and testing the value of a flag variable. For example, suppose I want to write a naive procedure that determines whether a variable is a prime number or not. If the number is prime, the procedure should print that the number is prime. If the number is not prime, the procedure should print the number's factors. In C, the procedure might look as follows:

int is_prime(int n) {
    int i, prime_flag;

    prime_flag = 1;
    for (i = 2; (i < n) && (prime_flag == 1); i++) {
        if ((n % x) == 0) {
	    printf("%d equals %d * %d\n", n, x, n / x);
	    prime_flag = 0;
	}
    }
    if (prime_flag == 1) 
        printf("%d is a prime number\n", n);
}

def is_prime(n):
    for i in range(2, n):
        if n % i == 0:
	    print n, 'equals', i, '*', n/i
	    break
    else:
        print n, 'is a prime number'

Reading from a File or Stdin

Python does not have the C equivalent of scanf. However, it does provide a way to read lines from a file or stdin, and then to extract information from these strings using regular expressions. Consequently, Python has a more powerful input and scanning mechanism than C, but it is somewhat more difficult to learn.

Files

Python supports a file object which is described in the Python reference manual in section 2.1.7. File objects are implemented using C's stdio package. Perhaps the most useful command is readline(), which returns the next line in a file, as a string. For example:

>>> my_file = open('/azure/homes/bvz/temp', 'r')
>>> line = my_file.readline()
>>> line
'Dear Dr. Tripathi, \012'

Standard Input

The stdin file object may be found in sys.stdin. For example:

>>> a = sys.stdin.readline()

Regular Expressions and String Operations

Once a string has been read into a variable, fields may be extracted from the string using either Python's string package or its regular expression package. If the fields are separated by blanks, commas, etc., then one can simply use the find method in the string module to extract fields (see section 4.1 of the Python reference manual). For example:

>>> import string
>>> blank_position = string.find(line, ' ')
>>> field1 = line[0 : blank_position]
>>> field1
'Dear'
>>> old_blank_position = blank_position
>>> blank_position = string.find(line, ' ', blank_position+1)
>>> field2 = line[old_blank_position+1 : blank_position]
>>> field2
'Dr.'

If your input is more complicated, you will need to use Python's regular expressions, which, unfortunately, are like Emacs regular expressions rather than Unix regular expressions. You will need to read sections 4.2 and 4.3 of the Python reference manual and know something about Emacs to use this facility.