Python 2.3 Quick Reference

25 Jan 2003 upgraded by Raymond Hettinger for Python 2.3

16 May 2001 upgraded by Richard Gruet and Simon Brunning for Python 2.0

2000/07/18 upgraded by Richard Gruet, [email protected] for Python 1.5.2

from V1.3 ref

1995/10/30, by Chris Hoffmann, [email protected]

Based on:

Python Bestiary, Author: Ken Manheimer, [email protected]

Python manuals, Authors: Guido van Rossum and Fred Drake

What's new in Python 2.0, Authors: A.M. Kuchling and Moshe Zadka

python-mode.el, Author: Tim Peters, [email protected]

and the readers of comp.lang.python

Python's nest: http://www.python.org Developement: http://

python.sourceforge.net/ ActivePython : http://www.ActiveState.com/ASPN/

Python/

newsgroup: comp.lang.python Help desk: [email protected]

Resources: http://starship.python.net/

http://www.vex.net/parnassus/

http://aspn.activestate.com/ASPN/Cookbook/Python

FAQ: http://www.python.org/cgi-bin/faqw.py

Full documentation: http://www.python.org/doc/

Excellent reference books:

Python Essential Reference by David Beazley (New Riders)

Python Pocket Reference by Mark Lutz (O'Reilly)

Invocation Options

python [-diOStuUvxX?] [-c command | script | - ] [args]

Invocation Options

Option Effect

-c cmd program passed in as string (terminates option list)

-d Outputs parser debugging information (also PYTHONDEBUG=x)

-E ignore environment variables (such as PYTHONPATH)

-h print this help message and exit

-i Inspect interactively after running script (also PYTHONINSPECT=x) and

force prompts, even if stdin appears not to be a terminal

-m mod run library module as a script (terminates option list

-O optimize generated bytecode (a tad; also PYTHONOPTIMIZE=x)

-OO remove doc-strings in addition to the -O optimizations

-Q arg division options: -Qold (default), -Qwarn, -Qwarnall, -Qnew

-S Don't perform 'import site' on initialization

-u Unbuffered binary stdout and stderr (also PYTHONUNBUFFERED=x).

-v Verbose (trace import statements) (also PYTHONVERBOSE=x)

-W arg : warning control (arg is action:message:category:module:lineno)

-x Skip first line of source, allowing use of non-unix Forms of #!cmd

-? Help!

-c Specify the command to execute (see next section). This terminates the

command option list (following options are passed as arguments to the command).

the name of a python file (.py) to execute read from stdin.

script Anything afterward is passed as options to python script or command,

not interpreted as an option to interpreter itself.

args passed to script or command (in sys.argv[1:])

If no script or command, Python enters interactive mode.

* Available IDEs in std distrib: IDLE (tkinter based, portable), Pythonwin

(Windows).

Environment variables

Environment variables

Variable Effect

PYTHONHOME Alternate prefix directory (or prefix;exec_prefix). The

default module search path uses prefix/lib

Augments the default search path for module files. The format

is the same as the shell's $PATH: one or more directory

pathnames separated by ':' or ';' without spaces around

(semi-)colons!

PYTHONPATH On Windows first search for Registry key HKEY_LOCAL_MACHINE\

Software\Python\PythonCore\x.y\PythonPath (default value). You

may also define a key named after your application with a

default string value giving the root directory path of your

app.

If this is the name of a readable file, the Python commands in

PYTHONSTARTUP that file are executed before the first prompt is displayed in

interactive mode (no default).

PYTHONDEBUG If non-empty, same as -d option

PYTHONINSPECT If non-empty, same as -i option

PYTHONSUPPRESS If non-empty, same as -s option

PYTHONUNBUFFERED If non-empty, same as -u option

PYTHONVERBOSE If non-empty, same as -v option

PYTHONCASEOK If non-empty, ignore case in file/module names (imports)

Notable lexical entities

Keywords

and del for is raise

assert elif from lambda return

break else global not try

class except if or while

continue exec import pass yield

def finally in print

* (list of keywords in std module: keyword)

* Illegitimate Tokens (only valid in strings): @ $ ?

* A statement must all be on a single line. To break a statement over

multiple lines use "\", as with the C preprocessor.

Exception: can always break when inside any (), [], or {} pair, or in

triple-quoted strings.

* More than one statement can appear on a line if they are separated with

semicolons (";").

* Comments start with "#" and continue to end of line.

Identifiers

(letter | "_") (letter | digit | "_")*

* Python identifiers keywords, attributes, etc. are case-sensitive.

* Special forms: _ident (not imported by 'from module import *'); __ident__

(system defined name);

__ident (class-private name mangling)

Strings

"a string enclosed by double quotes"

'another string delimited by single quotes and with a " inside'

'''a string containing embedded newlines and quote (') marks, can be

delimited with triple quotes.'''

""" may also use 3- double quotes as delimiters """

u'a unicode string' U"Another unicode string"

r'a raw string where \ are kept (literalized): handy for regular

expressions and windows paths!'

R"another raw string" -- raw strings cannot end with a \

ur'a unicode raw string' UR"another raw unicode"

Use \ at end of line to continue a string on next line.

adjacent strings are concatened, e.g. 'Monty' ' Python' is the same as

'Monty Python'.

u'hello' + ' world' --> u'hello world' (coerced to unicode)

String Literal Escapes

\newline Ignored (escape newline)

\\ Backslash (\) \e Escape (ESC) \v Vertical Tab (VT)

\' Single quote (') \f Formfeed (FF) \OOO char with octal value OOO

\" Double quote (") \n Linefeed (LF)

\a Bell (BEL) \r Carriage Return (CR) \xHH char with hex value HH

\b Backspace (BS) \t Horizontal Tab (TAB)

\uHHHH unicode char with hex value HHHH, can only be used in unicode string

\UHHHHHHHH unicode char with hex value HHHHHHHH, can only be used in unicode string

\AnyOtherChar is left as-is

* NUL byte (\000) is NOT an end-of-string marker; NULs may be embedded in

strings.

* Strings (and tuples) are immutable: they cannot be modified.

Numbers

Decimal integer: 1234, 1234567890546378940L (or l)

Octal integer: 0177, 0177777777777777777 (begin with a 0)

Hex integer: 0xFF, 0XFFFFffffFFFFFFFFFF (begin with 0x or 0X)

Long integer (unlimited precision): 1234567890123456

Float (double precision): 3.14e-10, .001, 10., 1E3

Complex: 1J, 2+3J, 4+5j (ends with J or j, + separates (float) real and

imaginary parts)

Sequences

* String of length 0, 1, 2 (see above)

'', '1', "12", 'hello\n'

* Tuple of length 0, 1, 2, etc:

() (1,) (1,2) # parentheses are optional if len > 0

* List of length 0, 1, 2, etc:

[] [1] [1,2]

Indexing is 0-based. Negative indices (usually) mean count backwards from end

of sequence.

Sequence slicing [starting-at-index : but-less-than-index]. Start defaults to

'0'; End defaults to 'sequence-length'.

a = (0,1,2,3,4,5,6,7)

a[3] ==> 3

a[-1] ==> 7

a[2:4] ==> (2, 3)

a[1:] ==> (1, 2, 3, 4, 5, 6, 7)

a[:3] ==> (0, 1, 2)

a[:] ==> (0,1,2,3,4,5,6,7) # makes a copy of the sequence.

Dictionaries (Mappings)

{} # Zero length empty dictionary

{1 : 'first'} # Dictionary with one (key, value) pair

{1 : 'first', 'next': 'second'}

dict([('one',1),('two',2)]) # Construct a dict from an item list

dict('one'=1, 'two'=2) # Construct a dict using keyword args

dict.fromkeys(['one', 'keys']) # Construct a dict from a sequence

Operators and their evaluation order

Operators and their evaluation order

Highest Operator Comment

(...) [...] {...} `...` Tuple, list & dict. creation; string

conv.

s[i] s[i:j] s.attr f(...) indexing & slicing; attributes, fct

calls

+x, -x, ~x Unary operators

x**y Power

x*y x/y x%y x//y mult, division, modulo, floor division

x+y x-y addition, subtraction

x<<y x>>y Bit shifting

x&y Bitwise and

x^y Bitwise exclusive or

x|y Bitwise or

x<y x<=y x>y x>=y x==y x!=y Comparison,

x is y x is not y membership

x in s x not in s

not x boolean negation

x and y boolean and

x or y boolean or

Lowest lambda args: expr anonymous function

Alternate names are defined in module operator (e.g. __add__ and add for +)

Most operators are overridable.

Many binary operators also support augmented assignment:

x += 1 # Same as x = x + 1

Basic Types and Their Operations

Comparisons (defined between *any* types)

Comparisons

Comparison Meaning Notes

< strictly less than (1)

<= less than or equal to

> strictly greater than

>= greater than or equal to

== equal to

!= not equal to

is object identity (2)

is not negated object identity (2)

Notes :

Comparison behavior can be overridden for a given class by defining special

method __cmp__.

The above comparisons return True or False which are of type bool

(a subclass of int) and behave exactly as 1 or 0 except for their type and

that they print as True or False instead of 1 or 0.

(1) X < Y < Z < W has expected meaning, unlike C

(2) Compare object identities (i.e. id(object)), not object values.

Boolean values and operators

Boolean values and operators

Value or Operator Returns Notes

None, numeric zeros, empty sequences and False

mappings

all other values True

not x True if x is False, else

True

x or y if x is False then y, else (1)

x

x and y if x is False then x, else (1)

y

Notes :

Truth testing behavior can be overridden for a given class by defining

special method __bool__.

(1) Evaluate second arg only if necessary to determine outcome.

None

None is used as default return value on functions. Built-in single object

with type NoneType.

Input that evaluates to None does not print when running Python

interactively.

Numeric types

Floats and integers.

Floats are implemented with C doubles.

Integers have unlimited size (only limit is system resources)

Operators on all numeric types

Operators on all numeric types

Operation Result

abs(x) the absolute value of x

int(x) x converted to integer

float(x) x converted to floating point

-x x negated

+x x unchanged

x + y the sum of x and y

x - y difference of x and y

x * y product of x and y

x / y quotient of x and y

x % y remainder of x / y

divmod(x, y) the tuple (x/y, x%y)

x ** y x to the power y (the same as pow(x, y))

Bit operators on integers

Bit operators

Operation >Result

~x the bits of x inverted

x ^ y bitwise exclusive or of x and y

x & y bitwise and of x and y

x | y bitwise or of x and y

x << n x shifted left by n bits

x >> n x shifted right by n bits

Complex Numbers

* represented as a pair of machine-level double precision floating point

numbers.

* The real and imaginary value of a complex number z can be retrieved through

the attributes z.real and z.imag.

Numeric exceptions

TypeError

raised on application of arithmetic operation to non-number

OverflowError

numeric bounds exceeded

ZeroDivisionError

raised when zero second argument of div or modulo op

FloatingPointError

raised when a floating point operation fails

Operations on all sequence types (lists, tuples, strings)

Operations on all sequence types

Operation Result Notes

x in s True if an item of s is equal to x, else False

x not in s False if an item of s is equal to x, else True

for x in s: loops over the sequence

s + t the concatenation of s and t

s * n, n*s n copies of s concatenated

s[i] i'th item of s, origin 0 (1)

s[i:j] slice of s from i (included) to j (excluded) (1), (2)

len(s) length of s

min(s) smallest item of s

max(s) largest item of (s)

iter(s) returns an iterator over s. iterators define __iter__ and next()

Notes :

(1) if i or j is negative, the index is relative to the end of the string,

ie len(s)+ i or len(s)+j is

substituted. But note that -0 is still 0.

(2) The slice of s from i to j is defined as the sequence of items with

index k such that i <= k < j.

If i or j is greater than len(s), use len(s). If i is omitted, use

len(s). If i is greater than or

equal to j, the slice is empty.

Operations on mutable (=modifiable) sequences (lists)

Operations on mutable sequences

Operation Result Notes

s[i] =x item i of s is replaced by x

s[i:j] = t slice of s from i to j is replaced by t

del s[i:j] same as s[i:j] = []

s.append(x) same as s[len(s) : len(s)] = [x]

s.count(x) return number of i's for which s[i] == x

s.extend(x) same as s[len(s):len(s)]= x

s.index(x) return smallest i such that s[i] == x (1)

s.insert(i, x) same as s[i:i] = [x] if i >= 0

s.pop([i]) same as x = s[i]; del s[i]; return x (4)

s.remove(x) same as del s[s.index(x)] (1)

s.reverse() reverse the items of s in place (3)

s.sort([cmpFct]) sort the items of s in place (2), (3)

Notes :

(1) raise a ValueError exception when x is not found in s (i.e. out of

range).

(2) The sort() method takes an optional argument specifying a comparison

fct of 2 arguments (list items) which should

return -1, 0, or 1 depending on whether the 1st argument is

considered smaller than, equal to, or larger than the 2nd

argument. Note that this slows the sorting process down considerably.

(3) The sort() and reverse() methods modify the list in place for economy

of space when sorting or reversing a large list.

They don't return the sorted or reversed list to remind you of this

side effect.

(4) [New 1.5.2] The optional argument i defaults to -1, so that by default the last

item is removed and returned.

Operations on mappings (dictionaries)

Operations on mappings

Operation Result Notes

len(d) the number of items in d

d[k] the item of d with key k (1)

d[k] = x set d[k] to x

del d[k] remove d[k] from d (1)

d.clear() remove all items from d

d.copy() a shallow copy of d

d.get(k,defaultval) the item of d with key k (4)

d.has_key(k) True if d has key k, else False

d.items() a copy of d's list of (key, item) pairs (2)

d.iteritems() an iterator over (key, value) pairs (7)

d.iterkeys() an iterator over the keys of d (7)

d.itervalues() an iterator over the values of d (7)

d.keys() a copy of d's list of keys (2)

d1.update(d2) for k, v in d2.items(): d1[k] = v (3)

d.values() a copy of d's list of values (2)

d.pop(k) remove d[k] and return its value

d.popitem() remove and return an arbitrary (6)

(key, item) pair

d.setdefault(k,defaultval) the item of d with key k (5)

Notes :

TypeError is raised if key is not acceptable

(1) KeyError is raised if key k is not in the map

(2) Keys and values are listed in random order

(3) d2 must be of the same type as d1

(4) Never raises an exception if k is not in the map, instead it returns

defaultVal.

defaultVal is optional, when not provided and k is not in the map,

None is returned.

(5) Never raises an exception if k is not in the map, instead it returns

defaultVal, and adds k to map with value defaultVal. defaultVal is

optional. When not provided and k is not in the map, None is returned and

added to map.

(6) Raises a KeyError if the dictionary is emtpy.

(7) While iterating over a dictionary, the values may be updated but

the keys cannot be changed.

Operations on strings

Note that these string methods largely (but not completely) supersede the

functions available in the string module.

Operations on strings

Operation Result Notes

s.capitalize() return a copy of s with only its first character

capitalized.

s.center(width) return a copy of s centered in a string of length width (1)

.

s.count(sub[ return the number of occurrences of substring sub in (2)

,start[,end]]) string s.

s.decode(([ return a decoded version of s. (3)

encoding

[,errors]])

s.encode([ return an encoded version of s. Default encoding is the

encoding current default string encoding. (3)

[,errors]])

s.endswith(suffix return true if s ends with the specified suffix, (2)

[,start[,end]]) otherwise return False.

s.expandtabs([ return a copy of s where all tab characters are (4)

tabsize]) expanded using spaces.

s.find(sub[,start return the lowest index in s where substring sub is (2)

[,end]]) found. Return -1 if sub is not found.

s.index(sub[ like find(), but raise ValueError when the substring is (2)

,start[,end]]) not found.

s.isalnum() return True if all characters in s are alphanumeric, (5)

False otherwise.

s.isalpha() return True if all characters in s are alphabetic, (5)

False otherwise.

s.isdigit() return True if all characters in s are digit (5)

characters, False otherwise.

s.islower() return True if all characters in s are lowercase, False (6)

otherwise.

s.isspace() return True if all characters in s are whitespace (5)

characters, False otherwise.

s.istitle() return True if string s is a titlecased string, False (7)

otherwise.

s.isupper() return True if all characters in s are uppercase, False (6)

otherwise.

s.join(seq) return a concatenation of the strings in the sequence

seq, seperated by 's's.

s.ljust(width) return s left justified in a string of length width. (1),

(8)

s.lower() return a copy of s converted to lowercase.

s.lstrip() return a copy of s with leading whitespace removed.

s.replace(old, return a copy of s with all occurrences of substring (9)

new[, maxsplit]) old replaced by new.

s.rfind(sub[ return the highest index in s where substring sub is (2)

,start[,end]]) found. Return -1 if sub is not found.

s.rindex(sub[ like rfind(), but raise ValueError when the substring (2)

,start[,end]]) is not found.

s.rjust(width) return s right justified in a string of length width. (1),

(8)

s.rstrip() return a copy of s with trailing whitespace removed.

s.split([sep[ return a list of the words in s, using sep as the (10)

,maxsplit]]) delimiter string.

s.splitlines([ return a list of the lines in s, breaking at line (11)

keepends]) boundaries.

s.startswith return true if s starts with the specified prefix,

(prefix[,start[ otherwise return false. (2)

,end]])

s.strip() return a copy of s with leading and trailing whitespace

removed.

s.swapcase() return a copy of s with uppercase characters converted

to lowercase and vice versa.

return a titlecased copy of s, i.e. words start with

s.title() uppercase characters, all remaining cased characters

are lowercase.

s.translate(table return a copy of s mapped through translation table (12)

[,deletechars]) table.

s.upper() return a copy of s converted to uppercase.

s.zfill(width) return a string padded with zeroes on the left side and

sliding a minus sign left if necessary. never truncates.

Notes :

(1) Padding is done using spaces.

(2) If optional argument start is supplied, substring s[start:] is

processed. If optional arguments start and end are supplied, substring s[start:

end] is processed.

(3) Optional argument errors may be given to set a different error handling

scheme. The default for errors is 'strict', meaning that encoding errors raise

a ValueError. Other possible values are 'ignore' and 'replace'.

(4) If optional argument tabsize is not given, a tab size of 8 characters

is assumed.

(5) Returns false if string s does not contain at least one character.

(6) Returns false if string s does not contain at least one cased

character.

(7) A titlecased string is a string in which uppercase characters may only

follow uncased characters and lowercase characters only cased ones.

(8) s is returned if width is less than len(s).

(9) If the optional argument maxsplit is given, only the first maxsplit

occurrences are replaced.

(10) If sep is not specified or None, any whitespace string is a separator.

If maxsplit is given, at most maxsplit splits are done.

(11) Line breaks are not included in the resulting list unless keepends is

given and true.

(12) table must be a string of length 256. All characters occurring in the

optional argument deletechars are removed prior to translation.

String formatting with the % operator

formatString % args--> evaluates to a string

* formatString uses C printf format codes : %, c, s, i, d, u, o, x, X, e, E,

f, g, G, r (details below).

* Width and precision may be a * to specify that an integer argument gives

the actual width or precision.

* The flag characters -, +, blank, # and 0 are understood. (details below)

* %s will convert any type argument to string (uses str() function)

* args may be a single arg or a tuple of args

'%s has %03d quote types.' % ('Python', 2) # => 'Python has 002 quote types.'

* Right-hand-side can also be a mapping:

a = '%(lang)s has %(c)03d quote types.' % {'c':2, 'lang':'Python}

(vars() function very handy to use on right-hand-side.)

Format codes

Conversion Meaning

d Signed integer decimal.

i Signed integer decimal.

o Unsigned octal.

u Unsigned decimal.

x Unsigned hexadecimal (lowercase).

X Unsigned hexadecimal (uppercase).

e Floating point exponential format (lowercase).

E Floating point exponential format (uppercase).

f Floating point decimal format.

F Floating point decimal format.

g Same as "e" if exponent is greater than -4 or less than precision,

"f" otherwise.

G Same as "E" if exponent is greater than -4 or less than precision,

"F" otherwise.

c Single character (accepts integer or single character string).

r String (converts any python object using repr()).

s String (converts any python object using str()).

% No argument is converted, results in a "%" character in the result.

(The complete specification is %%.)

Conversion flag characters

Flag Meaning

# The value conversion will use the ``alternate form''.

0 The conversion will be zero padded.

- The converted value is left adjusted (overrides "-").

(a space) A blank should be left before a positive number (or empty

string) produced by a signed conversion.

+ A sign character ("+" or "-") will precede the conversion (overrides a

"space" flag).

File Objects

Created with built-in function open; may be created by other modules' functions

as well.

Operators on file objects

File operations

Operation Result

f.close() Close file f.

f.fileno() Get fileno (fd) for file f.

f.flush() Flush file f's internal buffer.

f.isatty() True if file f is connected to a tty-like dev, else False.

f.read([size]) Read at most size bytes from file f and return as a string

object. If size omitted, read to EOF.

f.readline() Read one entire line from file f.

f.readlines() Read until EOF with readline() and return list of lines read.

Set file f's position, like "stdio's fseek()".

f.seek(offset[, whence == 0 then use absolute indexing.

whence=0]) whence == 1 then offset relative to current pos.

whence == 2 then offset relative to file end.

f.tell() Return file f's current position (byte offset).

f.write(str) Write string to file f.

f.writelines(list Write list of strings to file f.

)

File Exceptions

EOFError

End-of-file hit when reading (may be raised many times, e.g. if f is a

tty).

IOError

Other I/O-related I/O operation failure.

OSError

OS system call failed.

Advanced Types

-See manuals for more details -

+ Module objects

+ Class objects

+ Class instance objects

+ Type objects (see module: types)

+ File objects (see above)

+ Slice objects

+ XRange objects

+ Callable types:

o User-defined (written in Python):

# User-defined Function objects

# User-defined Method objects

o Built-in (written in C):

# Built-in Function objects

# Built-in Method objects

+ Internal Types:

o Code objects (byte-compile executable Python code: bytecode)

o Frame objects (execution frames)

o Traceback objects (stack trace of an exception)

Statements

pass -- Null statement

del name[,name]* -- Unbind name(s) from object. Object will be indirectly

(and automatically) deleted only if no longer referenced.

print [>> fileobject,] [s1 [, s2 ]* [,]

-- Writes to sys.stdout, or to fileobject if supplied.

Puts spaces between arguments. Puts newline at end

unless statement ends with comma.

Print is not required when running interactively,

simply typing an expression will print its value,

unless the value is None.

exec x [in globals [,locals]]

-- Executes x in namespaces provided. Defaults

to current namespaces. x can be a string, file

object or a function object.

callable(value,... [id=value], [*args], [**kw])

-- Call function callable with parameters. Parameters can

be passed by name or be omitted if function

defines default values. E.g. if callable is defined as

"def callable(p1=1, p2=2)"

"callable()" <=> "callable(1, 2)"

"callable(10)" <=> "callable(10, 2)"

"callable(p2=99)" <=> "callable(1, 99)"

*args is a tuple of positional arguments.

**kw is a dictionary of keyword arguments.

Assignment operators

Caption

Operator Result Notes

a = b Basic assignment - assign object b to label a (1)

a += b Roughly equivalent to a = a + b (2)

a -= b Roughly equivalent to a = a - b (2)

a *= b Roughly equivalent to a = a * b (2)

a /= b Roughly equivalent to a = a / b (2)

a %= b Roughly equivalent to a = a % b (2)

a **= b Roughly equivalent to a = a ** b (2)

a &= b Roughly equivalent to a = a & b (2)

a |= b Roughly equivalent to a = a | b (2)

a ^= b Roughly equivalent to a = a ^ b (2)

a >>= b Roughly equivalent to a = a >> b (2)

a <<= b Roughly equivalent to a = a << b (2)

Notes :

(1) Can unpack tuples, lists, and strings.

first, second = a[0:2]; [f, s] = range(2); c1,c2,c3='abc'

Tip: x,y = y,x swaps x and y.

(2) Not exactly equivalent - a is evaluated only once. Also, where

possible, operation performed in-place - a is modified rather than

replaced.

Control Flow

if condition: suite

[elif condition: suite]*

[else: suite] -- usual if/else_if/else statement

while condition: suite

[else: suite]

-- usual while statement. "else" suite is executed

after loop exits, unless the loop is exited with

"break"

for element in sequence: suite

[else: suite]

-- iterates over sequence, assigning each element to element.

Use built-in range function to iterate a number of times.

"else" suite executed at end unless loop exited

with "break"

break -- immediately exits "for" or "while" loop

continue -- immediately does next iteration of "for" or "while" loop

return [result] -- Exits from function (or method) and returns result (use a tuple to

return more than one value). If no result given, then returns None.

yield result -- Freezes the execution frame of a generator and returns the result

to the iterator's .__next__() method. Upon the next call to __next__(),

resumes execution at the frozen point with all of the local variables

still intact.

Exception Statements

assert expr[, message]

-- expr is evaluated. if false, raises exception AssertionError

with message. Inhibited if __debug__ is 0.

try: suite1

[except [exception [, value]: suite2]+

[else: suite3]

-- statements in suite1 are executed. If an exception occurs, look

in "except" clauses for matching <exception>. If matches or bare

"except" execute suite of that clause. If no exception happens

suite in "else" clause is executed after suite1.

If exception has a value, it is put in value.

exception can also be tuple of exceptions, e.g.

"except (KeyError, NameError), val: print val"

try: suite1

finally: suite2

-- statements in suite1 are executed. If no

exception, execute suite2 (even if suite1 is

exited with a "return", "break" or "continue"

statement). If exception did occur, executes

suite2 and then immediately reraises exception.

raise exception [,value [, traceback]]

-- raises exception with optional value

value. Arg traceback specifies a traceback object to

use when printing the exception's backtrace.

raise -- a raise statement without arguments re-raises

the last exception raised in the current function

An exception is either a string (object) or a class instance.

Can create a new one simply by creating a new string:

my_exception = 'You did something wrong'

try:

if bad:

raise my_exception, bad

except my_exception, value:

print 'Oops', value

Exception classes must be derived from the predefined class: Exception, e.g.:

class text_exception(Exception): pass

try:

if bad:

raise text_exception()

# This is a shorthand for the form

# "raise <class>, <instance>"

except Exception:

print 'Oops'

# This will be printed because

# text_exception is a subclass of Exception

When an error message is printed for an unhandled exception which is a

class, the class name is printed, then a colon and a space, and

finally the instance converted to a string using the built-in function

str().

All built-in exception classes derives from Exception, itself

derived from BaseException.

Name Space Statements

[1.51: On Mac & Windows, the case of module file names must now match the case

as used

in the import statement]

Packages (>1.5): a package is a name space which maps to a directory including

module(s) and the special initialization module '__init__.py'

(possibly empty). Packages/dirs can be nested. You address a

module's symbol via '[package.[package...]module.symbol's.

import module1 [as name1] [, module2]*

-- imports modules. Members of module must be

referred to by qualifying with [package.]module name:

"import sys; print sys.argv:"

"import package1.subpackage.module; package1.subpackage.module.foo()"

module1 renamed as name1, if supplied.

from module import name1 [as othername1] [, name2]*

-- imports names from module module in current namespace.

"from sys import argv; print argv"

"from package1 import module; module.foo()"

"from package1.module import foo; foo()"

name1 renamed as othername1, if supplied.

from module import *

-- imports all names in module, except those starting with "_";

*to be used sparsely, beware of name clashes* :

"from sys import *; print argv"

"from package.module import *; print x'

NB: "from package import *" only imports the symbols defined

in the package's __init__.py file, not those in the

template modules!

global name1 [, name2]*

-- names are from global scope (usually meaning from module)

rather than local (usually meaning only in function).

-- E.g. in fct without "global" statements, assuming

"a" is name that hasn't been used in fct or module

so far:

-Try to read from "a" -> NameError

-Try to write to "a" -> creates "a" local to fcn

-If "a" not defined in fct, but is in module, then

-Try to read from "a", gets value from module

-Try to write to "a", creates "a" local to fct

But note "a[0]=3" starts with search for "a",

will use to global "a" if no local "a".

Function Definition

def func_id ([param_list]): suite

-- Creates a function object & binds it to name func_id.

param_list ::= [id [, id]*]

id ::= value | id = value | *id | **id

[Args are passed by value.Thus only args representing a mutable object

can be modified (are inout parameters). Use a tuple to return more than

one value]

Example:

def test (p1, p2 = 1+1, *rest, **keywords):

-- Parameters with "=" have default value (v is

evaluated when function defined).

If list has "*id" then id is assigned a tuple of

all remaining args passed to function (like C vararg)

If list has "**id" then id is assigned a dictionary of

all extra arguments passed as keywords.

Class Definition

class <class_id> [(<super_class1> [,<super_class2>]*)]: <suite>

-- Creates a class object and assigns it name <class_id>

<suite> may contain local "defs" of class methods and

assignments to class attributes.

Example:

class my_class (class1, class_list[3]): ...

Creates a class object inheriting from both "class1" and whatever

class object "class_list[3]" evaluates to. Assigns new

class object to name "my_class".

- First arg to class methods is always instance object, called 'self'

by convention.

- Special method __init__() is called when instance is created.

- Special method __del__() called when no more reference to object.

- Create instance by "calling" class object, possibly with arg

(thus instance=apply(aClassObject, args...) creates an instance!)

- In current implementation, can't subclass off built-in

classes. But can "wrap" them, see UserDict & UserList modules,

and see __getattr__() below.

Example:

class c (c_parent):

def __init__(self, name): self.name = name

def print_name(self): print "I'm", self.name

def call_parent(self): c_parent.print_name(self)

instance = c('tom')

print instance.name

'tom'

instance.print_name()

"I'm tom"

Call parent's super class by accessing parent's method

directly and passing "self" explicitly (see "call_parent"

in example above).

Many other special methods available for implementing

arithmetic operators, sequence, mapping indexing, etc.

Documentation Strings

Modules, classes and functions may be documented by placing a string literal by

itself as the first statement in the suite. The documentation can be retrieved

by getting the '__doc__' attribute from the module, class or function.

Example:

class C:

"A description of C"

def __init__(self):

"A description of the constructor"

# etc.

Then c.__doc__ == "A description of C".

Then c.__init__.__doc__ == "A description of the constructor".

Others

lambda [param_list]: returnedExpr

-- Creates an anonymous function. returnedExpr must be

an expression, not a statement (e.g., not "if xx:...",

"print xxx", etc.) and thus can't contain newlines.

Used mostly for filter(), map() functions, and GUI callbacks..

List comprehensions

result = [expression for item1 in sequence1 [if condition1]

[for item2 in sequence2 ... for itemN in sequenceN]

]

is equivalent to:

result = []

for item1 in sequence1:

for item2 in sequence2:

...

for itemN in sequenceN:

if (condition1) and furthur conditions:

result.append(expression)

Built-In Functions

Built-In Functions

Function Result

__import__(name[, Imports module within the given context (see lib ref for

globals[, locals[, more details)

fromlist]]])

abs(x) Return the absolute value of number x.

bool(x) Returns True when the argument x is true and False otherwise.

buffer(obj) Creates a buffer reference to an object.

chr(i) Returns one-character string whose ASCII code isinteger i

classmethod(f) Converts a function f, into a method with the class as the

first argument. Useful for creating alternative constructors.

cmp(x,y) Returns negative, 0, positive if x <, ==, > to y

compile(string, from which the code was read, or eg. '<string>'if not read

filename, kind) from file.kind can be 'eval' if string is a single stmt, or

'single' which prints the output of expression statements

that evaluate to something else than None, or be 'exec'.

complex(real[, Builds a complex object (can also be done using J or j

image]) suffix,e.g. 1+3J)

delattr(obj, name) deletes attribute named name of object obj <=> del obj.name

If no args, returns the list of names in current

dict([items]) Create a new dictionary from the specified item list.

dir([object]) local symbol table. With a module, class or class

instance object as arg, returns list of names in its attr.

dict.

divmod(a,b) Returns tuple of (a/b, a%b)

enumerate(seq) Return a iterator giving: (0, seq[0]), (1, seq[1]), ...

eval(s[, globals[, Eval string s in (optional) globals, locals contexts.s must

locals]]) have no NUL's or newlines. s can also be acode object.

Example: x = 1; incr_x = eval('x + 1')

filter(function, Constructs a list from those elements of sequence for which

sequence) function returns true. function takes one parameter.

float(x) Converts a number or a string to floating point.

getattr(object, [<default> arg added in 1.5.2]Gets attribute called name

name[, default])) from object,e.g. getattr(x, 'f') <=> x.f). If not found,

raises AttributeError or returns default if specified.

globals() Returns a dictionary containing current global variables.

hasattr(object, Returns true if object has attr called name.

name)

hash(object) Returns the hash value of the object (if it has one)

help(f) Display documentation on object f.

hex(x) Converts a number x to a hexadecimal string.

id(object) Returns a unique 'identity' integer for an object.

int(x[, base]) base paramenter specifies base from which to convert string

values.

isinstance(obj, Returns true if obj is an instance of class. Ifissubclass

class) (A,B) then isinstance(x,A) => isinstance(x,B)

issubclass(class1, returns true if class1 is derived from class2

class2)

Returns the length (the number of items) of an object

iter(collection) Returns an iterator over the collection.

len(obj) (sequence, dictionary, or instance of class implementing

__len__).

list(sequence) Converts sequence into a list. If already a list,returns a

copy of it.

locals() Returns a dictionary containing current local variables.

Applies function to every item of list and returns a listof

map(function, list, the results. If additional arguments are passed,function

...) must take that many arguments and it is givento function on

each call.

max(seq) Returns the largest item of the non-empty sequence seq.

min(seq) Returns the smallest item of a non-empty sequence seq.

oct(x) Converts a number to an octal string.

open(filename [, Returns a new file object. First two args are same asthose

mode='r', [bufsize= for C's "stdio open" function. bufsize is 0for unbuffered,

implementation 1 for line-buffered, negative forsys-default, all else, of

dependent]]) (about) given size.

ord(c) Returns integer ASCII value of c (a string of len 1). Works

with Unicode char.

object() Create a base type. Used as a superclass for new-style objects.

open(name Open a file.

[, mode

[, buffering]])

pow(x, y [, z]) Returns x to power y [modulo z]. See also ** operator.

property() Created a property with access controlled by functions.

range(start [,end Returns list of ints from >= start and < end. With 1 arg,

[, step]]) list from 0..arg-1. With 2 args, list from start..end-1.

With 3 args, list from start up to end by step

after fixing it.

repr(object) Returns a string containing a printable and if possible

evaluable representation of an object.

Class redefinable (__repr__). See also str().

round(x, n=0) Returns the floating point value x rounded to n digitsafter