Python: An Introduction

Agenda
• Introduction
• Running Python
• Python Programming
– Data types
– Control flows
– Classes, functions, modules
• Hands-on Exercises
 Course Goals
• To understand the basic structure and syntax
of Python programming language
• To learn how to run Python scripts on our
research computing facility, the Emerald Linux
cluster
• To write your own simple Python scripts.
• To serve as the starting point for more
advanced training on Python coding
 What is python?
• Object oriented language
• Interpreted language
• Supports dynamic data type
• Independent from platforms
• Focused on development time
• Simple and easy grammar
• High-level internal object data types
• Automatic memory management
• It’s free (open source)!
 Timeline
• Python born, name picked - Dec 1989
– By Guido van Rossum, now at GOOGLE
• First public release (USENET) - Feb 1991
• python.org website - 1996 or 1997
• 2.0 released - 2000
• Python Software Foundation - 2001
• …
• 2.4 released - 2004
• 2.5 released – 2006
• Current version: 2.6.x
 Language properties
• Everything is an object
• Modules, classes, functions
• Exception handling
• Dynamic typing, polymorphism
• Static scoping
• Operator overloading
• Indentation for block structure
 High-level data types
• Numbers: int, long, float, complex
• Strings: immutable
• Lists and dictionaries: containers
• Other types for e.g. binary data, regular
expressions, introspection
• Extension modules can define new “built-in”
data types
 Why learn python?
• Fun-to-use "Scripting language"
• Object-oriented
– Highly educational
• Very easy to learn
• Powerful, scalable, easy to maintain
– high productivity
– Lots of libraries
• Glue language
– Interactive front-end for FORTRAN/C/C++ code
 Why learn python? (cont.)
• Reduce development time
• Reduce code length
• Easy to learn and use as developers
• Easy to understand codes
• Easy to do team projects
• Easy to extend to other languages
 Where to use python?
• System management (i.e., scripting)
• Graphic User Interface (GUI)
• Internet programming
• Database (DB) programming
• Text data processing
• Distributed processing
• Numerical operations
• Graphics
• And so on…
 Python vs. Perl
– Easier to learn
• important for occasional users
– More readable code
• improved code maintenance
– Fewer “magical” side effects
– More “safety” guarantees
– Better Java integration
– Less Unix bias
 Python vs. Java
– Code 5-10 times more concise
– Dynamic typing
– Much quicker development
• no compilation phase
• less typing
– Yes, it runs slower
• but development is so much faster!
– Similar (but more so) for C/C++
• Use Python with Java: JPython!
 Agenda
• Introduction
• Running Python
• Python Programming
– Data types
– Control flows
– Classes, functions, modules
• Hands-on Exercises
 Running Python Interactively
• Start python by typing "python"
– /afs/isis/pkg/isis/bin/python
• ^D (control-D) exits
• % python
• >>> ^D
• %
• Comments start with ‘#’
• >>> 2+2 #Comment on the same line as text
• 4
• >>> 7/3 #Numbers are integers by default
• 2
• >>> x = y = z = 0 #Multiple assigns at once
• >>> z
• 0
 Running Python Programs
• In general
• % python ./myprogram.py
• Can also create executable scripts
– Compose the code in an editor like vi/emacs
• % vi ./myprogram.py # Python scripts with the suffix .py.
– Then you can just type the script name to execute
• % python ./myprogram.py
• The first line of the program tells the OS how to execute it:
• #! /afs/isis/pkg/isis/bin/python
– Make the file executable:
• % chmod +x ./myprogram.py
– Then you can just type the script name to execute
• % ./myprogram.py
 Running Python Programs
Interactively
Suppose the file script.py contains the following lines:
print 'Hello world'
x = [0,1,2]
Let's run this script in each of the ways described on the last slide:
• python -i script.py
Hello world
>>> x
[0,1,2]

• $ python
>>> execfile('script.py')
>>> x
[0,1,2]
 Running Python Programs
Interactively
Suppose the file script.py contains the following lines:
print 'Hello world'
x = [0,1,2]
Let's run this script in each of the ways described on the last slide:
• python
>>> import script # DO NOT add the .py suffix. Script is a module here
>>> x
Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: name 'x' is not defined
>>> script.x # to make use of x, we need to let Python know which
#module it came from, i.e. give Python its context
[0,1,2]
 Running Python Programs
Interactively
# Pretend that script.py contains multiple stored quantities. To promote x(and only x) to
the top level context, type the following:
• $ python
>>> from script import x
Hello world
>>> x
[0,1,2]
>>>
# To promote all quantities in script.py to the top level context, type
from script import * into the interpreter. Of course, if that's what you
want, you might as well type python -i script.py into the terminal.
>>> from script import *
 File naming conventions
• python files usually end with the suffix .py
• but executable files usually don’t have the .py
extension
• modules (later) should always have the .py extension
 Comments

• Start with # and go to end of line

• What about C, C++ style comments?

– NOT supported!
 Agenda
• Introduction
• Running Python
• Python Programming
– Data types
– Control flows
– Classes, functions, modules
• Hands-on Exercises
 Python Syntax
• Much of it is similar to C syntax
• Exceptions:
– missing operators: ++, --
– no curly brackets,{}, for blocks; uses
whitespace
– different keywords
– lots of extra features
– no type declarations!
 Simple data types

• Numbers
– Integer, floating-point, complex!

• Strings
– characters are strings of length 1

• Booleans are False or True

 Numbers
• The usual notations and operators
• 12, 3.14, 0xFF, 0377, (-1+2)*3/4**5, abs(x), 0<x<=5

• C-style shifting & masking

• 1<<16, x&0xff, x|1, ~x, x^y
• Integer division truncates :-(
• 1/2 -> 0 # float(1)/2 -> 0.5
• Long (arbitrary precision), complex
• 2L**100 -> 1267650600228229401496703205376L
• 1j**2 -> (-1+0j)
 Strings and formatting
i = 10
d = 3.1415926
s = "I am a string!"
print "%d\t%f\t%s" % (i, d, s)
print “newline\n"
print "no newline"
 Variables
• No need to declare
• Need to assign (initialize)
• use of uninitialized variable raises exception
• Not typed
if friendly: greeting = "hello world"
else: greeting = 12**2
print greeting
• Everything is a variable:
• functions, modules, classes
 Reference semantics
• Assignment manipulates references
• x = y does not make a copy of y
• x = y makes x reference the object y references
• Very useful; but beware!
• Example:
>>> a = [1, 2, 3]; b = a
>>> a.append(4); print b
[1, 2, 3, 4]
 Simple data types: operators

• + - * / % (like C)
• += -= etc. (no ++ or --)
• Assignment using =
– but semantics are different!
a = 1
a = "foo" # OK
• Can also use + to concatenate strings
 Strings
• "hello"+"world" "helloworld" # concatenation
• "hello"*3 "hellohellohello" # repetition
• "hello"[0] "h" # indexing
• "hello"[-1] "o" # (from end)
• "hello"[1:4] "ell" # slicing
• len("hello") 5 # size
• "hello" < "jello" 1 # comparison
• "e" in "hello" 1 # search
• New line: "escapes: \n "
• Line continuation: triple quotes ’’’
• Quotes: ‘single quotes’, "raw strings"
 Simple Data Types
– Triple quotes useful for multi-line strings
>>> s = """ a long
... string with "quotes" or
anything else"""
>>> s
' a long\012string with "quotes"
or anything else'
>>> len(s)
45
 Methods in string

• upper()  strip(), lstrip(), rstrip()

• lower()  replace(a, b)
• capitalize()  expandtabs()
• count(s)  split()
• find(s)  join()
• rfind(s)  center(), ljust(), rjust()
• index(s)
 Compound Data Type: List
• List:
– A container that holds a number of other objects, in a
given order
– Defined in square brackets
a = [1, 2, 3, 4, 5]
print a[1] # number 2
some_list = []
some_list.append("foo")
some_list.append(12)
print len(some_list) # 2
 List
• a = [99, "bottles of beer", ["on", "the", "wall"]]
• Flexible arrays, not Lisp-like linked lists
• Same operators as for strings
• a+b, a*3, a[0], a[-1], a[1:], len(a)
• Item and slice assignment
• a[0] = 98
• a[1:2] = ["bottles", "of", "beer"]
-> [98, "bottles", "of", "beer", ["on", "the", "wall"]]
• del a[-1] # -> [98, "bottles", "of", "beer"]
 More list operations
>>> a = range(5) # [0,1,2,3,4]
>>> a.append(5) # [0,1,2,3,4,5]
>>> a.pop() # [0,1,2,3,4]
5
>>> a.insert(0, 5.5) # [5.5,0,1,2,3,4]
>>> a.pop(0) # [0,1,2,3,4]
5.5
>>> a.reverse() # [4,3,2,1,0]
>>> a.sort() # [0,1,2,3,4]
 Operations in List
 append • Indexing e.g., L[i]
 insert • Slicing e.g., L[1:5]
 index • Concatenation e.g., L + L
 count • Repetition e.g., L * 5
 sort • Membership test e.g., ‘a’ in L
 reverse • Length e.g., len(L)
 remove
 pop
 extend
 Nested List
• List in a list
• E.g.,
– >>> s = [1,2,3]
– >>> t = [‘begin’, s, ‘end’]
– >>> t
– [‘begin’, [1, 2, 3], ‘end’]
– >>> t[1][1]
–2
 Dictionaries
• Dictionaries: curly brackets
– What is dictionary?
• Refer value through key; “associative arrays”
– Like an array indexed by a string
– An unordered set of key: value pairs
– Values of any type; keys of almost any type
• {"name":"Guido", "age":43, ("hello","world"):1,
42:"yes", "flag": ["red","white","blue"]}
d = { "foo" : 1, "bar" : 2 }
print d["bar"] # 2
some_dict = {}
some_dict["foo"] = "yow!"
print some_dict.keys() # ["foo"]
 Methods in Dictionary
• keys()
• values()
• items()
• has_key(key)
• clear()
• copy()
• get(key[,x])
• setdefault(key[,x])
• update(D)
• popitem()
 Dictionary details
• Keys must be immutable:
– numbers, strings, tuples of immutables
• these cannot be changed after creation
– reason is hashing (fast lookup technique)
– not lists or other dictionaries
• these types of objects can be changed "in place"
– no restrictions on values
• Keys will be listed in arbitrary order
– again, because of hashing
 Tuples
• What is a tuple?
– A tuple is an ordered collection which cannot
be modified once it has been created.
– In other words, it's a special array, a read-only array.
• How to make a tuple? In round brackets
– E.g.,
>>> t = ()
>>> t = (1, 2, 3)
>>> t = (1, )
>>> t = 1,
>>> a = (1, 2, 3, 4, 5)
>>> print a[1] # 2
 Operations in Tuple

• Indexing e.g., T[i]

• Slicing e.g., T[1:5]
• Concatenation e.g., T + T
• Repetition e.g., T * 5
• Membership test e.g., ‘a’ in T
• Length e.g., len(T)
 List vs. Tuple
• What are common characteristics?
– Both store arbitrary data objects
– Both are of sequence data type
• What are differences?
– Tuple doesn’t allow modification
– Tuple doesn’t have methods
– Tuple supports format strings
– Tuple supports variable length parameter in function
call.
– Tuples slightly faster
 Data Type Wrap Up
• Integers: 2323, 3234L
• Floating Point: 32.3, 3.1E2
• Complex: 3 + 2j, 1j
• Lists: l = [ 1,2,3]
• Tuples: t = (1,2,3)
• Dictionaries: d = {‘hello’ : ‘there’, 2 : 15}
 Data Type Wrap Up
• Lists, Tuples, and Dictionaries can store any
type (including other lists, tuples, and
dictionaries!)
• Only lists and dictionaries are mutable
• All variables are references
 Input

• The raw_input(string) method returns a line

of user input as a string
• The parameter is used as a prompt
• The string can be converted by using the
conversion methods int(string),
float(string), etc.
 File I/O

f = file("foo", "r")
line = f.readline()
print line,
f.close()
# Can use sys.stdin as input;
# Can use sys.stdout as output.
 Files: Input
input = open(‘data’, ‘r’) Open the file for input

S = input.read() Read whole file into

one String
S = input.read(N) Reads N bytes
(N >= 1)
L = input.readlines() Returns a list of line
strings
 Files: Output

output = open(‘data’, ‘w’) Open the file for

writing
output.write(S) Writes the string S to
file
output.writelines(L) Writes each of the
strings in list L to file
output.close() Manual close
 open() and file()

• These are identical:

f = open(filename, "r")
f = file(filename, "r")
• The open() version is older
• The file() version is the recommended
way to open a file now
– uses object constructor syntax (next lecture)
 OOP Terminology

• class -- a template for building objects

• instance -- an object created from the template
(an instance of the class)
• method -- a function that is part of the object and
acts on instances directly
• constructor -- special "method" that creates new
instances
 Objects
• Objects:
– What is an object?
• data structure, and
• functions (methods) that operate on it
class thingy:
# Definition of the class here, next slide
t = thingy()
t.method()
print t.field
• Built-in data structures (lists, dictionaries) are also objects
– though internal representation is different
 Defining a class

class Thingy:
"""This class stores an arbitrary object."""
def __init__(self, value):
constructor
"""Initialize a Thingy."""
self.value = value
def showme(self): method

"""Print this object to stdout."""

print "value = %s" % self.value
 Using a class (1)
t = Thingy(10) # calls __init__ method
t.showme() # prints "value = 10"
• t is an instance of class Thingy
• showme is a method of class Thingy
• __init__ is the constructor method of class Thingy
– when a Thingy is created, the __init__ method is called
• Methods starting and ending with __ are "special" methods
 Using a class (2)

print t.value # prints "10"

– value is a field of class Thingy

t.value = 20 # change the field value
print t.value # prints "20"
 "Special" methods

• All start and end with __ (two underscores)

• Most are used to emulate functionality of built-in
types in user-defined classes
• e.g. operator overloading
– __add__, __sub__, __mult__, ...
– see python docs for more information
 Control flow (1)
• if, if/else, if/elif/else
if a == 0:
print "zero!"
elif a < 0:
print "negative!"
else:
print "positive!"

 Notes:
• blocks delimited by indentation!
• colon (:) used at end of lines containing control flow keywords
 Control flow (3)

• while loops

a = 10
while a > 0:
print a
a -= 1
 Control flow (4)

• for loops

for a in range(10):
print a

• really a "foreach" loop

 Control flow (5)

• Common for loop idiom:

a = [3, 1, 4, 1, 5, 9]
for i in range(len(a)):
print a[i]
 Control flow (6)

• Common while loop idiom:

f = open(filename, "r")
while True:
line = f.readline()
if not line:
break
# do something with line
 Control flow (7): odds & ends

• continue statement like in C

• pass keyword:
if a == 0:
pass # do nothing
else:
# whatever
 Defining functions

def foo(x):
y = 10 * x + 2
return y
• All variables are local unless
specified as global
• Arguments passed by value
 Executing functions

def foo(x):
y = 10 * x + 2
return y

print foo(10) # 102

 Why use modules?
• Code reuse
– Routines can be called multiple times within a program
– Routines can be used from multiple programs
• Namespace partitioning
– Group data together with functions used for that data
• Implementing shared services or data
– Can provide global data structure that is accessed by
multiple subprograms
 Modules
• Modules are functions and variables defined in separate files
• Items are imported using from or import
• from module import function
• function()

• import module
• module.function()
• Modules are namespaces
– Can be used to organize variable names, i.e.
• atom.position = atom.position - molecule.position
 Modules

• Access other code by importing modules

import math
print math.sqrt(2.0)
• or:
from math import sqrt
print sqrt(2.0)
 Modules
• or:
from math import *
print sqrt(2.0)
• Can import multiple modules on one line:
import sys, string, math
• Only one "from x import y" per line
 Example: NumPy Modules
• http://numpy.scipy.org/
• NumPy has many of the features of Matlab, in a free, multiplatform
program. It also allows you to do intensive computing operations in a
simple way
• Numeric Module: Array Constructors
– ones, zeros, identity
– arrayrange
• LinearAlgebra Module: Solvers
– Singular Value Decomposition
– Eigenvalue, Eigenvector
– Inverse
– Determinant
– Linear System Solver
 Arrays and Constructors
• >>> a = ones((3,3),float)
• >>> print a
• [[1., 1., 1.],
• [1., 1., 1.],
• [1., 1., 1.]]
• >>> b = zeros((3,3),float)
• >>> b = b + 2.*identity(3) #"+" is overloaded
• >>> c = a + b
• >>> print c
• [[3., 1., 1.],
• [1., 3., 1.],
• [1., 1., 3.]]
 Overloaded operators
• >>> b = 2.*ones((2,2),float) #overloaded
• >>> print b
• [[2.,2.],
• [2.,2.]]
• >>> b = b+1 # Addition of a scalar is
• >>> print b # element-by-element
• [[3.,3.],
• [3.,3.]]
• >>> c = 2.*b # Multiplication by a scalar is
• >>> print c # element-by-element
• [[6.,6.],
• [6.,6.]]
 Array functions
• >>> from LinearAlgebra import *
• >>> a = zeros((3,3),float) + 2.*identity(3)
• >>> print inverse(a)
• [[0.5, 0., 0.],
• [0., 0.5, 0.],
• [0., 0., 0.5]]
• >>> print determinant(inverse(a))
• 0.125
• >>> print diagonal(a)
• [0.5,0.5,0.5]
• >>> print diagonal(a,1)
• [0.,0.]
– transpose(a), argsort(), dot()
 Eigenvalues
• >>> from LinearAlgebra import *
• >>> val = eigenvalues(c)
• >>> val, vec = eigenvectors(c)
• >>> print val
• [1., 4., 1.]
• >>> print vec
• [[0.816, -0.408, -0.408],
• [0.575, 0.577, 0.577],
• [-0.324, -0.487, 0.811]]
– also solve_linear_equations, singular_value_decomposition, etc.
 Least Squares Fitting
• Part of Hinsen's Scientific Python module
• >>> from LeastSquares import *
• >>> def func(params,x): # y=ax^2+bx+c
• return params[0]*x*x + params[1]*x +
• params[2]
• >>> data = []
• >>> for i in range(10):
• data.append((i,i*i))
• >>> guess = (3,2,1)
• >>> fit_params, fit_error =
• leastSquaresFit(func,guess,data)
• >>> print fit_params
• [1.00,0.000,0.00]
 FFT
• >>> from FFT import *
• >>> data = array((1,0,1,0,1,0,1,0))
• >>> print fft(data).real
• [4., 0., 0., 0., 4., 0., 0., 0.]]

• Also note that the FFTW package ("fastest Fourier transform in the West")
has a python wrapper. See notes at the end
• Python Standard Libraries/Modules:
– http://docs.python.org/library/
– http://its2.unc.edu/dci/dci_components/shared_apps/packages/python
_packages.html
– http://pypi.python.org/pypi/
 Command-line arguments
import sys
print len(sys.argv) # NOT argc
# Print all arguments:
print sys.argv
# Print all arguments but the program
# or module name:
print sys.argv[1:] # "array slice"
 Catching Exceptions
#python code a.py
x = 0
try:
print 1/x
except ZeroDivisionError, message:
print "Can’t divide by zero:"
print message
>>>python a.py
Can't divide by zero:
integer division or modulo by zero
 Try-Finally: Cleanup

f = open(file)
try:
process_file(f)
finally:
f.close() # always executed
print "OK" # executed on success only
 Raising Exceptions
• raise IndexError
• raise IndexError("k out of range")
• raise IndexError, "k out of range”
• try:
something
except: # catch everything
print "Oops"
raise # reraise
 Python: Pros & Cons
• Pros
– Free availability (like Perl, Python is open source).
– Stability (Python is in release 2.6 at this point and, as I noted earlier, is older
than Java).
– Very easy to learn and use
– Good support for objects, modules, and other reusability mechanisms.
– Easy integration with and extensibility using C and Java.
• Cons
– Smaller pool of Python developers compared to other languages, such as Java
– Lack of true multiprocessor support
– Absence of a commercial support point, even for an Open Source project
(though this situation is changing)
– Software performance slow, not suitable for high performance applications
 References
– Python Homepage
• http://www.python.org
– Python Tutorial
• http://docs.python.org/tutorial/
– Python Documentation
• http://www.python.org/doc
– Python Library References
• http://docs.python.org/release/2.5.2/lib/lib.html
– Python Add-on Packages:
• http://pypi.python.org/pypi