Introduction to Python LinuxWorld - New York City - January 2002 Guido van Rossum Director of PythonLabs at Zope Corporation (Now with: Google Inc.) (minorly updated by

Slide 2©2001, 2002 Guido van Rossum Why Python? Birth: Xmas 1989 Have your cake and eat it, too: Productivity and readable code Key design feature: Extensibility VHLLs will gain on system languages (John Ousterhout) Scripting: Higher Level Programming for the 21st Century "Life's better without braces" (Bruce Eckel)

Slide 3©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 Python evolution

Slide 4©2001, 2002 Guido van Rossum Try It Out! If you brought a laptop into the classroom, feel free to play along Download Python from Any version will do for this class –By and large they are all mutually compatible –Recommended/current version: –Oldest version still in use: Avoid 1.6/1.6.1 if you can –3.0 is out too! Use IDLE if you can

Slide 5©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 6©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 Fixed in Python 3.0 Long (arbitrary precision), complex 2**100 -> L 1j**2 -> (-1+0j)

Slide 7©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"True# comparison "e" in "hello"True# search "escapes: \n etc, \033 etc, \if etc" 'single quotes' “double quotes” r"raw strings" """triple quotes can contain newline like we just saw """

Slide 8©2001, 2002 Guido van Rossum Lists Flexible arrays, similar to Scheme Vectors, but 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 9©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] 42 >>> a.reverse()# [4,3,2,1,0] >>> a.sort()# [0,1,2,3,4]

Slide 10©2001, 2002 Guido van Rossum Dictionaries Akin to Java Maps 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"} d["back"] = "rug" # {"duck": "eend", "back": "rug"} d["duck"] = "duik" # {"duck": "duik", "back": "rug"}

Slide 11©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") -> True d.has_key("spam") -> False Values of any type; keys almost any {"name":"Guido", "age":43, ("hello","world"):1, 42:"yes", "flag": ["red","white","blue"]}

Slide 12©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 13©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 14©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 15©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 16©2001, 2002 Guido van Rossum a 123 b a 123 b 4 a = [1, 2, 3] a.append(4) b = a a 123 Changing a Shared List

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

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

Slide 19©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 "---" In C: for (i = 0; i < 20; i++) { if (i%3 == 0) { printf("%d\n", i); if (i%5 == 0) { printf("Bingo!\n"); } } printf("---\n"); } 0 Bingo! Bingo!

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

Slide 21©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 22©2001, 2002 Guido van Rossum Classes class name: "documentation" statements -or- class name(base1, base2,...):... Most, statements are method definitions: def name(self, arg1, arg2,...):... May also be class variable assignments

Slide 23©2001, 2002 Guido van Rossum Example Class class Stack: "A well-known data structure…" def __init__(self):# constructor self.items = [] # instance field 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

Slide 24©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()# -> True x.push(1)# [1] x.empty()# -> False x.push("hello")# [1, "hello"] x.pop()# -> "hello"# [1] To inspect instance variables, use dot notation: x.items# -> [1]

Slide 25©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# test precondition return self.items[size-1-n]

Slide 26©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)# base class constructor def push(self, x): assert len(self.items) < self.limit FancyStack.push(self, x)# "super" method call

Slide 27©2001, 2002 Guido van Rossum Class / Instance Variables class Connection: verbose = False# class variable def __init__(self, host): self.host = host# instance variable def debug(self, v): self.verbose = True# make instance variable! def connect(self): if self.verbose:# class or instance variable? print "connecting to", self.host

Slide 28©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 Mutable class variable: one copy shared by all Mutable instance variable: each instance its own

Slide 29©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

Slide 30©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 31©2001, 2002 Guido van Rossum 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) # Can't divide by zero: integer division or modulo by zero

Slide 32©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 or syntax error?

Slide 33©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 34©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 35©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 36©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 37©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 38©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 39©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 40©2001, 2002 Guido van Rossum URLs –official site –Community –(alias for –Python Bookstore

June 27, 2005© 2005 Guido van Rossum 41 The Zen of Python 1.Beautiful is better than ugly. 2.Explicit is better than implicit. 3.Simple is better than complex. 4.Complex is better than complicated. 5.Flat is better than nested. 6.Sparse is better than dense. 7.Readability counts. 8.Special cases aren't special enough to break the rules. 9.Although practicality beats purity. 10.Errors should never pass silently. 11.Unless explicitly silenced. 12.In the face of ambiguity, refuse the temptation to guess. 13.There should be one— and preferably only one —obvious way to do it. 14.Although that way may not be obvious at first unless you're Dutch. 15.Now is better than never. 16.Although never is often better than right now. 17.If the implementation is hard to explain, it's a bad idea. 18.If the implementation is easy to explain, it may be a good idea. 19.Namespaces are one honking great idea — let's do more of those! (a poem by Tim Peters)

Slide 42©2001, 2002 Guido van Rossum Further Reading Exploring Python: Timothy Budd (Prentice Hall ‘09) Learning Python: Lutz, Ascher (O'Reilly '98) Python Essential Reference: Beazley (Addison- Wesley ‘09) Programming Python, 3rd Ed.: Lutz (O'Reilly '06) Core Python Programming, 2 nd Ed: Chun (Prentice- Hall '06) The Quick Python Book: Harms, McDonald (Manning ‘00) Python and Tkinter Programming: Grayson (Manning '00) And many more titles...

Python : My Experience T. K. Prasad

What/Why of my first programs in Python? Compiler Construction Assignment Grading Programs that tested scanner/parser built from FLEX/Bison spec turned in by students on test suites – Improved Scripting : Replaced Bash Cloud-based Search Engine Index Construction – String manipulation and data structuring facilities for generating inverted index for text document search engine : Used Hadoop streaming on Cloud

Striking Features Indentation based block structure promotes succinctness and improves readability Lack of separate variable/field declaration – Pros: Concise Code (with suitably chosen names) – Cons: Lack of redundancy for static checking Powerful and convenient string handling Useful collections – Lists, Dictionaries (maps), Tuples, Arrays, etc – Uniformity and Convenience: strings vs lists Numbers : int, long, float, complex

(cont’d) Dynamic typing – Pros: Supports heterogeneous data structures akin to Scheme – Cons: Certain type errors cannot be detected – Duck Typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface.dynamic typingmethods Duck typing is aided by habitually not testing for the type of arguments in method and function bodies, relying on documentation, clear code, and testing to ensure correct use. Object fields can be dynamically created

(cont’d) Multiparadigm Programming Language – Functional Style Views computation as a sequence of transformation – Imperative Style Views computation as a “large” sequence of “small” changes to the memory – Object-Oriented Style Views computation as interactions between a collection of computing agents (client-server paradigm)