Department of Mathematics and Computer Science

Math 169 Notes -- Python

Contents

• A. "Hello World!" in Python
• B. History
• C. Identifiers
• D. Reserved Words
• E. Output Function
• F. Program Structure
• G. Functions
• H. Comments
• I. Statements
• J. Variables
• K. Input Functions
• L. File I/O
• M. Lists
• N. Control Structures
• ---1. While Loops
• ---2. If-then-else
• ---3. For Loops
• O. Arithmetic Expressions, Binary Operators
• P. Numerical Comparisons
• Q. Dictionaries
• R. Strings
• S. Functions in the module string
• T. Regular Expressions and Pattern Matching
• U. The exec and eval Statements

A. "Hello World!" in Python

Interactive mode:

          print "Hello world!"

          def greeting():
	       print "Hello world!"

          greeting()

         #! /usr/bin/python
	 print "Hello world!"

B. History

Unlike many languages, Python (like LISP) can be used in an interactive mode. One can also create functions to be stored in independent files and imported into the Python environment for execution.

C. Identifiers

D. Reserved Words

Python reserved words are written with all lower case letters.

E. Output Function

Output to a file is addressed in a separate section below.

F. Program Structure

A Python program can be written as a collection of commands and statements or structures within the interactive environment. These commands can also be put in a separate file which can be invoked from the interpreter. Another alternative is to write a collection of procedures within a file (with extension .py) and import the file, and then invoke the procedures.

As with other languages, when writing a long program, it is good to structure it as a set of interrelated procedures/functions some of which call others. Usually Python programmers make use of the IDLE Python GUI enabling a programmer to save code and to debug easily.

The starting function may be given any name. Many programmers, however, following the C/C++/Java style, label the main function "main."

One imports a module by using the keyword import followed by the file name (without extension .py). In this case, one invokes any function by including the filename followed by a dot and then the function name. For example, if file mymath.py contains a function area to compute the area of a circle with input r being the value of the radius, then one must type

      import mymath
      mymath.area(4)

One can avoid repeating the file name when using functions it contains by specifying functions explicitly or using the wildcard symbol *. In other words, one may type

      from mymath import area
      area(4)

      from mymath import *
      area(4)

G. Functions

Functions can explicitly return a value by using the reserved word return before the identifier storing the value to be returned.

For example,

	def factorial(n):
	    r = 1
	    while n > 0:
                  r = r * n
                  n = n - 1
	    return r

Parameters are passed via call by value only. As with Fortran-90, one can also label the parameters when invoking a function (and the parameters are not in order).

H. Comments

I. Statements

If a statement needs to run over more than one line, one places the backslash character \ at the end of the line to be continued. The backslash is not used if the split occurs within grouping symbols, i.e., ( ), [ ], or { }. The continued line is indented. For example,

      x = [1, 2, 3, 4,
            5, 6]
      y = 123 + 34.0/456.7 - \
            54.2

J. Variables and Data Types

        def main():
		i = 1
		print i
		i = "hello"
		print i
        main()		

	1
	hello

Strings are enclosed in single quotes (and can have embedded double quotes), or in double quotes (and can have embedded single quotes), or in triple double quotes (and can have embedded newlines). One can include the C/C++ backslash escape characters in strings, e.g., \n, \t, \\, \', etc.

(Short) Integers are as in other languages. They are written without any decimal point and store about 9 digits accuracy.

Long Integers are designated by a trailing lower-case or upper-case L, as in 3L or 1234567890123456L. These are integers with unlimited precision.

Floats are numbers including a decimal point. Floats will automatically shift from single precision to double precision as needed.

Complex Numbers are written as the sum of the real and imaginery parts with the convention that the imaginery number is designated (as in most Engineering disciplines) as j rather than i, so one writes 3 + 2j for example. (Note that standard math functions in the math modules do not take complex arguments; instead one must import the complex math module, cmath, and specially designate functions from that module, e.g., cmath.sqrt(-1).)

By default all variables are local to each separate function. Identifiers that have been given a value in the main level are visible to a function when it is invoked. If a function uses an identifier already in use at the main level, that local identifier does not affect the other identifier's value. One can determine all visible variables/identifiers and their values via the commands globals() and locals().

Variables are usually created when a function is called and destroyed when it is completed.

K. Input Functions

      x = float(raw_input("enter a number:"))

In short segments, for keyboard input, one can also use the function input which takes a character string argument to be displayed on the screen. It will convert input to the appropriate data type (include a string enclosed in quotes). For example,

      x = input("enter a number:")

Note that a character string entered without enclosing quotes will result in an error message.

For various reasons, several authors (including the notes at the main Python web site, http://www.python.org/doc/current/lib/built-in-funcs.html [see the entry for input] ) warn about possible errors when using input and recommend using raw_input instead.

L. File I/O

        myinfile = open("textfile.txt",'r')

       line = myinfile.readline()

       myoutfile.write("The end of the output.\n")

       myinfile.close()

M. Lists

        x = [1, 2, 3]

Like with arrays in C/C++ (and other languages), elements in a Python list can be accessed directly via a subscript enclosed in square brackets (starting at 0 as with C/C++), e.g., x[0].

Like in LISP, a Python list can have elements of different data types, including lists. It does not have to be declared before use, and, in fact, can be expanded or condensed after being created. For example

        x = [1, 2.5, 90000000L, "hello"]

        x = [[1,2,3], [11,22,33],"hello"]
        x[1][2]

Operations on lists can be done via assignments or via functions (i.e., variable methods).

The length of a list x is obtained via the function len(x).

To append to the end of a list, one can write

        x[len(x):] = [5, 6, 7]

        x.append(5)
        x.append(6)
        x.append(7)

        x[:0] = [-1, 0]

        x.insert(0,0)
        x.insert(0,-1)

        x.insert(2,"goodbye")

        x[2:4] = []

        del x[2:4]

         x.remove(3)

One can reverse elements in a list, or sort elements in a list, or find the maximum/minimum elements in a list using built-in methods and functions. For example,

         x.reverse()        
         x.sort()
         xmin = min(x)
         xmax = max(x)

         3 in x
         2 not in x

One can concatenate two lists using the plus sign. For example,

         z = [0, 1, 2, 3] + [4, 5, 6, 7]

         z = [1, 3] * 4

Other list functions and methods can be found in a Python book or web search.

N. Control Structures

Moreover, each "header" line (i.e., a line beginning with a keyword) must end with a colon.

1. While loops are similar to while loops in other languages with the following changes. The expression after the reserved word "while" can be any conditional expression (no parentheses are needed). A while statement can have an optional "else:" clause that is executed once when the condition fails. The "body" of the while segment can include the keywords break (which completely terminates the structure, including any else clause) or continue (which terminates the remainder of that iteration of the loop and restarts the loop from the condition again).

As an example, the following is taken from the sample function given above:

	    while n > 0:
	          r = r * n
	          n = n - 1

2. If-then-else structures are used as in Pascal/Fortran-90/C/C++. The "else" clause is optional.

The keyword then is not used (similar to C/C++).

An "else if" clause may be included (with another condition), but the keyword is written elif.

3. For Loops in Python are both similar and dissimilar to counted loops in other languages.

The major similarity is that such loops are repeated a set number of times. The major dissimilarity is that the determination of the frequency of the repetition of the loop is significantly augmented from what is available in other languages.

The syntax of the for loop includes the keyword for followed by a loop variable, followed by the keyword in, followed by a sequence from which the loop variable takes its values, followed by the colon (on the header line). Following this header line, the body of the loop appears, indented. An else: clause may follow as with the while loop.

Most generally, one determine a sequence which constitutes the range of numbers that the loop variable can take on. For example,

        x = [1.0, 2.0, 3.0]
        for n in x:
           print 1/n

Programmers often make use of the range function to obtain a continuous set of values. For example range(len(x)) would produce a sequence of integers corresponding to the subscript range of the list x (i.e., its "length" assuming the initial value corresponds to subscript 0).

One can also use range with two arguments, indicating the starting value and the upper value (that is not included). For example, range(2,6) results in the list [2,3,4,5].

One can also use range with three arguments, indicating the the starting value, the final value (not included), and the step value (as with Fortran), which may be negative. Thus, range(6,1,-2) produces the list [6, 4, 2].

Instead of using the function range (which constructs and stores the values specified), one may use the function xrange which does not really store the values specified, but creates them as needed for a for. The function xrange is slower than range but saves memory.

O. Arithmetic Expressions, Binary Operators

+	addition
-	subtraction
*	multiplication
/	division
%	"mod", i.e., remainder after division
**	exponentiation

P. Numerical Comparisons

<	less than
<=	less than or equal to
==	equal to
>	greater than
>=	greater than or equal to
!=	not equal to

	1 <= n <= 10

The standard logical operators and, or, and not are part of the language. Other character and symbolic operators are part of the languages (e.g., in (for set inclusion), ^ (for bitwise exclusive or)). See a complete manual for the full list.

Q. Dictionaries

An empty dictionary is created by associating a name in an assignment statement with curly braces enclosing nothing, e.g.,

              sampledict = {}

              sampledict['sam'] = 'blue'
              sampledict[2] = 'green'

              sampledict = {'sam':'blue',2:'green'}

              sampledict.keys()

One can test for the presence of a specific key (subscript) using the "has_key" method, e.g.,

              sampledict.has_key('sam')

              sampledict.get('sam','Not in Dictionary')

One can also combine two dictionaries using the "update" method. For example, if one wishes to augment dictionary "x" with the contents of dictionary "z", one invokes

              x.update(z)

R. Strings

              x = "Hello"

Attempting to change a character in the string, e.g., via

              x[0]='G'

String operation: Concatenation of two strings can be achieved via the plus operator. Thus,

              y = "John" + "son"

S. Functions in the module string

string.join: This will concatenate into one long string the individual strings given as a list. E.g.,

         string.join(["John", "son"])

string.split: This will split the string provided as an argument at each 'white space', whether the white space is a tab, newline, or blank. Additional arguments are possible to change the "split" character or to determine how many "splits" should take place.

string.atof: This will take a character string (ASCII) and convert it to a FLOAT number.

string.atoi: This will take a character string (ASCII) and convert it to a INTEGER number. An additional parameter will convert the string to the indicated base.

string.atol: This will take a character string (ASCII) and convert it to a LONG INTEGER number.

string.strip: This will take a character string and remove white space at the beginning or end. The related functions string.rstrip and string.lstrip will strip white space from only the right or the left end of the input string.

string.find: This will take two character strings as arguments and returns an integer indicating the beginning location of the second string within the first string. E.g.,

           string.find("Mississippi","ss")

string.replace: This will take three character strings as arguments and creates a new string based on the first string (without actually changing it), in which every occurrance of the second string is replaced by the third. For example,

           string.replace('abracadabra','a','xx')

Other functions enable a programmer to create a "translation" table for characters (e.g., a table relating ( to [, ) to ], ~ to !, etc.), and then invoke this table on a string to "translate" all characters found in the table into their "translation" characters.

SAMPLE CODE

The following example, taken from The Quick Python Book by D. Harms and K. McDonald, illustrates the power of Python in dealing with string and dictionaries. It analyzes a string (in this case the explicit sample string is part of the code), and counts the number of times each word appears in the string. The dictionary occurrences stores the words as keys and associates with each word a number as its value indicating its frequency.

           import string
	   SampleString = "To be or not to be"
	   occurrences = {}
	   for word in string.split(SampleString):
	      occurrences[word]  = occurrences.get(word,0)+1
	   for word in occurrences.keys():
	      print "The word", word, "occurs", \
	           occurrences[word], "time(s) in the string"

T. Regular Expressions and Pattern Matching

For additional information as to how regular expressions are used in Unix/Linux, type man regexp at the Unix/Linux prompt.

Regular expression patterns in Python are similar to those in Unix. For example, ( ) are used to group alternatives separated by |, [ ] are used to group single character alternatives (unless a range is specified with a - (as in a-z), a + after [ ] is used to indicate one or more repetitions of characters within the brackets.

Regular expression functions are included in the re module which must be imported before use. If a regular expression is designated for use, it is usual practice to "compile" the expression to increase the speed of the code. As examples, the following are valid regular expressions:

     regexp1 = re.compile("hello|Hello")
     regexp2 = re.compile("(h|H)ello")
     regexp3 = re.compile("[hH]ello")
     regexp4 = re.compile("[a-zA-Z]+")

The following sample code, taken from The Quick Python Book, shows how to use regular expressions to search through lines of an input file and count how many contain the string "hello."

      import re
      regexp = re.compile("hello")
      count = 0
      file = open("textfile",'r')
      for line in file.readlines():
          if regexp.search(line):
	      count = count + 1
      file.close()
      print count

U. The exec and eval Statements

The eval statement takes an expression (either a literal character string or stored in a variable) within parentheses as an argument to a function and returns the value as if it were typed into the interpreter. For example,

          x=1
          y='x + 2'
          eval(y)

          eval('2 + 3')

The exec statement consists of the keyword exec followed by a statement (either a literal character string or stored in a variable) without parentheses and executes the statement as if it were typed into the interpreter. A Python "statement" usually does not return a value as does an expression. It may, for instance, set a variable to a (new) value or perform some action. For example,

          exec 'x=2'

          c = 'x=2'
          exec c

Alternatively,

          exec 'print "Hello world!"'

          d = "Hello world!"
          exec 'print d'

This page is maintained by Dennis C. Smolarski, S.J. dsmolarski@math.scu.edu
Last updated: 23 October 2005. Minor corrections: 9 November 2005, 31 Jan 2006.