Introduction to Python

LinuxWorld - New York City - January 2002

Guido van Rossum Director of PythonLabs at Zope Corporation [email protected] [email protected]

Why Python?
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)

Slide 2

2001, 2002 Guido van Rossum

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 what's new in Python 2.0 and beyond

Slide 3

2001, 2002 Guido van Rossum

Try It Out!
If you brought a laptop into the classroom, feel free to play along Download Python from www.python.org Any version will do for this class
By and large they are all mutually compatible Recommended version: 2.1.1 or 2.2 Oldest version still in widespread use: 1.5.2 Avoid 1.6/1.6.1 if you can When using 2.0 or 2.1, upgrade to 2.0.1 / 2.1.1 2.1.2 is coming soon!

Use IDLE if you can

Slide 4 2001, 2002 Guido van Rossum

Interactive Shell
Great for learning the language Great for experimenting with the library 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

Slide 5

2001, 2002 Guido van Rossum

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)

Slide 6

2001, 2002 Guido van Rossum

Strings
"hello"+"world" "hello"*3 "hello"[0] "hello"[-1] "hello"[1:4] len("hello") "hello" < "jello" "e" in "hello" "helloworld" "h" "o" "ell" 5 1 1 # concatenation # indexing # (from end) # slicing # size # comparison # search "hellohellohello" # repetition

"escapes: \n etc, \033 etc, \if etc" 'single quotes' """triple quotes""" r"raw strings"

Slide 7

2001, 2002 Guido van Rossum

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"]

Slide 8

2001, 2002 Guido van Rossum

More List Operations

>>> a = range(5) >>> a.append(5) >>> a.pop() 5 >>> a.insert(0, 42) >>> a.pop(0) 5.5 >>> a.reverse() >>> a.sort() # [4,3,2,1,0] # [0,1,2,3,4] # [42,0,1,2,3,4] # [0,1,2,3,4] # [0,1,2,3,4] # [0,1,2,3,4,5] # [0,1,2,3,4]

Slide 9

2001, 2002 Guido van Rossum

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"}

Slide 10

2001, 2002 Guido van Rossum

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"]}

Slide 11

2001, 2002 Guido van Rossum

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

Slide 12

2001, 2002 Guido van Rossum

Tuples
key = (lastname, firstname) point = x, y, z x, y, z = point singleton = (1,) empty = () # parentheses optional # unpack # trailing comma!!! # parentheses!

lastname = key[0]

tuples vs. lists; tuples immutable

Slide 13

2001, 2002 Guido van Rossum

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

Slide 14

2001, 2002 Guido van Rossum

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]

Slide 15

2001, 2002 Guido van Rossum

Changing a Shared List

a = [1, 2, 3]

a a

b=a b a a.append(4) b
Slide 16

2001, 2002 Guido van Rossum

Changing an Integer
a=1 a a b=a b a a = a+1 b 1 2
old reference deleted by assignment (a=...)

1
new int object created by add operator (1+1)

Slide 17

2001, 2002 Guido van Rossum

Control Structures
if condition: statements [elif condition: statements] ... else: statements break continue for var in sequence: statements while condition: statements

Slide 18

2001, 2002 Guido van Rossum

Grouping Indentation
In Python: for i in range(20): if i%3 == 0: print i if i%5 == 0: print "Bingo!" print "---" } printf("---\n"); } In C: for (i = 0; i < 20; i++) { if (i%3 == 0) { printf("%d\n", i); if (i%5 == 0) { printf("Bingo!\n"); }
0 Bingo! ------3 ------6 ------9 ------12 ------15 Bingo! ------18 -----

Slide 19

2001, 2002 Guido van Rossum

Functions, Procedures
def name(arg1, arg2, ...): """documentation""" # optional doc string statements return return expression # from procedure # from function

Slide 20

2001, 2002 Guido van Rossum

Example Function
def gcd(a, b): "greatest common divisor" while a != 0: a, b = b%a, a return b >>> gcd.__doc__ 'greatest common divisor' >>> gcd(12, 20) 4 # parallel assignment

Slide 21

2001, 2002 Guido van Rossum

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

Slide 22

2001, 2002 Guido van Rossum

Example Class
class Stack: "A well-known data structure" def __init__(self): self.items = [] def push(self, x): self.items.append(x) def pop(self): x = self.items[-1] empty? del self.items[-1] return x def empty(self): return len(self.items) == 0
Slide 23 2001, 2002 Guido van Rossum

# constructor

# the sky is the limit # what happens if its

# 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() x.push(1) x.empty() x.push("hello") x.pop() # -> "hello" # -> 0 # [1, "hello"] # [1] # -> 1 # [1]

To inspect instance variables, use dot notation:

x.items # -> [1]

Slide 24

2001, 2002 Guido van Rossum

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

Slide 25

2001, 2002 Guido van Rossum

Subclassing (2)
class LimitedStack(FancyStack): "fancy stack with limit on stack size" def __init__(self, limit): self.limit = limit FancyStack.__init__(self) constructor def push(self, x): assert len(self.items) < self.limit FancyStack.push(self, x) # "super" method call # base class

Slide 26

2001, 2002 Guido van Rossum

Class / Instance Variables

class Connection: verbose = 0 def __init__(self, host): self.host = host def debug(self, v): self.verbose = v def connect(self): if self.verbose: print "connecting to", self.host # class or instance variable? # make instance variable! # instance variable # class variable

Slide 27

2001, 2002 Guido van Rossum

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

Slide 28

2001, 2002 Guido van Rossum

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

Slide 29

2001, 2002 Guido van Rossum

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

Slide 30

2001, 2002 Guido van Rossum

Catching Exceptions
def foo(x): return 1/x def bar(x): try: print foo(x) except ZeroDivisionError, message: print "Cant divide by zero:", message bar(0)

Slide 31

2001, 2002 Guido van Rossum

Try-finally: Cleanup

f = open(file) try: process_file(f) finally: f.close() # always executed print "OK" # executed on success only

Slide 32

2001, 2002 Guido van Rossum

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

Slide 33

2001, 2002 Guido van Rossum

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

Slide 34

2001, 2002 Guido van Rossum

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()

Slide 35

2001, 2002 Guido van Rossum

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, ...

Slide 36

2001, 2002 Guido van Rossum

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

Slide 37

2001, 2002 Guido van Rossum

Python 2.1: What's New

From __future__ import nested_scopes
def make_adder(n): def adder(x): return x+n return adder add2 = make_adder(2) add2(10) == 12

Rich comparisons
Overload <, <=, ==, !=, >=, > separately

Warnings framework
Prepare for the future

Slide 38

2001, 2002 Guido van Rossum

Python 2.2: What's New

Iterators and Generators
from __future__ import generators def inorder(tree): if tree: for x in inorder(tree.left): yield x yield tree.label for x in inorder(tree.right): yield x

Type/class unification
class mydict(dict):

Fix division operator so 1/2 == 0.5; 1//2 == 0

Requires __future__ statement in Python 2.x Change will be permanent in Python 3.0

Slide 39

2001, 2002 Guido van Rossum

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

Slide 40

2001, 2002 Guido van Rossum

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...
Slide 41 2001, 2002 Guido van Rossum

TIME FOR QUESTIONS