Download Introduction to Python

Introduction to Python
Why Python?
Python is a general-purpose interpreted,
interactive, object-oriented, and high-level
programming language. It was created by
Guido van Rossum during 1985- 1990. Like
Perl, Python source code is also available
under the GNU General Public License
(GPL).
 Have your cake and eat it, too:
Productivity and readable code
 VHLLs will gain on system languages
(John Ousterhout)
 "Life's better without braces"
(Bruce Eckel)
Python is Interpreted: Python is processed at
runtime by the interpreter. You do not need
to compile your program before executing
it. This is similar to PERL and PHP.
Python is Interactive: You can actually sit at
a Python prompt and interact with the
interpreter directly to write your programs.
Python is Object-Oriented: Python supports
Object-Oriented style or technique of
programming that encapsulates code
within objects.
Python is a Beginner's Language: Python is a
great language for the beginner-level
programmers and supports the
development of a wide range of
applications from simple text processing to
WWW browsers to games.
Tutorial Outline










interactive "shell"
basic types: numbers, strings
container types: lists, dictionaries, tuples
variables
control structures
functions & procedures
classes & instances
modules & packages
exceptions
files & standard library
$sudo apt-get install python3-minimal
Interactive “Shell”
In the bash shell (Linux): type export
PYTHONPATH=/usr/local/bin/python3.4 and press
Enter.
 Great for learning the language
 Great for experimenting with the library
Unix: IDLE is the very first Unix IDE for Python.
 Great for testing your own modules
 Two variations: IDLE (GUI),
python (command line)
 Type statements or expressions at prompt:
>>> print "Hello, world"
Hello, world
>>> x = 12**2
>>> x/2
72
>>> # this is a comment
#!/usr/bin/python3
print ("Hello, Python!")
Python supports four different numerical types −
Numbers
 The usual suspects
 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 # 1./2. -> 0.5, float(1)/2 -> 0.5
 Will be fixed in the future
 Long (arbitrary precision), complex
 2L**100 ->
1267650600228229401496703205376L
 In Python 2.2 and beyond, 2**100 does the same thing
 1j**2 -> (-1+0j)
int (signed integers): They are often called just
integers or ints, are positive or negative whole
numbers with no decimal point.
long (long integers ): Also called longs, they are
integers of unlimited size, written like integers and
followed by an uppercase or lowercase L.
float (floating point real values) : Also called floats,
they represent real numbers and are written with a
decimal point dividing the integer and fractional
parts. Floats may also be in scientific notation, with E
or e indicating the power of 10 (2.5e2 = 2.5 x 102 =
250).
complex (complex numbers) : are of the form a + bJ,
where a and b are floats and J (or j) represents the
square root of -1 (which is an imaginary number). The
real part of the number is a, and the imaginary part is
b. Complex numbers are not used much in Python
programming.
Strings
Operator Description
Example
+
a + b will give HelloPython
*
 "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
 "e" in "hello"
# comparison
1
[]
[:]
in
not in
r/R
# search
 "escapes: \n etc, \033 etc, \if etc"
 'single quotes' """triple quotes""" r"raw strings"
%
Concatenation - Adds values on
either side of the operator
Repetition - Creates new strings,
concatenating multiple copies
of the same string
Slice - Gives the character from
the given index
Range Slice - Gives the
characters from the given range
Membership - Returns true if a
character exists in the given
string
Membership - Returns true if a
character does not exist in the
given string
Raw String - Suppresses actual
meaning of Escape characters.
The syntax for raw strings is
exactly the same as for normal
strings with the exception of the
raw string operator, the letter "r,"
which precedes the quotation
marks. The "r" can be lowercase
(r) or uppercase (R) and must be
placed immediately preceding
the first quote mark.
Format - Performs String
formatting
a*2 will give -HelloHello
a[1] will give e
a[1:4] will give ell
H in a will give 1
M not in a will give 1
print r'\n' prints \n and print
R'\n'prints \n
Lists
 Flexible arrays, not Lisp-like linked lists
 a = [99, "bottles of beer", ["on", "the", "wall"]]
 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"]

The method append() appends a passed obj into the existing list.

Syntax

Following is the syntax for append() method −

list.append(obj)

Parameters

obj -- This is the object to be appended in the list.

Return Value

This method does not return any value but updates existing list.

Example

The following example shows the usage of append() method.

#!/usr/bin/python

aList = [123, 'xyz', 'zara', 'abc'];

aList.append( 2009 );

print "Updated List : ", aList

When we run above program, it produces following result −

Updated List : [123, 'xyz', 'zara', 'abc', 2009]
More List Operations
>>> a = [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, 42)
# [42,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]
Dictionaries
 Hash tables, "associative arrays"
 d = {"duck": "eend", "water": "water"}
 Lookup:
 d["duck"] -> "eend"
 d["back"] # raises KeyError exception
 Delete, insert, overwrite:
 del d["water"] # {"duck": "eend", "back": "rug"}
 d["back"] = "rug" # {"duck": "eend", "back": "rug"}
 d["duck"] = "duik" # {"duck": "duik", "back": "rug"}
More Dictionary Ops
 Keys, values, items:
 d.keys() -> ["duck", "back"]
 d.values() -> ["duik", "rug"]
 d.items() -> [("duck","duik"), ("back","rug")]
 Presence check:
 d.has_key("duck") -> 1; d.has_key("spam") -> 0
 Values of any type; keys almost any
 {"name":"Guido", "age":43, ("hello","world"):1,
42:"yes", "flag": ["red","white","blue"]}
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
A tuple is a sequence of immutable Python
objects. Tuples are sequences, just like lists.
The differences between tuples and lists are,
the tuples cannot be changed unlike lists
and tuples use parentheses, whereas lists
use square brackets.
tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";
 key = (lastname, firstname)
 point = x, y, z # parentheses optional
 x, y, z = point # unpack
 lastname = key[0]
 singleton = (1,)
# trailing comma!!!
 empty = ()
# parentheses!
 tuples vs. lists; tuples immutable
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":
 Even functions, classes, modules
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]
Changing a Shared List
a = [1, 2, 3]
a
1
2
3
1
2
3
1
2
3
a
b=a
b
a
a.append(4)
b
4
Changing an Integer
a=1
a
1
a
b=a
1
b
a
new int object created
by add operator (1+1)
2
a = a+1
b
1
old reference deleted
by assignment (a=...)
Control Structures
if condition:
statements
while condition:
statements
[elif condition:
statements] ...
else:
for var in sequence:
statements
statements
break
continue
Grouping Indentation
In C:
In Python:
for (i = 0; i < 20; i++)
{
for i in range(20):
if (i%3 == 0) {
printf("%d\n", i);
if i%3 == 0:
if (i%5 == 0) {
print i
printf("Bingo!\n"); }
if i%5 == 0:
}
print "Bingo!"
print "---"
printf("---\n");
}
0
Bingo!
------3
------6
------9
------12
------15
Bingo!
------18
-----
Functions, Procedures
def name(arg1, arg2, ...):
"""documentation"""
# optional doc string
statements
return
# from procedure
return expression
# from function
Example Function
def gcd(a, b):
"greatest common divisor"
while a != 0:
a, b = b%a, a # parallel assignment
return b
>>> gcd.__doc__
'greatest common divisor'
>>> gcd(12, 20)
4
Classes
class name:
"documentation"
statements
-orclass name(base1, base2, ...):
...
Most, statements are method definitions:
def name(self, arg1, arg2, ...):
...
May also be class variable assignments
Example Class
class Stack:
"A well-known data structure…"
def __init__(self):
# constructor
self.items = []
def push(self, x):
self.items.append(x)
# the sky is the limit
def pop(self):
x = self.items[-1]
# what happens if it’s empty?
del self.items[-1]
return x
def empty(self):
return len(self.items) == 0 # Boolean result
Using Classes
 To create an instance, simply call the class object:
x = Stack()# no 'new' operator!
 To use methods of the instance, call using dot notation:
x.empty() # -> 1
x.push(1)
# [1]
x.empty() # -> 0
x.push("hello")
x.pop()
# [1, "hello"]
# -> "hello"
# [1]
 To inspect instance variables, use dot notation:
x.items
# -> [1]
Subclassing
class FancyStack(Stack):
"stack with added ability to inspect inferior stack items"
def peek(self, n):
"peek(0) returns top; peek(-1) returns item below that; etc."
size = len(self.items)
assert 0 <= n < size
return self.items[size-1-n]
# test precondition
Subclassing (2)
class LimitedStack(FancyStack):
"fancy stack with limit on stack size"
def __init__(self, limit):
self.limit = limit
FancyStack.__init__(self)
# base class constructor
def push(self, x):
assert len(self.items) < self.limit
FancyStack.push(self, x)
# "super" method call
Class / Instance Variables
class Connection:
verbose = 0
# class variable
def __init__(self, host):
self.host = host
# instance variable
def debug(self, v):
self.verbose = v
# make instance variable!
def connect(self):
if self.verbose:
# class or instance variable?
print "connecting to", self.host
Instance Variable Rules
 On use via instance (self.x), search order:
 (1) instance, (2) class, (3) base classes
 this also works for method lookup
 On assignment via instance (self.x = ...):
 always makes an instance variable
 Class variables "default" for instance variables
 But...!
 mutable class variable: one copy shared by all
 mutable instance variable: each instance its own
Modules
 Collection of stuff in foo.py file
 functions, classes, variables
 Importing modules:
 import re; print re.match("[a-z]+", s)
 from re import match; print match("[a-z]+", s)
 Import with rename:
 import re as regex
 from re import match as m
 Before Python 2.0:
 import re; regex = re; del re
Packages
 Collection of modules in directory
 Must have __init__.py file
 May contain subpackages
 Import syntax:
 from P.Q.M import foo; print foo()
 from P.Q import M; print M.foo()
 import P.Q.M; print P.Q.M.foo()
 import P.Q.M as M; print M.foo()
# new
Catching Exceptions
def foo(x):
return 1/x
def bar(x):
try:
print foo(x)
except ZeroDivisionError, message:
print "Can’t divide by zero:", message
bar(0)
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
More on Exceptions
 User-defined exceptions
 subclass Exception or any other standard exception
 Old Python: exceptions can be strings
 WATCH OUT: compared by object identity, not ==
 Last caught exception info:
 sys.exc_info() == (exc_type, exc_value, exc_traceback)
 Last uncaught exception (traceback printed):
 sys.last_type, sys.last_value, sys.last_traceback
 Printing exceptions: traceback module
File Objects
 f = open(filename[, mode[, buffersize])
 mode can be "r", "w", "a" (like C stdio); default "r"
 append "b" for text translation mode
 append "+" for read/write open
 buffersize: 0=unbuffered; 1=line-buffered; buffered
 methods:
 read([nbytes]), readline(), readlines()
 write(string), writelines(list)
 seek(pos[, how]), tell()
 flush(), close()
 fileno()
Standard Library
 Core:
 os, sys, string, getopt, StringIO, struct, pickle, ...
 Regular expressions:
 re module; Perl-5 style patterns and matching rules
 Internet:
 socket, rfc822, httplib, htmllib, ftplib, smtplib, ...
 Miscellaneous:
 pdb (debugger), profile+pstats
 Tkinter (Tcl/Tk interface), audio, *dbm, ...
Python 2.0: What's New
 Augmented assignment: x += y
 List comprehensions:
[s.strip() for s in f.readlines()]
 Extended print: print >>sys.stderr, "Hello!"
 Extended import: import foo as bar
 Unicode strings: u"\u1234"
 New re implementation (faster, Unicode)
 Collection of cyclic garbage
 XML, distutils
URLs
 http://www.python.org
 official site
 http://starship.python.net
 Community
 http://www.python.org/psa/bookstore/
 (alias for http://www.amk.ca/bookstore/)
 Python Bookstore
Further Reading
Learning Python: Lutz, Ascher (O'Reilly '98)
Python Essential Reference: Beazley (New Riders '99)
Programming Python, 2nd Ed.: Lutz (O'Reilly '01)
Core Python Programming: Chun (Prentice-Hall '00)
The Quick Python Book: Harms, McDonald (Manning '99)
The Standard Python Library: Lundh (O'Reilly '01)
Python and Tkinter Programming: Grayson (Manning '00)
Python Programming on Win32:
Hammond, Robinson (O'Reilly '00)
 Learn to Program Using Python: Gauld (Addison-W. '00)
 And many more titles...








The Problem
The Subaru Software Development team (SSD) is migrating their
instrument control software from C/C++ to Python.
Lack of performance comparisons directly between the two
languages.
Information on performance impacts from migrated code is needed.
40
Write performance benchmarking
software in both C/C++ and Python.
Execute software on Subaru’s Real
Time System (AO188RTS)
Construct a Wiki page on Subaru’s Wiki
to present an analysis on the results.
41
Why Python?
C++
Complex syntax
Difficult to read
Python
Minimal Syntax
Easier to read and debug
Faster development time
Increases productivity
Compiled vs. Interpreted
C++ is a compiled
language.
Code is translated from a
human readable text form
into an executable form that
a machine can read.
Compiled code is hardware
specific.
Python is an interpreted
language.
Code is translated into a
machine readable form
during run time by an
interpreter application.
Interpreted code run on any
platform with the interpreter
installed.
Benchmarking Suite
Output
GUI
Runtime (ms)
(Shorter
is better)
Results
- The
Good
Searching
Sorting
C++
Python
C++
Python
45
Results
– The Bad
Vector Normalization
C++
Python
Jitter
46
Results
–
The
Ugly
Matrix Inversion
C++
Python
Jitter
47
Conclusions
Python ran an average of 4x slower than C++ in
averaging all test results.
Runtime jitter is more important for real-time
applications than average execution times.
Mathematical, memory intensive, or complex
algorithms suffer the biggest performance impacts
in Python.
Utilizing Pythons built in methods or external modules
can produce near or better than C++ performance.
Exercises
Exercise
Rewrite your pay computation with time-and-ahalf for overtime and create a function called
computepay which takes two parameters ( hours
and rate).
Enter Hours: 45
Enter Rate: 10
Pay: 475.0
475 = 40 * 10 + 5 * 15
 Installing Python
 Installing your text editor (NotePad++ or TextWrangler)
 Setting tab expansion
 Using the Command Line or Terminal Interface
 Editing and running Python Programs
Exercise 2.3
Write a program to prompt the user for their name
and welcome them.
Enter your name: Chuck
Hello Chuck
Exercise 2.4
Write a program to prompt the user for hours and
rate per hour to compute gross pay.
Enter Hours: 35
Enter Rate: 2.75
Pay: 96.25
Exercise 3.1
Rewrite your pay computation to give the
employee 1.5 times the hourly rate for hours
worked above 40 hours.
Enter Hours: 45
Enter Rate: 10
Pay: 475.0
475 = 40 * 10 + 5 * 15
Exercise 3.2
Rewrite your pay program using try and except so
that your program handles non-numeric input
gracefully.
Enter Hours: 20
Enter Rate: nine
Error, please enter numeric input
Enter Hours: forty
Error, please enter numeric input
Exercise 5.1
Write a program which reads list of numbers until
``done'' is entered. Once ``done'' is entered, print
out the total, count, and average of the numbers.
If the user enters anything other than a number,
print an error message and skip to the next
number.
Enter a number: 4
Enter a number: 5
Enter a number: bad data
Invalid input
Enter a number: 7
Enter a number: done
Average: 5.33333333333