iNTRODUCATION TO PYTHON IN PROGRAMMING LANGUAGE

Python: An Introduction Python: An Introduction Shubin Liu, Ph.D. Research Computing Center University of North Carolina at Chapel Hill

its.unc.edu 2 Agenda  Introduction  Running Python  Python Programming •Data types •Control flows •Classes, functions, modules  Hands-on Exercises The PPT/WORD format of this presentation is available here: http://its2.unc.edu/divisions/rc/training/scientific/ /afs/isis/depts/its/public_html/divisions/rc/training/scientific/short_courses/

its.unc.edu 3 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

its.unc.edu 4 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)!

its.unc.edu 5 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

its.unc.edu 6 Language properties  Everything is an object  Modules, classes, functions  Exception handling  Dynamic typing, polymorphism  Static scoping  Operator overloading  Indentation for block structure

its.unc.edu 7 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

its.unc.edu 8 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

its.unc.edu 9 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

its.unc.edu 10 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…

its.unc.edu 11 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

its.unc.edu 12 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!

its.unc.edu 14 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

its.unc.edu 15 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

its.unc.edu 16 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]

its.unc.edu 17 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]

its.unc.edu 18 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 *

its.unc.edu 19 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

its.unc.edu 20 Comments  Start with # and go to end of line  What about C, C++ style comments? •NOT supported!

its.unc.edu 22 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!

its.unc.edu 23 Simple data types  Numbers •Integer, floating-point, complex!  Strings •characters are strings of length 1  Booleans are False or True

its.unc.edu 24 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)

its.unc.edu 25 Strings and formatting i = 10 d = 3.1415926 s = "I am a string!" print "%dt%ft%s" % (i, d, s) print “newlinen" print "no newline"

its.unc.edu 26 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

its.unc.edu 27 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]

its.unc.edu 28 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

its.unc.edu 29 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"

its.unc.edu 30 Simple Data Types •Triple quotes useful for multi-line strings >>> s = """ a long ... string with "quotes" or anything else""" >>> s ' a long012string with "quotes" or anything else' >>> len(s) 45

its.unc.edu 31 Methods in string  upper()  lower()  capitalize()  count(s)  find(s)  rfind(s)  index(s)  strip(), lstrip(), rstrip()  replace(a, b)  expandtabs()  split()  join()  center(), ljust(), rjust()

its.unc.edu 32 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

its.unc.edu 33 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"]

its.unc.edu 34 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]

its.unc.edu 35 Operations in List  Indexing e.g., L[i]  Slicing e.g., L[1:5]  Concatenation e.g., L + L  Repetition e.g., L * 5  Membership test e.g., ‘a’ in L  Length e.g., len(L)  append  insert  index  count  sort  reverse  remove  pop  extend

its.unc.edu 36 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

its.unc.edu 37 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"]

its.unc.edu 38 Methods in Dictionary  keys()  values()  items()  has_key(key)  clear()  copy()  get(key[,x])  setdefault(key[,x])  update(D)  popitem()

its.unc.edu 39 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

its.unc.edu 40 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

its.unc.edu 41 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)

its.unc.edu 42 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

its.unc.edu 43 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}

its.unc.edu 44 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

its.unc.edu 45 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.

its.unc.edu 46 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.

its.unc.edu 47 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

its.unc.edu 48 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

its.unc.edu 49 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)

its.unc.edu 50 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

its.unc.edu 51 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

its.unc.edu 52 Defining a class class Thingy: """This class stores an arbitrary object.""" def __init__(self, value): """Initialize a Thingy.""" self.value = value def showme(self): """Print this object to stdout.""" print "value = %s" % self.value constructor method

its.unc.edu 53 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

its.unc.edu 54 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"

its.unc.edu 55 "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

its.unc.edu 56 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

its.unc.edu 57 Control flow (3)  while loops a = 10 while a > 0: print a a -= 1

its.unc.edu 58 Control flow (4)  for loops for a in range(10): print a  really a "foreach" loop

its.unc.edu 59 Control flow (5)  Common for loop idiom: a = [3, 1, 4, 1, 5, 9] for i in range(len(a)): print a[i]

its.unc.edu 60 Control flow (6)  Common while loop idiom: f = open(filename, "r") while True: line = f.readline() if not line: break # do something with line

its.unc.edu 61 Control flow (7): odds & ends  continue statement like in C  pass keyword: if a == 0: pass # do nothing else: # whatever

its.unc.edu 62 Defining functions def foo(x): y = 10 * x + 2 return y  All variables are local unless specified as global  Arguments passed by value

its.unc.edu 63 Executing functions def foo(x): y = 10 * x + 2 return y print foo(10) # 102

its.unc.edu 64 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

its.unc.edu 65 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

its.unc.edu 66 Modules  Access other code by importing modules import math print math.sqrt(2.0)  or: from math import sqrt print sqrt(2.0)

its.unc.edu 67 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

its.unc.edu 68 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

its.unc.edu 69 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.]]

its.unc.edu 70 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.]]

its.unc.edu 71 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()

its.unc.edu 72 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.

its.unc.edu 73 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]

its.unc.edu 74 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/

its.unc.edu 75 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"

its.unc.edu 76 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

its.unc.edu 77 Try-Finally: Cleanup f = open(file) try: process_file(f) finally: f.close() # always executed print "OK" # executed on success only

its.unc.edu 78 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

its.unc.edu 79 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

its.unc.edu 80 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

its.unc.edu Questions & Comments Please direct comments/questions about research computing to E-mail: research@unc.edu Please direct comments/questions pertaining to this presentation to E-Mail: shubin@email.unc.edu The PPT file of this presentation is available here: http://its2.unc.edu/divisions/rc/training/scientific/short_courses/Python_intro.ppt

its.unc.edu 82 The PPT/WORD format of this presentation is available here: http://its2.unc.edu/divisions/rc/training/scientific/ /afs/isis/depts/its/public_html/divisions/rc/training/scientific/short_courses/ Hands-On Exercises  26 codes at /netscr/training/Python  Copy to your own /netscr/$USER  Read, understand, and then run them  Suggested order: • hello, input, print, readwrite • number, string_test, sort • list, dictionary, tuple, function, class • loop, fact, … • calculator, guess, prime_number • matrix, opt, leastsq

iNTRODUCATION TO PYTHON IN PROGRAMMING LANGUAGE

More Related Content

Similar to iNTRODUCATION TO PYTHON IN PROGRAMMING LANGUAGE

Recently uploaded

iNTRODUCATION TO PYTHON IN PROGRAMMING LANGUAGE

Editor's Notes