Introduction to Python LinuxWorld – New York City – January 2002 Guido

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" "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 # search "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] Slide 8 # - [98, "bottles", "of", "beer"] 2001, 2002 Guido van Rossum

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, 42) # [42,0,1,2,3,4] a.pop(0) # [0,1,2,3,4] 5.5 a.reverse() a.sort() Slide 9 # [4,3,2,1,0] # [0,1,2,3,4] 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 # parentheses optional x, y, z point # unpack lastname key[0] singleton (1,) # trailing comma!!! empty () # parentheses! 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 1 2 3 1 2 3 1 2 3 a b a b a a.append(4) b Slide 16 2001, 2002 Guido van Rossum 4

Changing an Integer a 1 a 1 a 1 b a b a new int object created by add operator (1 1) 2 a a 1 b Slide 17 1 2001, 2002 Guido van Rossum old reference deleted by assignment (a .)

Control Structures if condition: while condition: statements statements [elif condition: statements] . else: for var in sequence: statements statements break continue Slide 18 2001, 2002 Guido van Rossum

Grouping Indentation In Python: In C: for i in range(20): for (i 0; i 20; i ) { if i%3 0: if (i%3 0) { print i printf("%d\n", i); if i%5 0: if (i%5 0) { print "Bingo!" printf("Bingo!\ n"); } print "---" } printf("---\n"); } Slide 19 2001, 2002 Guido van Rossum 0 Bingo! ------3 ------6 ------9 ------12 ------15 Bingo! ------18 -----

Functions, Procedures def name(arg1, arg2, .): """documentation""" string # optional doc statements return # from procedure return expression Slide 20 # from function 2001, 2002 Guido van Rossum

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 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): # 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 Slide 23 # Boolean result 2001, 2002 Guido van Rossum

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") # [1, "hello"] x.pop() # - "hello" # [1] To inspect instance variables, use dot notation: x.items Slide 24 # - [1] 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] Slide 25 2001, 2002 Guido van Rossum # 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) Slide 26 # "super" method call 2001, 2002 Guido van Rossum

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: variable? # class or instance print "connecting to", self.host 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() Slide 30 2001, 2002 Guido van Rossum # 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) Slide 31 2001, 2002 Guido van Rossum

Try-finally: Cleanup f open(file) try: process file(f) finally: f.close() print "OK" Slide 32 # always executed # executed on success only 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