Python Tutorial for CS114

Python at Brandeis

Python should be available on both SG and Linux workstations in the Berry Patch (slate, granite, capri, quartz, talc; psyche, calypso, circe, calliope, orestes, theseus, electra, alcestis, cleo, medea, antiope, penelope, iphitus, omphale). To run Python on any CS machine, type python at the prompt.

To use Python from xemacs:

Python Documentation and Tutorials

You can invoke the interpreter as follows:

• To access interactive mode (command-line interface):

  
  [your_handle@cleo ~]$ python
  Python 1.5.2 (#1, Feb  1 2000, 16:32:16)  [GCC egcs-2.91.66
  19990314/Linux (egcs- on linux-i386
  Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
  >>> _
  
  

  In interactive mode, the interpreter can be used as calculator:

  >>> a = 3
  >>> a
  3
  >>> 3*3
  9
  

• Files containing python code traditionally have the extension .py. To run a file with your code:

  
  [yourhandle@cleo ~]$ python <filename>.py <arg1>
  <arg2>
  
  

  If you prefer to enter the interactive mode after your file has been executed, use:

  
  [yourhandle@cleo ~]$ python -i <filename>.py <arg1>
  <arg2>
  
  

• To turn your file into an executable script, modify the permissions appropriately (chmod u+x <filename>), and add the following standard shell instruction to the top of your file:

  
  #!/usr/bin/python
  

To exit from the interpreter: C-d

You can import standard modules or your own files. To import the whole module:

>>> import sys
>>> sys.argv
[<filename>.py, <arg1>, <arg2>]

To import a particular variable or function:

>>> from sys import exit
>>> exit()
[yourhandle@cleo ~]$ _

Basics

Indentation after a colon is used to mark blocks:

if a < 0:
    print "a is negative"
else:
    print "a is non-negative"    

Variables don't have types, so no variable declarations are necessary.

Numeric types are standard, except long integers have unlimited precision in Python:

>>> a = 44444444444444444422222222222222222444444444444444444L
>>> a * a
1975308641975308640000000000000000020246913580246913530864197530864197599999999999999999802469135802469136L

Python has the following built-in data types:

Strings

Lists

Tuples

Dictionaries

The first 3 types are sequence types, and are basically similar to arrays in other programming languages. Strings are arrays of characters. Tuples and lists are arrays of arbitrary values. Consequently, tuples and lists can be nested. Strings and tuples are immutable. That is, e.g. unlike in C, you can not assign Lists are mutable.

• Strings

  
  >>> a = "There is no \"place\" like home"
  >>> a
  'There is no "place" like home'
  >>> b = "There's no place like home"
  >>> b
  "There's no place like home"
  >>> c = 'There\'s no place like home'
  >>> c
  "There's no place like home"
  

  All standard escape sequences apply to Python strings:

  
  >>> a = "blah\tblah"
  >>> a
  'blah\011blah'
  >>> print a
  blah	blah
  

  Lists

  
  >>> alist = ['There', 'is', 'no', 'place', 'like', 'home']
  >>> blist = ['There', 0.34]
  >>> clist = [['There', 0.34], ['is', 0.57]]
  >>> dlist = [('There', 0.34), ('is', 0.57)]
  

  Tuples

  
  >>> atuple = ('There', 0.34)
  >>> btuple = ('bigram', [('There', 'is'), 0.34])
  

  Sequence types are indexed as arrays:

  
  >>> a 
  'There is no "place" like home'
  >>> a[0]
  'T'
  >>> a[1]
  'h'
  >>> alist
  ('There', 'is', 'no', 'place', 'like', 'home')
  >>> alist[0]
  >>> btuple
  ('bigram', [('There', 'is'), 0.34])
  >>> btuple[1]
  [('There', 'is'), 0.34]
  

  You can obtain slices of a given sequence with the slicing operator ":". The second argument is non-inclusive, i.e. alist[m:n] gets you the portion of the list containing all elements beginning with position m and ending with position n-1. Either argument can be omitted.

  
  >>> a[:4]
  >>> alist
  ['There', 'is', 'no', 'place', 'like', 'home']
  >>> alist[0:3]
  ['There', 'is', 'no']
  >>> alist[:3]
  ['There', 'is', 'no']
  >>> alist[2:]
  ['no', 'place', 'like', 'home']
  >>> a
  'There is no "place" like home'
  >>> a[:4]
  'Ther'
  

  Slices of any sequence type can be concatenated using "+":

  
  >>> (1, 2) + (3, 4)
  (1, 2, 3, 4)
  

  Lists are mutable, i.e. you can modify any element of the list and also modify slices of lists:

  
  >>> alist = [1, 2, 3, 4, 5]
  >>> alist[0] = 'a'
  >>> alist[1:3] = ['b', 'c']
  >>> alist
  ['a', 'b', 'c', 4, 5]
  

  Also, the List data type has methods such as append(x), insert(i, x), index(x), sort(), etc.

  
  >>> a = ['There', 'is', 'no', 'place', 'like', 'home']
  >>> a.sort()
  >>> a
  ['There', 'home', 'is', 'like', 'no', 'place']
  

  Dictionaries

  Dictionaries are associative arrays or hashes. Any immutable Python object can be used as a key in a dictionary.

  
  >>> adict = {}
  >>> bdict = {"home": [1.12, 2.34], ('home', 'NN'): .45}
  >>> bdict[('home', 'NN')]
  0.45
  >>> bdict['home']
  [1.12, 2.34]
  

Truth Values and Boolean Operations

The following values are false in Python:

None

zero of any numeric type

any empty sequence or mapping

All other values are true (except for instances of user-defined classes, if that class defines a __nonzero__() method or a __len__() method, and that method returns zero)

Boolean operations: not, and, or

>>> a = '' 
>>> b = 32
>>> a or b
32
>>> a or not b
0

For sequences, there is a membership testing operator in:

>>> b = 32
>>> b in [21, 32]
1

You can also compare sequence objects of the same type (using lexicographic order):

>>> (1, 2, ('aa', 'ab')) < (1, 2, ('abc', 'a'), 4)
1

Control Flow

All the standard loop and conditional constructs are present:

• if

  
  if not a == 0:
     print b/float(a)
  else:
     print "Attempted division by 0!"
  

• while

  
  while (a % 2 == 0):
     a = a/2
  

• for

  A Perl loop that iterates over the elements of an array

  
  foreach $elem (@myarray) {..}
  

  translates into Python as:

  
  myarray = [e1, e2, e3]
  for e in myarray:
     <do the loop commands>
  

  If you wish to iterate over a list that is being changed within the loop, iterate over its copy:

  
  myarray = [e1, e2, e3]
  for e in myarray[:]:
     <do the loop commands>
  

  In Python, one customarily uses range() function for the loop variable in for loop.

  
  >>> range(10)
  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  >>> range(5, 10)
  [5, 6, 7, 8, 9]
  >>> range(0, 10, 3)
  [0, 3, 6, 9]
  >>> range(-10, -100, -30)
  [-10, -40, -70]
  

  A standard C/Java/Perl style loop

  
  for(i = 0; i < n; i++) {
     <do the loop commands>
  }
  

  translates into Python as:

  
  for i in range(n):
     <do the loop commands>
  

• continue, break, else clause

  These are used just like in C. Else clause on loops is executed only if the loop was not exited through break:

  
  >>> for n in range(2, 10):
  ...     for x in range(2, n):
  ...         if n % x == 0:
  ...            print n, 'equals', x, '*', n/x
  ...            break
  ...     else:
  ...          print n, 'is a prime number'
  ... 
  2 is a prime number
  3 is a prime number
  4 equals 2 * 2
  5 is a prime number
  6 equals 2 * 3
  7 is a prime number
  8 equals 2 * 4
  9 equals 3 * 3
  

Functions

Python allows default arguments:

>>> def modsum(a, b, c = 10):
...     return (a+b)%c
... 
>>> modsum(22, 33)
5

By the way, Python allows function objects to returned or stored in variables:

>>> def square(x): return x*x
>>> def cube(x): return x*x*x
>>> def compose(f1, f2):
...     return lambda x, f1=f1, f2=f2: f1(f2(x))
>>> f = compose(square, cube)
>>> f(2)
64    

Reading and writing files

Printing in Python is easy:

>>> x = 10 * 3.14
>>> y = 200 * 200
>>> s = 'The value of x is ' + `x` + ', and y is ' + `y` + '...'
>>> print s
The value of x is 31.400000000000002, and y is 40000...

Note that in the above writing `x` is the same as str(x), the latter being an builtin function. So

>>> s = 'The value of x is ' + `x` + ', and y is ' + `y` + '...'

>>> s = 'The value of x is ' + str(x) + ', and y is ' + str(y) + '...'

You can also build strings with standard C-style format strings:

>>> x = math.pi
>>> a = '%f %f %f' % (x, x*x, x*x*x)
>>> print a
3.141593 9.869604 31.006277

Some common commands for dealing with file objects:

• open() returns a file object , and is most commonly used with two arguments: "open(filename, mode)".

  
  >>> f=open('/tmp/workfile', 'w')
  

• f.read(size), which reads some quantity of data and returns it as a string. size is an optional numeric argument. When size is omitted or negative, the entire contents of the file will be read and returned

  
  >>> f.read()
  'This is the entire file.\n'
  

• f.readline() reads a single line from the file; a newline character (\n) is left at the end of the string

  
  >>> f.readline()
  'This is the first line of the file.\n'
  

• f.write(string) writes the contents of string to the file, returning None.

  
  >>> f.write('This is a test\n')
  

• f.close() is used to... close the file.

Some relevant modules

string

>>> from string import split
>>> split("There is no place like home")
['There', 'is', 'no', 'place', 'like', 'home']