diff --git a/Misc/cheatsheet b/Misc/cheatsheet
index 204b51b..a4d96e2 100644
--- a/Misc/cheatsheet
+++ b/Misc/cheatsheet
@@ -1,541 +1,2218 @@
- 			  A Python Bestiary
-		 Itemizing Python Objects and Nuances
+                          Python 2.0 Quick Reference
 
-   $Revision$ $Date$ 	ken.manheimer@nist.gov
 
-  			   Notable lexical entities
-			   ========================
 
-    Keywords
+ 16 May 2001  upgraded by Richard Gruet and Simon Brunning for Python 2.0
+ 2000/07/18  upgraded by Richard Gruet, rgruet@intraware.com for Python 1.5.2
+from V1.3 ref
+1995/10/30, by Chris Hoffmann, choffman@vicorp.com
 
-     	access	       and	      break	     class
-     	continue       def	      del	     elif
-     	else	       except	      exec	     finally
-     	for	       from	      global	     if
-     	import	       in	      is	     lambda
-     	not	       or	      pass	     print
-     	raise	       return	      try	     while
+Based on:
+    Python Bestiary, Author: Ken Manheimer, ken.manheimer@nist.gov
+    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, tim_one@email.msn.com
+
+    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: help@python.org
+Resources: http://starship.python.net/ and http://www.vex.net/parnassus/
+Full documentation: http://www.python.org/doc/
+An excellent Python reference book: Python Essential Reference by David Beazley
+(New Riders)
+
+
+Contents
+
+  * Invocation Options
+  * Environment Variables
+  * Lexical Entities : keywords, identifiers, strings, numbers, sequences,
+    dictionaries, operators
+  * Basic Types And Their Operations
+  * Advanced Types
+  * Statements
+  * Built In Functions
+  * Built In Exceptions
+  * Standard methods & operators redefinition in user-created Classes
+  * Special informative state attributes for some types
+  * Important Modules : sys, os, posix, posixpath, shutil, time, string, re,
+    math, getopt
+  * List of modules In base distribution
+  * Workspace Exploration And Idiom Hints
+  * Python Mode for Emacs
+  * The Python Debugger
+
+
+
+Invocation Options
+
+python [-diOStuUvxX?] [-c command | script | - ] [args]
+
+                              Invocation Options
+Option                                  Effect
+-d      Outputs parser debugging information (also PYTHONDEBUG=x)
+-i      Inspect interactively after running script (also PYTHONINSPECT=x) and
+        force prompts, even if stdin appears not to be a terminal
+-O      Optimize generated bytecode (set __debug__ = 0 =>s suppresses asserts)
+-S      Don't perform 'import site' on initialization
+-t      Issue warnings about inconsistent tab usage (-tt: issue errors)
+-u      Unbuffered binary stdout and stderr (also PYTHONUNBUFFERED=x).
+-U      Force Python to interpret all string literals as Unicode literals.
+-v      Verbose (trace import statements) (also PYTHONVERBOSE=x)
+-x      Skip first line of source, allowing use of non-unix Forms of #!cmd
+[DEL:-X [DEL:Disable class based built-in exceptions (for backward
+:DEL]   compatibility management of exceptions):DEL]
+-?      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
+    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)		\0XX  char with
-     \" Double quote (")     \n Linefeed (LF)		      octal value XX
-     \a Bell (BEL)	     \r Carriage Return (CR)	\xXX  char with
-     \b Backspace (BS)	     \t Horizontal Tab (TAB)	      hex value XX
+     \\ 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
 
-    Illegitimate Tokens (only valid in strings): @ $ ?
+  * 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.
 
-   Operating environment (Unix)
+Numbers
 
-    Shell environment vars:
+    Decimal integer: 1234, 1234567890546378940L        (or l)
+    Octal integer: 0177, 0177777777777777777L (begin with a 0)
+    Hex integer: 0xFF, 0XFFFFffffFFFFFFFFFFL (begin with 0x or 0X)
+    Long integer (unlimited precision): 1234567890123456L (ends with L or l)
+    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)
 
-     PYTHONPATH:    dirs to be prepended to module search path; a la shell PATH
-     PYTHONSTARTUP: names path of file to be loaded on interactive startup
+Sequences
 
-    Internal (module sys) vars ('import sys' to refer to them):
+  * 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]
 
-     argv		- list of command and arguments passed to python script
-     builtin_module_names - list of names of modules compiled in to python
-   ( exc_* values are set only during handling of a raised exception)
-     exc_type		- type of exception being handled
-     exc_value		- exception's parameter ('raise's 2nd arg)
-     exc_traceback	- exception's traceback obj
-     exit(N)		- exit from python with status N, by raising SystemExit
-     exitfunc		- function hook, to be called on exit if set
-     last_type		- type of last unhandled exception
-     last_value		- value of last unhandled exception
-     last_traceback	- traceback of last unhandled exception
-     modules		- list of modules already loaded
-     path		- list of strings specifying module-load search path
-     ps1='>>>'		- string specifying primary prompt, iff interactive
-     ps2='...'		- string specifying secondary prompt, iff interactive
-     settrace		- system trace function, used by debuggers, etc
-     setprofile		- system profile function
-     stdin		- standard input file object
-     stdout		- standard output file object
-     stderr		- standard error file object
-     tracebacklimit=1000 - maximum number of traceback levels to print
+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'.
 
-     Objects - behaviors, special attributes, operations, statements, etc
-     ====================================================================
+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.
 
-    General object aspects
+Dictionaries (Mappings)
 
-     Boolean values and operators
+    Dictionary of length 0, 1, 2, etc:
+    {} {1 : 'first'} {1 : 'first',  'next': 'second'}
 
-      False values:	None, numeric zeros, empty sequences and mappings
-      True values:	all other values
+Operators and their evaluation order
 
-      not X: if X is false then 1, else 0
-    ( 'or', 'and' evaluate second arg only if necessary to determine outcome)
-      X or Y: if X is false then Y, else X
-      X and Y: if X is false then X, else Y
+                     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                     mult, division, modulo
+        x+y  x-y                          addition, substraction
+        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<>y                              identity,
+        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
 
-     Special methods for any type				(s: self)
+Alternate names are defined in module operator (e.g. __add__ and add for +)
+Most operators are overridable
 
-      id(obj)		unique identifier for object (currently, its address)
-      __init__(s, args)	object instantiation - see Classes, below
-      __del__(s)	object demise
-      __repr__(s)	repr() and `...` conversions
-      __str__(s)	str() and 'print' statement
-      __cmp__(s)	implements <, ==, >, <=, <>, !=, >=, is [not]
-      __hash__(s)	hash() and dictionary operations
 
-     Special informative state attributes for some types:
+Basic Types and Their Operations
 
-      X.__dict__	dict used to store object's writeable attributes
-      X.__methods__	list of X's methods; on many built-in types.
-      X.__members__	lists of X's data attributes
-      X.__class__	class to which X belongs
-      X.__bases__	tuple of X base classes
+Comparisons (defined between *any* types)
 
-     General Name Space behavior and binding
+               Comparisons
+Comparison         Meaning          Notes
+<          strictly less than        (1)
+<=         less than or equal to
+>          strictly greater than
+>=         greater than or equal to
+==         equal to
+!= or <>   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__.
+    (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 __nonzero__.
+    (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, integers and long integers.
+
+    Floats are implemented with C doubles.
+    Integers are implemented with C longs.
+    Long 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
+long(x)      x converted to long 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 and long 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
+
+Operations on all sequence types (lists, tuples, strings)
+
+                Operations on all sequence types
+Operation                     Result                     Notes
+x in s     1 if an item of s is equal to x, else 0
+x not in s 0 if an item of s is equal to x, else 1
+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)
+
+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.extend(x)      same as s[len(s):len(s)]= x                (5)
+s.count(x)       return number of i's for which s[i] == 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.remove(x)      same as del s[s.index(x)]                  (1)
+s.pop([i])       same as x = s[i]; del s[i]; return x       (4)
+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 pop() method is experimental and not supported by
+other mutable sequence types than lists.
+          The optional  argument i defaults to -1, so that by default the last
+item is removed and returned.
+     (5) [New 1.5.2] Experimental ! Raises an exception when x is not a list
+object.
+
+
+
+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.has_key(k)               1 if d has key k, else 0
+d.items()                  a copy of d's list of (key, item) pairs  (2)
+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.get(k,defaultval)        the item of d with key k                 (4)
+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.
+
+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.encode([        return an encoded version of s. Default encoding is the
+encoding[,errors  current default string encoding.                         (3)
+]])
+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.
+
+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 hexidecimal (lowercase).
+X          Unsigned hexidecimal (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()        1 if file f is connected to a tty-like dev, else 0.
+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
+
+
+    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.
+
+    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 StandardError, itself
+derived from Exception.
+
+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(), reduce() 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.
+apply(f, args[,     Calls func/method f with arguments args and optional
+keywords])          keywords.
+callable(x)         Returns 1 if x callable, else 0.
+chr(i)              Returns one-character string whose ASCII code isinteger i
+cmp(x,y)            Returns negative, 0, positive if x <, ==, > to y
+coerce(x,y)         Returns a tuple of the two numeric arguments converted to a
+                    common type.
+                    Compiles string into a code object.filename is used in
+                    error message, can be any string. It isusually the file
+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
+                    thatevaluate 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
+dir([object])       localsymbol table. With a module, class or class
+                    instanceobject as arg, returns list of names in its attr.
+                    dict.
+divmod(a,b)         Returns tuple of (a/b, a%b)
+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')
+execfile(file[,     Executes a file without creating a new module, unlike
+globals[, locals]]) import.
+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,
+                    raisesAttributeError 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)
+hex(x)              Converts a number x to a hexadecimal string.
+id(object)          Returns a unique 'identity' integer for an object.
+input([prompt])     Prints prompt if given. Reads input and evaluates it.
+                    Converts a number or a string to a plain integer. Optional
+int(x[, base])      base paramenter specifies base from which to convert string
+                    values.
+intern(aString)     Enters aString in the table of "interned strings"
+                    andreturns the string. Interned strings are 'immortals'.
+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
+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.
+                    Converts a number or a string to a long integer. Optional
+long(x[, base])     base paramenter specifies base from which to convert string
+                    values.
+                    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.
+pow(x, y [, z])     Returns x to power y [modulo z]. See also ** operator.
+range(start [,end   Returns list of ints from >= start and < end.With 1 arg,
+[, step]])          list from 0..arg-1With 2 args, list from start..end-1With 3
+                    args, list from start up to end by step
+raw_input([prompt]) Prints prompt if given, then reads string from stdinput (no
+                    trailing \n). See also input().
+reduce(f, list [,   Applies the binary function f to the items oflist so as to
+init])              reduce the list to a single value.If init given, it is
+                    "prepended" to list.
+                    Re-parses and re-initializes an already imported module.
+                    Useful in interactive mode, if you want to reload amodule
+reload(module)      after fixing it. If module was syntacticallycorrect but had
+                    an error in initialization, mustimport it one more time
+                    before calling reload().
+                    Returns a string containing a printable and if possible
+repr(object)        evaluable representation of an object. <=> `object`
+                    (usingbackquotes). Class redefinissable (__repr__). See
+                    also str()
+round(x, n=0)       Returns the floating point value x rounded to n digitsafter
+                    the decimal point.
+setattr(object,     This is the counterpart of getattr().setattr(o, 'foobar',
+name, value)        3) <=> o.foobar = 3Creates attribute if it doesn't exist!
+slice([start,] stop Returns a slice object representing a range, with R/
+[, step])           Oattributes: start, stop, step.
+                    Returns a string containing a nicely
+str(object)         printablerepresentation of an object. Class overridable
+                    (__str__).See also repr().
+tuple(sequence)     Creates a tuple with same elements as sequence. If already
+                    a tuple, return itself (not a copy).
+                    Returns a type object [see module types] representing
+                    thetype of obj. Example: import typesif type(x) ==
+type(obj)           types.StringType: print 'It is a string'NB: it is
+                    recommanded to use the following form:if isinstance(x,
+                    types.StringType): etc...
+unichr(code)        code.
+unicode(string[,    Creates a Unicode string from a 8-bit string, using
+encoding[, error    thegiven encoding name and error treatment ('strict',
+]]])                'ignore',or 'replace'}.
+                    Without arguments, returns a dictionary correspondingto the
+                    current local symbol table. With a module,class or class
+vars([object])      instance object as argumentreturns a dictionary
+                    corresponding to the object'ssymbol table. Useful with "%"
+                    formatting operator.
+xrange(start [, end Like range(), but doesn't actually store entire listall at
+[, step]])          once. Good to use in "for" loops when there is abig range
+                    and little memory.
+zip(seq1[, seq2,    Returns a list of tuples where each tuple contains the nth
+...])               element of each of the argument sequences.
+
+
+
+
+Built-In Exceptions
+
+Exception>
+         Root class for all exceptions
+    SystemExit
+         On 'sys.exit()'
+    StandardError
+                 Base class for all built-in exceptions; derived from Exception
+    root class.
+        ArithmeticError
+                 Base class for OverflowError, ZeroDivisionError,
+    FloatingPointError
+            FloatingPointError
+                       When a floating point operation fails.
+            OverflowError
+                            On excessively large arithmetic operation
+            ZeroDivisionError
+                  On division or modulo operation with 0 as 2nd arg
+            AssertionError
+                When an assert statement fails.
+        AttributeError
+                    On attribute reference or assignment failure
+        EnvironmentError    [new in 1.5.2]
+                On error outside Python; error arg tuple is (errno, errMsg...)
+            IOError    [changed in 1.5.2]
+               I/O-related operation failure
+            OSError    [new in 1.5.2]
+               used by the os module's os.error exception.
+        EOFError
+                    Immediate end-of-file hit by input() or raw_input()
+        ImportError
+         On failure of `import' to find module or name
+        KeyboardInterrupt
+         On user entry of the interrupt key (often `Control-C')
+        LookupError
+                base class for IndexError, KeyError
+            IndexError
+                 On out-of-range sequence subscript
+            KeyError
+                 On reference to a non-existent mapping (dict) key
+        MemoryError
+         On recoverable memory exhaustion
+        NameError
+         On failure to find a local or global (unqualified) name
+        RuntimeError
+         Obsolete catch-all; define a suitable error instead
+          NotImplementedError   [new in 1.5.2]
+                On method not implemented
+        SyntaxError
+         On parser encountering a syntax error
+       IndentationError
+           On parser encountering an indentation syntax error
+       TabError
+           On parser encountering an indentation syntax error
+        SystemError
+         On non-fatal interpreter error - bug - report it
+        TypeError
+         On passing inappropriate type to built-in op or func
+        ValueError
+         On arg error not covered by TypeError or more precise
+
+
+
+Standard methods & operators redefinition in classes
+
+Standard methods & operators map to special '__methods__' and thus may be
+ redefined (mostly in in user-defined classes), e.g.:
+    class x:
+         def __init__(self, v): self.value = v
+         def __add__(self, r): return self.value + r
+    a = x(3) # sort of like calling x.__init__(a, 3)
+    a + 4    # is equivalent to a.__add__(4)
+
+Special methods for any class
+
+(s: self, o: other)
+        __init__(s, args) instance initialization (on construction)
+        __del__(s)        called on object demise (refcount becomes 0)
+        __repr__(s)       repr() and `...` conversions
+        __str__(s)        str() and 'print' statement
+        __cmp__(s, o)     Compares s to o and returns <0, 0, or >0.
+                          Implements >, <, == etc...
+        __hash__(s)       Compute a 32 bit hash code; hash() and dictionary ops
+        __nonzero__(s)    Returns 0 or 1 for truth value testing
+        __getattr__(s, name)  called when attr lookup doesn't find <name>
+        __setattr__(s, name, val) called when setting an attr
+                                  (inside, don't use "self.name = value"
+                                   use "self.__dict__[name] = val")
+        __delattr__(s, name)  called to delete attr <name>
+        __call__(self, *args) called when an instance is called as function.
+
+Operators
+
+    See list in the operator module. Operator function names are provided with
+    2 variants, with or without
+    ading & trailing '__' (eg. __add__ or add).
+
+    Numeric operations special methods
+    (s: self, o: other)
+
+        s+o       =  __add__(s,o)         s-o        =  __sub__(s,o)
+        s*o       =  __mul__(s,o)         s/o        =  __div__(s,o)
+        s%o       =  __mod__(s,o)         divmod(s,o) = __divmod__(s,o)
+        s**o      =  __pow__(s,o)
+        s&o       =  __and__(s,o)
+        s^o       =  __xor__(s,o)         s|o        =  __or__(s,o)
+        s<<o      =  __lshift__(s,o)      s>>o       =  __rshift__(s,o)
+        nonzero(s) = __nonzero__(s) (used in boolean testing)
+        -s        =  __neg__(s)           +s         =  __pos__(s)
+        abs(s)    =  __abs__(s)           ~s         =  __invert__(s)  (bitwise)
+        s+=o      =  __iadd__(s,o)        s-=o       =  __isub__(s,o)
+        s*=o      =  __imul__(s,o)        s/=o       =  __idiv__(s,o)
+        s%=o      =  __imod__(s,o)
+        s**=o     =  __ipow__(s,o)
+        s&=o      =  __iand__(s,o)
+        s^=o      =  __ixor__(s,o)        s|=o       =  __ior__(s,o)
+        s<<=o     =  __ilshift__(s,o)     s>>=o      =  __irshift__(s,o)
+        Conversions
+        int(s)    =  __int__(s)           long(s)    =  __long__(s)
+        float(s)  =  __float__(s)         complex(s)    =  __complex__(s)
+        oct(s)    =  __oct__(s)           hex(s)     =  __hex__(s)
+        coerce(s,o) = __coerce__(s,o)
+        Right-hand-side equivalents for all binary operators exist;
+        are called when class instance is on r-h-s of operator:
+        a + 3  calls __add__(a, 3)
+        3 + a  calls __radd__(a, 3)
+
+    All seqs and maps, general operations plus:
+    (s: self, i: index or key)
+
+        len(s)    = __len__(s)        length of object, >= 0.  Length 0 == false
+        s[i]      = __getitem__(s,i)  Element at index/key i, origin 0
+
+    Sequences, general methods, plus:
+      s[i]=v           = __setitem__(s,i,v)
+      del s[i]         = __delitem__(s,i)
+      s[i:j]           = __getslice__(s,i,j)
+      s[i:j]=seq       = __setslice__(s,i,j,seq)
+      del s[i:j]       = __delslice__(s,i,j)   == s[i:j] = []
+      seq * n          = __repeat__(seq, n)
+      s1 + s2          = __concat__(s1, s2)
+      i in s           = __contains__(s, i)
+    Mappings, general methods, plus
+      hash(s)          = __hash__(s) - hash value for dictionary references
+      s[k]=v           = __setitem__(s,k,v)
+      del s[k]         = __delitem__(s,k)
+
+Special informative state attributes for some types:
+
+    Lists & Dictionaries:
+        __methods__ (list, R/O): list of method names of the object
+
+    Modules:
+        __doc__ (string/None, R/O): doc string (<=> __dict__['__doc__'])
+        __name__(string, R/O): module name (also in __dict__['__name__'])
+        __dict__ (dict, R/O): module's name space
+        __file__(string/undefined, R/O): pathname of .pyc, .pyo or .pyd (undef for
+                 modules statically linked to the interpreter)
+        __path__(string/undefined, R/O): fully qualified package name when applies.
+
+    Classes:    [in bold: writable since 1.5.2]
+        __doc__ (string/None, R/W): doc string (<=> __dict__['__doc__'])
+        __name__(string, R/W): class name (also in __dict__['__name__'])
+        __bases__ (tuple, R/W): parent classes
+        __dict__ (dict, R/W): attributes (class name space)
+
+    Instances:
+        __class__ (class, R/W): instance's class
+        __dict__ (dict, R/W): attributes
+    User-defined functions: [bold: writable since 1.5.2]
+        __doc__ (string/None, R/W): doc string
+        __name__(string, R/O): function name
+        func_doc (R/W): same as __doc__
+        func_name (R/O): same as __name__
+        func_defaults (tuple/None, R/W): default args values if any
+        func_code (code, R/W): code object representing the compiled function body
+        func_globals (dict, R/O): ref to dictionary of func global variables
+
+    User-defined Methods:
+        __doc__ (string/None, R/O): doc string
+        __name__(string, R/O): method name (same as im_func.__name__)
+        im_class (class, R/O): class defining the method (may be a base class)
+        im_self (instance/None, R/O): target instance object (None if unbound)
+        im_func (function, R/O): function object
+    Built-in Functions & methods:
+        __doc__ (string/None, R/O): doc string
+        __name__ (string, R/O): function name
+        __self__ : [methods only] target object
+        __members__ = list of attr names: ['__doc__','__name__','__self__'])
+    Codes:
+        co_name (string, R/O): function name
+        co_argcount (int, R/0): number of positional args
+        co_nlocals (int, R/O): number of local vars (including args)
+        co_varnames (tuple, R/O): names of local vars (starting with args)
+        co_code (string, R/O): sequence of bytecode instructions
+        co_consts (tuple, R/O): litterals used by the bytecode, 1st one is
+                                fct doc (or None)
+        co_names (tuple, R/O): names used by the bytecode
+        co_filename (string, R/O): filename from which the code was compiled
+        co_firstlineno (int, R/O): first line number of the function
+        co_lnotab (string, R/O): string encoding bytecode offsets to line numbers.
+        co_stacksize (int, R/O): required stack size (including local vars)
+        co_firstlineno (int, R/O): first line number of the function
+        co_flags (int, R/O): flags for the interpreter
+                           bit 2 set if fct uses "*arg" syntax
+                           bit 3 set if fct uses '**keywords' syntax
+    Frames:
+        f_back (frame/None, R/O): previous stack frame (toward the caller)
+        f_code (code, R/O): code object being executed in this frame
+        f_locals (dict, R/O): local vars
+        f_globals (dict, R/O): global vars
+        f_builtins (dict, R/O): built-in (intrinsic) names
+        f_restricted (int, R/O): flag indicating whether fct is executed in
+                                 restricted mode
+        f_lineno (int, R/O): current line number
+        f_lasti (int, R/O): precise instruction (index into bytecode)
+        f_trace (function/None, R/W): debug hook called at start of each source line
+        f_exc_type (Type/None, R/W): Most recent exception type
+        f_exc_value (any, R/W): Most recent exception value
+        f_exc_traceback (traceback/None, R/W): Most recent exception traceback
+    Tracebacks:
+        tb_next (frame/None, R/O): next level in stack trace (toward the frame where
+                                  the exception occurred)
+        tb_frame (frame, R/O): execution frame of the current level
+        tb_lineno (int, R/O): line number where the exception occured
+        tb_lasti (int, R/O): precise instruction (index into bytecode)
+
+    Slices:
+        start (any/None, R/O): lowerbound
+        stop (any/None, R/O): upperbound
+        step (any/None, R/O): step value
+
+    Complex numbers:
+        real (float, R/O): real part
+        imag (float, R/O): imaginary part
+    XRanges:
+        tolist (Built-in method, R/O): ?
+
+
+Important Modules
+
+                                      sys
+
+                              Some sys variables
+      Variable                                Content
+argv                 The list of command line arguments passed to aPython
+                     script. sys.argv[0] is the script name.
+builtin_module_names A list of strings giving the names of all moduleswritten
+                     in C that are linked into this interpreter.
+check_interval       How often to check for thread switches or signals(measured
+                     in number of virtual machine instructions)
+exc_type, exc_value, Deprecated since release 1.5. Use exc_info() instead.
+exc_traceback
+exitfunc             User can set to a parameterless fcn. It will getcalled
+                     before interpreter exits.
+last_type,           Set only when an exception not handled andinterpreter
+last_value,          prints an error. Used by debuggers.
+last_traceback
+maxint               maximum positive value for integers
+modules              Dictionary of modules that have already been loaded.
+path                 Search path for external modules. Can be modifiedby
+                     program. sys.path[0] == dir of script executing
+platform             The current platform, e.g. "sunos5", "win32"
+ps1, ps2             prompts to use in interactive mode.
+                     File objects used for I/O. One can redirect byassigning a
+stdin, stdout,       new file object to them (or any object:.with a method
+stderr               write(string) for stdout/stderr,.with a method readline()
+                     for stdin)
+version              string containing version info about Python interpreter.
+                     (and also: copyright, dllhandle, exec_prefix, prefix)
+version_info         tuple containing Python version info - (major, minor,
+                     micro, level, serial).
 
-      Name space search order: local, global, builtin
+                              Some sys functions
+     Function                                 Result
+exit(n)            Exits with status n. Raises SystemExit exception.(Hence can
+                   be caught and ignored by program)
+getrefcount(object Returns the reference count of the object. Generally 1
+)                  higherthan you might expect, because of object arg temp
+                   reference.
+setcheckinterval(  Sets the interpreter's thread switching interval (in number
+interval)          ofvirtualcode instructions, default:10).
+settrace(func)     Sets a trace function: called before each line ofcode is
+                   exited.
+setprofile(func)   Sets a profile function for performance profiling.
+                   Info on exception currently being handled; this is atuple
+                   (exc_type, exc_value, exc_traceback).Warning: assigning the
+exc_info()         traceback return value to a loca variable in a
+                   functionhandling an exception will cause a circular
+                   reference.
+setdefaultencoding Change default Unicode encoding - defaults to 7-bit ASCII.
+(encoding)
+getrecursionlimit  Retrieve maximum recursion depth.
+()
+setrecursionlimit  Set maximum recursion depth. (Defaults to 1000.)
+()
 
-      "global" name space = file = module
-      "local" name space = function or method
 
-      Code Block scopes		(ns = name space, cb = containing block)
 
-     ( global ns generally is containing module, unless overriden by args)
+                                      os
+"synonym" for whatever O/S-specific module is proper for current environment.
+this module uses posix whenever possible.
+(see also M.A. Lemburg's utility http://www.lemburg.com/files/python/
+platform.py)
 
-       Code block type	Local ns		Notes
-       ---------------	--------		-----
-       Module		same as global ns
-       Script		same as global ns	global ns is __main__
-       Interactive cmd	same as global ns	global ns is __main__
-       Class def	new ns
-       Function body	new ns
-       'exec' string	local ns of cb	    (or args)
-       'eval' string	local ns of caller  (or args)
-       'execfile' file	local ns of caller  (or args)
-       'input' expr	local ns of caller
+                               Some os variables
+     Variable                                 Meaning
+name                name of O/S-specific module (e.g. "posix", "mac", "nt")
+path                O/S-specific module for path manipulations.
+                    On Unix, os.path.split() <=> posixpath.split()
+curdir              string used to represent current directory ('.')
+pardir              string used to represent parent directory ('..')
+sep                 string used to separate directories ('/' or '\'). Tip: use
+                    os.path.join() to build portable paths.
+altsep              Alternate sep
+if applicable (None
+otherwise)
+pathsep             character used to separate search path components (as in
+                    $PATH), eg. ';' for windows.
+linesep             line separator as used in binary files, ie '\n' on Unix, '\
+                    r\n' on Dos/Win, '\r'
 
-      Binding operations and exceptions:
+                               Some os functions
+     Function                                 Result
+makedirs(path[,     Recursive directory creation (create required intermediary
+mode=0777])         dirs); os.error if fails.
+removedirs(path)    Recursive directory delete (delete intermediary empty
+                    dirs); if fails.
+renames(old, new)   Recursive directory or file renaming; os.error if fails.
 
-     ~ SyntaxError: on attempt to bind to literals or other non-bindables
-     ~ NameError: on attempt to evaluate unbound atom
 
-     ( for object attribute functions, obj: object, nm: string, val: any value)
-       getattr(obj, nm)		get value of obj.nm
-       hasattr(obj, nm)		true if obj has nm attribute
-       setattr(obj, nm, val)	set obj.nm to val
 
-       assignment statement: 	targ1, targ2, ,,, = obj1, obj2, ,,,
-       deletion statement:	del obj1, obj2, ...
-       for loop target identifiers, 'except' clauses (see Statements, below)
-       formal params		(see Callables, below)
-       import statement		(see Modules objects, below)
-       class and func defs	(see Callables, below)
+                                     posix
+don't import this module directly, import os instead !
+(see also module: shutil for file copy & remove fcts)
 
-      Name space linkage
+                            posix Variables
+Variable                             Meaning
+environ  dictionary of environment variables, e.g.posix.environ['HOME'].
+error    exception raised on POSIX-related error.
+         Corresponding value is tuple of errno code and perror() string.
 
-       global statement: global var, ...	# Interpret 'var's as globals
-     X access statement: access ...	# control inst and class vars access
+                             Some posix functions
+   Function                                 Result
+chdir(path)     Changes current directory to path.
+chmod(path,     Changes the mode of path to the numeric mode
+mode)
+close(fd)       Closes file descriptor fd opened with posix.open.
+_exit(n)        Immediate exit, with no cleanups, no SystemExit,etc. Should use
+                this to exit a child process.
+execv(p, args)  "Become" executable p with args args
+getcwd()        Returns a string representing the current working directory
+getpid()        Returns the current process id
+fork()          Like C's fork(). Returns 0 to child, child pid to parent.[Not
+                on Windows]
+kill(pid,       Like C's kill [Not on Windows]
+signal)
+listdir(path)   Lists (base)names of entries in directory path, excluding '.'
+                and '..'
+lseek(fd, pos,  Sets current position in file fd to position pos, expressedas
+how)            an offset relative to beginning of file (how=0), tocurrent
+                position (how=1), or to end of file (how=2)
+mkdir(path[,    Creates a directory named path with numeric mode (default 0777)
+mode])
+open(file,      Like C's open(). Returns file descriptor. Use file object
+flags, mode)    fctsrather than this low level ones.
+pipe()          Creates a pipe. Returns pair of file descriptors (r, w) [Not on
+                Windows].
+popen(command,  Opens a pipe to or from command. Result is a file object to
+mode='r',       read to orwrite from, as indicated by mode being 'r' or 'w'.
+bufSize=0)      Use it to catch acommand output ('r' mode) or to feed it ('w'
+                mode).
+remove(path)    See unlink.
+rename(src, dst Renames/moves the file or directory src to dst. [error iftarget
+)               name already exists]
+rmdir(path)     Removes the empty directory path
+read(fd, n)     Reads n bytes from file descriptor fd and return as string.
+                Returns st_mode, st_ino, st_dev, st_nlink, st_uid,st_gid,
+stat(path)      st_size, st_atime, st_mtime, st_ctime.[st_ino, st_uid, st_gid
+                are dummy on Windows]
+system(command) Executes string command in a subshell. Returns exitstatus of
+                subshell (usually 0 means OK).
+                Returns accumulated CPU times in sec (user, system, children's
+times()         user,children's sys, elapsed real time). [3 last not on
+                Windows]
+unlink(path)    Unlinks ("deletes") the file (not dir!) path. same as: remove
+utime(path, (   Sets the access & modified time of the file to the given tuple
+aTime, mTime))  of values.
+wait()          Waits for child process completion. Returns tuple ofpid,
+                exit_status [Not on Windows]
+waitpid(pid,    Waits for process pid to complete. Returns tuple ofpid,
+options)        exit_status [Not on Windows]
+write(fd, str)  Writes str to file fd. Returns nb of bytes written.
 
-   @ Built-in Exceptions
 
-      AttributeError	On attribute reference or assignment failure
-      EOFError		Immediate end-of-file hit by input() or raw_input()
-      IOError		I/O-related I/O operation failure
-      ImportError	On failure of `import' to find module or name
-      IndexError	On out-of-range sequence subscript
-      KeyError		On reference to a non-existent mapping (dict) key
-      KeyboardInterrupt	On user entry of the interrupt key (often `Control-C')
-      MemoryError	On recoverable memory exhaustion
-      NameError		On failure to find a local or global (unqualified) name
-      OverflowError	On excessively large arithmetic operation
-      RuntimeError	Obsolete catch-all; define a suitable error instead
-      SyntaxError	On parser encountering a syntax error
-      SystemError	On non-fatal interpreter error - bug - report it
-      SystemExit	On `sys.exit()'
-      TypeError		On passing inappropriate type to built-in op or func
-      ValueError	On arg error not covered by TypeError or more precise
-      ZeroDivisionError	On division or modulo operation with 0 as 2nd arg
 
-    			       **** Numbers ****
+                                   posixpath
+Do not import this module directly, import os instead and refer to this module
+as os.path. (e.g. os.path.exists(p)) !
 
-   @ Integers: 'C' long, >= 32 bits precision; OverflowError if bounds exceeded
-   @ Long Integers: unlimited precision - '2147483648L'
-   @ Floating point: machine double-precision floating point - '2147483648.0'
+                           Some posixpath functions
+ Function                                 Result
+abspath(p) Returns absolute path for path p, taking current working dir in
+           account.
+dirname/
+basename(p directory and name parts of the path p. See also split.
+)
+exists(p)  True if string p is an existing path (file or directory)
+expanduser Returns string that is (a copy of) p with "~" expansion done.
+(p)
+expandvars Returns string that is (a copy of) p with environment vars expanded.
+(p)        [Windows: case significant; must use Unix: $var notation, not %var%]
+getsize(   return the size in bytes of filename. raise os.error.
+filename)
+getmtime(  return last modification time of filename (integer nb of seconds
+filename)  since epoch).
+getatime(  return last access time of filename (integer nb of seconds since
+filename)  epoch).
+isabs(p)   True if string p is an absolute path.
+isdir(p)   True if string p is a directory.
+islink(p)  True if string p is a symbolic link.
+ismount(p) True if string p is a mount point [true for all dirs on Windows].
+join(p[,q  Joins one or more path components intelligently.
+[,...]])
+           Splits p into (head, tail) where tail is lastpathname component and
+split(p)   <head> is everything leadingup to that. <=> (dirname(p), basename
+           (p))
+splitdrive Splits path p in a pair ('drive:', tail) [Windows]
+(p)
+splitext(p Splits into (root, ext) where last comp of root contains no periods
+)          and ext is empty or startswith a period.
+           Calls the function visit with arguments(arg, dirname, names) for
+           each directory recursively inthe directory tree rooted at p
+walk(p,    (including p itself if it's a dir)The argument dirname specifies the
+visit, arg visited directory, the argumentnames lists the files in the
+)          directory. The visit function maymodify names to influence the set
+           of directories visited belowdirname, e.g., to avoid visiting certain
+           parts of the tree.
 
-     Numeric operations vs special methods		(s = self, o = other)
 
-      s+o	=  __add__(s,o)		s-o	   =  __sub__(s,o)
-      s*o	=  __mul__(s,o)		s/o	   =  __div__(s,o)
-      s%o	=  __mod__(s,o)		divmod(s,o) = __divmod__(s,o)
-      pow(s,o)	=  __pow__(s,o)
-      s&o	=  __and__(s,o)		
-      s^o	=  __xor__(s,o)		s|o	   =  __xor__(s,o)
-      s<<o	=  __lshift__(s,o)	s>>o	   =  __rshift__(s,o)
-      nonzero(s) = __nonzero__(s)	coerce(s,o) = __coerce__(s,o)
-      -s  	=  __neg__(s)		+s	   =  __pos__(s)  
-      abs(s)	=  __abs__(s)		~s	   =  __invert__(s)  (bitwise)
-      int(s)  	=  __int__(s)		long(s)	   =  __long__(s)
-      float(s)	=  __float__(s)
-      oct(s)  	=  __oct__(s)		hex(s)	   =  __hex__(s)
 
-     Numeric functions:
+                                    shutil
+high-level file operations (copying, deleting).
 
-      range(start=0,end,step=1)  create arithmetic progression list
-      round(x, n=0)		 round floating point x to n decimal places
-      xrange(start=0,end,step=1) create virtual arithmetic progressions tuple
+                             Main shutil functions
+     Function                                 Result
+copy(src, dst)     Copies the contents of file src to file dst, retaining file
+                   permissions.
+copytree(src, dst  Recursively copies an entire directory tree rooted at src
+[, symlinks])      into dst (which should not already exist). If symlinks is
+                   true, links insrc are kept as such in dst.
+rmtree(path[,      Deletes an entire directory tree, ignoring errors if
+ignore_errors[,    ignore_errors true,or calling onerror(func, path,
+onerror]])         sys.exc_info()) if supplied with
 
-     Numeric exceptions:
+(and also: copyfile, copymode, copystat, copy2)
 
-    ~ TypeError: raised on application of arithemetic opertion to non-number
-    ~ OverflowError: numeric bounds exceeded
-    ~ ZeroDivisionError: raised when zero second argument of div or modulo op
+time
 
-    		**** Collections - Sequences and Mappings ****
+                                  Variables
+Variable                               Meaning
+altzone  signed offset of local DST timezone in sec west of the 0th meridian.
+daylight nonzero if a DST timezone is specified
 
-     Collections general operations vs methods  (s: self, i: index or key)
+                                   Functions
+  Function                                 Result
+time()        return a float representing UTC time in seconds since the epoch.
+gmtime(secs), return a tuple representing time : (year aaaa, month(1-12),day
+localtime(    (1-31), hour(0-23), minute(0-59), second(0-59), weekday(0-6, 0 is
+secs)         monday), Julian day(1-366), daylight flag(-1,0 or 1))
+asctime(
+timeTuple),
+strftime(
+format,       return a formated string representing time.
+timeTuple)
+mktime(tuple) inverse of localtime(). Return a float.
+strptime(     parse a formated string representing time, return tuple as in
+string[,      gmtime().
+format])
+sleep(secs)   Suspend execution for <secs> seconds. <secs> can be a float.
 
-      len(s)	= __len__(s)	    length of object, >= 0.  Length 0 == false
-      s[i]	= __getitem__(s,i)  Element at index/key i, origin 0
+and also: clock, ctime.
 
-     Sequences
+                                    string
 
-    @ String (immutable sequence): 'string contents'
+As of Python 2.0, much (though not all) of the functionality provided by the
+string module have been superseded by built-in string methods - see Operations
+on strings for details.
 
-       'this is a string'
-       "and so is this"
-       ''' and this begins a 'multi-line' string with embedded quotes...
-       and this is the end of that string.'''
+                             Some string variables
+              Variable                                Meaning
+digits                               The string '0123456789'
+hexdigits, octdigits                 legal hexadecimal & octal digits
+letters, uppercase, lowercase,       Strings containing the appropriate
+whitespace                           characters
+index_error                          Exception raised by index() if substr not
+                                     found.
 
-       `expr`		= __repr__(expr), converts arbitrary expr to string
-       chr(int)	 	string of ascii letter at ordinate in (0 <= int < 256)
-       ord(string) 	ascii ordinate of string (string must be length 1)
-       string % arg	format operator, a la C sprintf
-         arg for single directive can be any (suitable) type
-         arg for multiple directives must be tuple or dict
-         dict (mapping) arg uses parenthesized directives that are keys into it
-         supports %, c, s, i, d, u, o, x, X, e, E, f, g, G directives
-         * can be width and precision; directs use of corresponding (int) args
-         * can not be used with dict args
-         flag characters -, +, blank, #, and 0 understood.
-         %s conversion takes any python object, converts using `str()'
-         ANSI directives %p and %n not supported
-         %s conversions do *not* take \000 as end of string
+                             Some string functions
+     Function                                 Result
+expandtabs(s,      returns a copy of string <s> with tabs expanded.
+tabSize)
+find/rfind(s, sub  Return the lowest/highest index in <s> where the substring
+[, start=0[, end=  <sub> is found such that <sub> is wholly contained ins
+0])                [start:end]. Return -1 if <sub> not found.
+ljust/rjust/center Return a copy of string <s> left/right justified/centerd in
+(s, width)         afield of given width, padded with spaces. <s> is
+                   nevertruncated.
+lower/upper(s)     Return a string that is (a copy of) <s> in lowercase/
+                   uppercase
+split(s[, sep=     Return a list containing the words of the string <s>,using
+whitespace[,       the string <sep> as a separator.
+maxsplit=0]])
+join(words[, sep=' Concatenate a list or tuple of words with
+'])                interveningseparators; inverse of split.
+replace(s, old,    Returns a copy of string <s> with all occurences of
+new[, maxsplit=0]  substring<old> replaced by <new>. Limits to <maxsplit>
+                   firstsubstitutions if specified.
+strip(s)           Return a string that is (a copy of) <s> without leadingand
+                   trailing whitespace. see also lstrip, rstrip.
 
-    @ Tuples (immutable sequence): (oneelem, another, etc)
 
-       parens may be left off all but empty tuples
-       singletons represented by affixing a comma to an expr
-       empty tuple represented using empty parens
 
-    @ Lists (mutable sequence): [oneelem, another, etc]
+                                   re (sre)
 
-       assignment - must be 1-1 map of items in target and object sequences
-       deletion - similar rules as for assignment
+Handles Unicode strings. Implemented in new module sre, re now a mere front-end
+for compatibility.
+Patterns are specified as strings. Tip: Use raw strings (e.g. r'\w*') to
+litteralize backslashes.
 
-       List special methods: see mutable sequence ops vs methods, below
 
-      Sequences general ops vs methods	      (s: self, i,j: indices, v: val)
+                           Regular expression syntax
+   Form                                Description
+.          matches any character (including newline if DOTALL flag specified)
+^          matches start of the string (of every line in MULTILINE mode)
+$          matches end of the string (of every line in MULTILINE mode)
+*          0 or more of preceding regular expression (as many as possible)
++          1 or more of preceding regular expression (as many as possible)
+?          0 or 1 occurence of preceding regular expression
+*?, +?, ?? Same as *, + and ? but matches as few characters as possible
+{m,n}      matches from m to n repetitions of preceding RE
+{m,n}?     idem, attempting to match as few repetitions as possible
+[ ]        defines character set: e.g. '[a-zA-Z]' to match all letters(see also
+           \w \S)
+[^ ]       defines complemented character set: matches if char is NOT in set
+           escapes special chars '*?+&$|()' and introduces special sequences
+\          (see below). Due to Python string rules, write as '\\' orr'\' in the
+           pattern string.
+\\         matches a litteral '\'; due to Python string rules, write as '\\\\
+           'in pattern string, or better using raw string: r'\\'.
+|          specifies alternative: 'foo|bar' matches 'foo' or 'bar'
+(...)      matches any RE inside (), and delimits a group.
+(?:...)    idem but doesn't delimit a group.
+           matches if ... matches next, but doesn't consume any of the string
+(?=...)    e.g. 'Isaac (?=Asimov)' matches 'Isaac' only if followed by
+           'Asimov'.
+(?!...)    matches if ... doesn't match next. Negative of (?=...)
+(?P<name   matches any RE inside (), and delimits a named group. (e.g. r'(?P
+>...)      <id>[a-zA-Z_]\w*)' defines a group named id)
+(?P=name)  matches whatever text was matched by the earlier group named name.
+(?#...)    A comment; ignored.
+(?letter)  letter is one of 'i','L', 'm', 's', 'x'. Set the corresponding flags
+           (re.I, re.L, re.M, re.S, re.X) for the entire RE.
 
-       All collections general methods, plus:
-       s[i:j]	        __getslice__(s,i,j), all s[k] s.t. i <= k < j
-       min(s)		smallest item of s
-       max(s)		largest item of s
-       v [not] in s	1 if v [not] equal to an item in s, else 0
-       s + seq		concatenation of s and seq
-       s * num		num copies of s concatenated, also, `num * s'
+                               Special sequences
+Sequence                              Description
+number   matches content of the group of the same number; groups are numbered
+         starting from 1
+\A       matches only at the start of the string
+\b       empty str at beg or end of word: '\bis\b' matches 'is', but not 'his'
+\B       empty str NOT at beginning or end of word
+\d       any decimal digit (<=> [0-9])
+\D       any non-decimal digit char (<=> [^O-9])
+\s       any whitespace char (<=> [ \t\n\r\f\v])
+\S       any non-whitespace char (<=> [^ \t\n\r\f\v])
+\w       any alphaNumeric char (depends on LOCALE flag)
+\W       any non-alphaNumeric char (depends on LOCALE flag)
+\Z       matches only at the end of the string
 
-      Immutable sequence ops vs methods     (s: self, i,j: indices, v: val)
+                         Variables
+Variable                       Meaning
+error    Exception when pattern string isn't a valid regexp.
 
-       All collections and sequences general methods, plus:
-       s[i:j]	        __getslice__(s,i,j), all s[k] s.t. i <= k < j
-     ( For s[i:j], len(self) is intrinsically added to i, j < 0)
-     ( Complex elems of immutable seqs may be mutable, see dictionaries, below)
+                                   Functions
+   Function                                 Result
+               Compile a RE pattern string into a regular expression object.
+               Flags (combinable by |):
 
-      Mutable sequence ops vs methods	      (s: self, i,j: indices, v: val)
+               I or IGNORECASE or (?i)
+                   case insensitive matching
+compile(       L or LOCALE or (?L)
+pattern[,          make \w, \W, \b, \B dependent on thecurrent locale
+flags=0])      M or MULTILINE or (?m)
+                   matches every new line and not onlystart/end of the whole
+                   string
+               S or DOTALL or (?s)
+                   '.' matches ALL chars, including newline
+               X or VERBOSE or (?x)
+                   Ignores whitespace outside character sets
+escape(string) return (a copy of) string with all non-alphanumerics
+               backslashed.
+match(pattern, if 0 or more chars at beginning of <string> match the RE pattern
+string[, flags string,return a corresponding MatchObject instance, or None if
+])             no match.
+search(pattern scan thru <string> for a location matching <pattern>, return
+, string[,     acorresponding MatchObject instance, or None if no match.
+flags])
+split(pattern, split <string> by occurrences of <pattern>. If capturing () are
+string[,       used inpattern, then occurrences of patterns or subpatterns are
+maxsplit=0])   also returned.
+findall(       return a list of non-overlapping matches in <pattern>, either a
+pattern,       list ofgroups or a list of tuples if the pattern has more than 1
+string)        group.
+               return string obtained by replacing the (<count> first) lefmost
+sub(pattern,   non-overlapping occurrences of <pattern> (a string or a RE
+repl, string[, object) in <string>by <repl>; <repl> can be a string or a fct
+count=0])      called with a single MatchObj arg, which must return the
+               replacement string.
+subn(pattern,
+repl, string[, same as sub(), but returns a tuple (newString, numberOfSubsMade)
+count=0])
 
-       All sequences' general methods, plus:
-     ( for non-slice refs, i < 0 intrinsically has len(s) added)
-     ( For slice refs, len(s) *is not* intrinsically added to i, j < 0)
-     ( for assignment/deletion, index refs must point to existing items
-       s[i]=v		= __setitem__(s,i,v)
-       del s[i]		= __delitem__(s,i)
-       s[i:j]		= __getslice__(s,i,j)
-       s[i:j]=seq	= __setslice__(s,i,j,seq)
-       del s[i:j]	= __delslice__(s,i,j)	== s[i:j] = []
-       s.append(seq)	== `s[len(seq):len(seq)] = seq'	(but faster)
-       s.count(v)	number of i's for which `s[i] == v'
-       s.index(v)	first i such that `s[i] == v', or IndexError if none
-       s.insert(i, v)	== `s[i:i] = [v]'
-       s.remove(v)	== `del s[s.index(v)]', or IndexError if v not in s
-       s.reverse()	reverse the items of s in place
-       s.sort()		permute s items so s[i] <= s[j], for i < j
+Regular Expression Objects
 
-     Mappings
 
-    @ Dictionaries: {key1: val1, key2: val2, ...}
+(RE objects are returned by the compile fct)
 
-       built-in types as keys must be unalterable: obj & all contents immutable
-       User-defined classes as keys must have __hash__() and __cmp__() methods
-     ~ TypeError is raised if key not acceptable
-     ~ KeyError is raised if reference made using non-existent key
-       key types may vary (contrary to ref man)
+                          re object attributes
+Attribute                            Descrition
+flags      flags arg used when RE obj was compiled, or 0 if none provided
+groupindex dictionary of {group name: group number} in pattern
+pattern    pattern string from which RE obj was compiled
 
-      Dictionaries ops vs methods		(s: self, k: key, v: val)
+                               re object methods
+  Method                                  Result
+            If zero or more characters at the beginning of string match this
+            regular expression, return a corresponding MatchObject instance.
+            Return None if the string does not match the pattern; note that
+            this is different from a zero-length match.
+            The optional second parameter pos gives an index in the string
+match(      where the search is to start; it defaults to 0. This is not
+string[,    completely equivalent to slicing the string; the '' pattern
+pos][,      character matches at the real beginning of the string and at
+endpos])    positions just after a newline, but not necessarily at the index
+            where the search is to start.
+            The optional parameter endpos limits how far the string will be
+            searched; it will be as if the string is endpos characters long, so
+            only the characters from pos to endpos will be searched for a
+            match.
+            Scan through string looking for a location where this regular
+search(     expression produces a match, and return a corresponding MatchObject
+string[,    instance. Return None if no position in the string matches the
+pos][,      pattern; note that this is different from finding a zero-length
+endpos])    match at some point in the string.
+            The optional pos and endpos parameters have the same meaning as for
+            the match() method.
+split(
+string[,    Identical to the split() function, using the compiled pattern.
+maxsplit=
+0])
+findall(    Identical to the findall() function, using the compiled pattern.
+string)
+sub(repl,
+string[,    Identical to the sub() function, using the compiled pattern.
+count=0])
+subn(repl,
+string[,    Identical to the subn() function, using the compiled pattern.
+count=0])
 
-       all collections general ops, plus:
-       hash(s)		= __hash__(s) - hash value for dictionary references
-       s[k]=v		= __setitem__(s,k,v)
-       del s[k]		= __delitem__(s,k)
-       s.items()	= a list copy of s's (key, item) pairs
-       s.keys()		= a list copy of s's keys
-       s.values()	= a list copy of s's values
-       s.has_keys(k)	= 1 if s has key k, else 0
-     ( s.items, .keys, and .values yield random but mutually consistent order)
+Match Objects
 
-    			      **** Callables ****
 
-   @ User defined functions: 'def name (param-list): suite'
+(Match objects are returned by the match & search functions)
 
-      suite is not evaluated at statement execution, but at function invocation
-      function parameters, comma separated on param-list:
-      func_code: special attr, code object representing compiled function body
-      func_globals: special attr, ref to global dict of funcs definition module
-      func(arg-list)	invocation
+                            Match object attributes
+Attribute                              Description
+pos       value of pos passed to search or match functions; index intostring at
+          which RE engine started search.
+endpos    value of endpos passed to search or match functions; index intostring
+          beyond which RE engine won't go.
+re        RE object whose match or search fct produced this MatchObj instance
+string    string passed to match() or search()
 
-   @ User defined methods: like functions, with extra implicit arg
+                            Match object functions
+Function                                 Result
+          returns one or more groups of the match. If one arg, result is a
+group([g1 string;if multiple args, result is a tuple with one item per arg. If
+, g2,     gi is 0,return value is entire matching string; if 1 <= gi <= 99,
+...])     returnstring matching group #gi (or None if no such group); gi may
+          also bea group name.
+          returns a tuple of all groups of the match; groups not
+groups()  participatingto the match have a value of None. Returns a string
+          instead of tupleif len(tuple)=1
+start(
+group),   returns indices of start & end of substring matched by group (or
+end(group Noneif group exists but doesn't contribute to the match)
+)
+span(     returns the 2-tuple (start(group), end(group)); can be (None, None)if
+group)    group didn't contibute to the match.
 
-      Same as functions, but passed class instance as additional first argument
-      im_self: special attr, method's class instance object
-      im_func: special attr, function object
-      mthd(args)	invocation, same as mthd.im_func(mthd.im_self, args)
 
-   @ Classes: 'class name[ (inheritance)]: suite'
 
-      inheritance list is evaluated, if any, to identify base classes for name
-      suite is executed in new local name space, which goes to the class object
-      class name is bound in encompassing local name space
-      container for dictionary containing class's ns dictionary
-      __dict__: ro attr, class ns as dictionary object
-      __bases__: ro attr, class' base classes in tuple
-      __init__(self, args..): implements object instantiation
-      __del__(self): implements impending object deletion
+                                     math
 
-   @ Class instances
+Variables:
+pi
+e
+Functions (see ordinary C man pages for info):
+acos(x)
+asin(x)
+atan(x)
+atan2(x, y)
+ceil(x)
+cos(x)
+cosh(x)
+exp(x)
+fabs(x)
+floor(x)
+fmod(x, y)
+frexp(x)        -- Unlike C: (float, int) = frexp(float)
+ldexp(x, y)
+log(x)
+log10(x)
+modf(x)         -- Unlike C: (float, float) = modf(float)
+pow(x, y)
+sin(x)
+sinh(x)
+sqrt(x)
+tan(x)
+tanh(x)
 
-      __dict__: ro attr, class' attribute dictionary
-      __class__: ro attr, instance's class object
+                                    getopt
 
-     Callables special method vs ops		(f: function)
+Functions:
+getopt(list, optstr)    -- Similar to C. <optstr> is option
+                           letters to look for. Put ':' after letter
+                           if option takes arg. E.g.
+    # invocation was "python test.py -c hi -a arg1 arg2"
+       opts, args =  getopt.getopt(sys.argv[1:], 'ab:c:')
+    # opts would be
+       [('-c', 'hi'), ('-a', '')]
+    # args would be
+       ['arg1', 'arg2']
 
-      apply(f, args-tuple)	call f with args-tuple as arg list
-      compile(str, flnm, kind)	compile string into exectuable code object
-      eval(str, glbls=, lcls=)	evaluate string as expression (cond_list)
-      filter(f, seq)		=> seq of seq elems for which f is true
-      map(f, lst, [lst2, ...])	=> list of f applied to succesive lsts elems
-      reduce(f, lst, initlzr)	=> value of f applied to elems and cume result
 
-  @ 			 **** Null object: `None' ****
+List of modules and packages in base distribution
 
-  @		**** Type objects, print as: <type 'int'> ****
-   ( '<...>' form is only for printing - cannot be entered that way,
+(built-ins and content of python Lib directory)
+(Python NT distribution, may be slightly different in other distributions)
 
-     accessed via built-in func 'type()'
-   ( equal only when identical (same id()),
-     so can't just use the string name, must use object with the same str val)
+                           Standard library modules
+   Operation                                 Result
+aifc             Stuff to parse AIFF-C and AIFF files.
+anydbm           Generic interface to all dbm clones. (dbhash, gdbm,
+                 dbm,dumbdbm)
+asynchat         Support for 'chat' style protocols
+asyncore         Asynchronous File I/O (in select style)
+atexit           Register functions to be called at exit of Python interpreter.
+audiodev         Audio support for a few platforms.
+base64           Conversions to/from base64 RFC-MIME transport encoding .
+BaseHTTPServer   Base class forhttp services.
+Bastion          "Bastionification" utility (control access to instance vars)
+bdb              A generic Python debugger base class.
+binhex           Macintosh binhex compression/decompression.
+bisect           List bisection algorithms.
+calendar         Calendar printing functions.
+cgi              Wraps the WWW Forms Common Gateway Interface (CGI).
+CGIHTTPServer    CGI http services.
+cmd              A generic class to build line-oriented command interpreters.
+[DEL:cmp:DEL]    [DEL:Efficiently compare files, boolean outcome only.:DEL]
+[DEL:cmpcache:   [DEL:Same, but caches 'stat' results for speed.:DEL]
+DEL]
+code             Utilities needed to emulate Python's interactive interpreter
+codecs           Lookup existing Unicode encodings and register new ones.
+colorsys         Conversion functions between RGB and other color systems.
+commands         Tools for executing UNIX commands .
+compileall       Force "compilation" of all .py files in a directory.
+ConfigParser     Configuration file parser (much like windows .ini files)
+copy             Generic shallow and deep copying operations.
+copy_reg         Helper to provide extensibility for pickle/cPickle.
+dbhash           (g)dbm-compatible interface to bsdhash.hashopen.
+dircache         Sorted list of files in a dir, using a cache.
+[DEL:dircmp:DEL] [DEL:Defines a class to build directory diff tools on.:DEL]
+dis              Bytecode disassembler.
+distutils        Package installation system.
+dospath          Common operations on DOS pathnames.
+dumbdbm          A dumb and slow but simple dbm clone.
+[DEL:dump:DEL]   [DEL:Print python code that reconstructs a variable.:DEL]
+exceptions       Class based built-in exception hierarchy.
+filecmp          File comparison.
+fileinput        Helper class to quickly write a loop over all standard input
+                 files.
+[DEL:find:DEL]   [DEL:Find files directory hierarchy matching a pattern.:DEL]
+fnmatch          Filename matching with shell patterns.
+formatter        A test formatter.
+fpformat         General floating point formatting functions.
+ftplib           An FTP client class. Based on RFC 959.
+gc               Perform garbacge collection, obtain GC debug stats, and tune
+                 GC parameters.
+getopt           Standard command line processing. See also ftp://
+                 www.pauahtun.org/pub/getargspy.zip
+getpass          Utilities to get a password and/or the current user name.
+glob             filename globbing.
+gopherlib        Gopher protocol client interface.
+[DEL:grep:DEL]   [DEL:'grep' utilities.:DEL]
+gzip             Read & write gzipped files.
+htmlentitydefs   Proposed entity definitions for HTML.
+htmllib          HTML parsing utilities.
+httplib          HTTP client class.
+ihooks           Hooks into the "import" mechanism.
+imaplib          IMAP4 client.Based on RFC 2060.
+imghdr           Recognizing image files based on their first few bytes.
+imputil          Privides a way of writing customised import hooks.
+keyword          List of Python keywords.
+knee             A Python re-implementation of hierarchical module import.
+linecache        Cache lines from files.
+linuxaudiodev    Lunix /dev/audio support.
+locale           Support for number formatting using the current locale
+                 settings.
+macpath          Pathname (or related) operations for the Macintosh.
+macurl2path      Mac specific module for conversion between pathnames and URLs.
+mailbox          A class to handle a unix-style or mmdf-style mailbox.
+mailcap          Mailcap file handling (RFC 1524).
+mhlib            MH (mailbox) interface.
+mimetools        Various tools used by MIME-reading or MIME-writing programs.
+mimetypes        Guess the MIME type of a file.
+MimeWriter       Generic MIME writer.
+mimify           Mimification and unmimification of mail messages.
+mmap             Interface to memory-mapped files - they behave like mutable
+                 strings./font>
+multifile        Class to make multi-file messages easier to handle.
+mutex            Mutual exclusion -- for use with module sched.
+netrc
+nntplib          An NNTP client class. Based on RFC 977.
+ntpath           Common operations on DOS pathnames.
+nturl2path       Mac specific module for conversion between pathnames and URLs.
+os               Either mac, dos or posix depending system.
+[DEL:packmail:   [DEL:Create a self-unpacking shell archive.:DEL]
+DEL]
+pdb              A Python debugger.
+pickle           Pickling (save and restore) of Python objects (a faster
+                 Cimplementation exists in built-in module: cPickle).
+pipes            Conversion pipeline templates.
+[DEL:poly:DEL]   [DEL:Polynomials.:DEL]
+popen2           variations on pipe open.
+poplib           A POP3 client class. Based on the J. Myers POP3 draft.
+posixfile        Extended (posix) file operations.
+posixpath        Common operations on POSIX pathnames.
+pprint           Support to pretty-print lists, tuples, & dictionaries
+                 recursively.
+profile          Class for profiling python code.
+pstats           Class for printing reports on profiled python code.
+pty              Pseudo terminal utilities.
+pyexpat          Interface to the Expay XML parser.
+py_compile       Routine to "compile" a .py file to a .pyc file.
+pyclbr           Parse a Python file and retrieve classes and methods.
+Queue            A multi-producer, multi-consumer queue.
+quopri           Conversions to/from quoted-printable transport encoding.
+rand             Don't use unless you want compatibility with C's rand().
+random           Random variable generators (obsolete, use whrandom)
+re               Regular Expressions.
+reconvert        Convert old ("regex") regular expressions to new syntax
+                 ("re").
+regex_syntax     Flags for regex.set_syntax().
+regexp           Backward compatibility for module "regexp" using "regex".
+regsub           Regular expression subroutines.
+repr             Redo repr() but with limits on most sizes.
+rexec            Restricted execution facilities ("safe" exec, eval, etc).
+rfc822           RFC-822 message manipulation class.
+rlcompleter      Word completion for GNU readline 2.0.
+robotparser      Parse robot.txt files, useful for web spiders.
+sched            A generally useful event scheduler class.
+sgmllib          A parser for SGML.
+shelve           Manage shelves of pickled objects.
+shlex            Lexical analyzer class for simple shell-like syntaxes.
+shutil           Utility functions usable in a shell-like program.
+SimpleHTTPServer Simple extension to base http class
+site             Append module search paths for third-party packages to
+                 sys.path.
+smtplib          SMTP Client class (RFC 821)
+sndhdr           Several routines that help recognizing sound.
+SocketServer     Generic socket server classes.
+stat             Constants and functions for interpreting stat/lstat struct.
+statcache        Maintain a cache of file stats.
+statvfs          Constants for interpreting statvfs struct as returned by
+                 os.statvfs()and os.fstatvfs() (if they exist).
+string           A collection of string operations.
+StringIO         File-like objects that read/write a string buffer (a fasterC
+                 implementation exists in built-in module: cStringIO).
+sunau            Stuff to parse Sun and NeXT audio files.
+sunaudio         Interpret sun audio headers.
+symbol           Non-terminal symbols of Python grammar (from "graminit.h").
+tabnanny,/font>  Check Python source for ambiguous indentation.
+telnetlib        TELNET client class. Based on RFC 854.
+tempfile         Temporary file name allocation.
+threading        Proposed new higher-level threading interfaces
+threading_api    (doc of the threading module)
+toaiff           Convert "arbitrary" sound files to AIFF files .
+token            Tokens (from "token.h").
+tokenize         Compiles a regular expression that recognizes Python tokens.
+traceback        Format and print Python stack traces.
+tty              Terminal utilities.
+turtle           LogoMation-like turtle graphics
+types            Define names for all type symbols in the std interpreter.
+tzparse          Parse a timezone specification.
+unicodedata      Interface to unicode properties.
+urllib           Open an arbitrary URL.
+urlparse         Parse URLs according to latest draft of standard.
+user             Hook to allow user-specified customization code to run.
+UserDict         A wrapper to allow subclassing of built-in dict class.
+UserList         A wrapper to allow subclassing of built-in list class.
+UserString       A wrapper to allow subclassing of built-in string class.
+[DEL:util:DEL]   [DEL:some useful functions that don't fit elsewhere !!:DEL]
+uu               UUencode/UUdecode.
+wave             Stuff to parse WAVE files.
+webbrowser       Platform independent URL launcher.
+[DEL:whatsound:  [DEL:Several routines that help recognizing sound files.:DEL]
+DEL]
+whichdb          Guess which db package to use to open a db file.
+whrandom         Wichmann-Hill random number generator.
+xdrlib           Implements (a subset of) Sun XDR (eXternal Data
+                 Representation)
+xmllib           A parser for XML, using the derived class as static DTD.
+xml.dom          Classes for processing XML using the Document Object Model.
+xml.sax          Classes for processing XML using the SAX API.
+zipfile          Read & write PK zipped files.
+[DEL:zmod:DEL]   [DEL:Demonstration of abstruse mathematical concepts.:DEL]
 
-  @ 			       **** Modules ****
 
-     functions and methods in a module share module's ("global") namespace
-     function uses "global" statement to instantiate var in global context
-     Modules use "import" to incorp other module's names - see Name Spaces
 
-     Special attrs, methods, and operations
+(following list not revised)
 
-      __dict__: attr, module's ns as dictionary; can modify vals but not sruct
-      __name__: ro attr, module's name as string
-      import		Instantiate module or module components within another
-      reload(amod)	Reread an imported module
+* Built-ins *
 
-  @ 				**** Files ****
+            sys                 Interpreter state vars and functions
+            __built-in__        Access to all built-in python identifiers
+            __main__            Scope of the interpreters main program, script or stdin
+            array               Obj efficiently representing arrays of basic values
+            math                Math functions of C standard
+            time                Time-related functions
+            regex               Regular expression matching operations
+            marshal             Read and write some python values in binary format
+            struct              Convert between python values and C structs
 
-     wrapper around a C stdio file pointer
-     sys.stdin, sys.stdout, sys.stderr are standard io-stream file objects
+* Standard *
 
-     File operations:
+            getopt              Parse cmd line args in sys.argv.  A la UNIX 'getopt'.
+            os                  A more portable interface to OS dependent functionality
+            re                  Functions useful for working with regular expressions
+            string              Useful string and characters functions and exceptions
+            whrandom            Wichmann-Hill pseudo-random number generator
+            thread              Low-level primitives for working with process threads
+            threading           idem, new recommanded interface.
 
-       open(nm, mode='r', bufsize=sysdef)    return new file object
-       close()		A closed file cannot be read or written anymore.
-       flush()		Flush the internal buffer, like stdio's `fflush()'.
-       isatty()		1 if file connected to a tty(-like) device, else 0.
-       read(SIZE) 	Read up to SIZE bytes frm file, less on EOF or no data
-       readline()	Read one entire line from the file.
-       readlines() 	`readline()' til EOF and return list  of lines read.
-       seek(OFFSET,WHENCE) Set file's current position, like stdio's `fseek()'
-       tell()		Return file's current position, like stdio's `ftell()'.
-       write(STR)	Write a string to the file.  There is no return value.
+* Unix/Posix *
 
-     File functions:
+            dbm                 Interface to Unix ndbm database library
+            grp                 Interface to Unix group database
+            posix               OS functionality standardized by C and POSIX standards
+            posixpath           POSIX pathname functions
+            pwd                 Access to the Unix password database
+            select              Access to Unix select multiplex file synchronization
+            socket              Access to BSD socket interface
 
-      input(prompt='')	     like raw input but accept '\' line continuations
-      print exp, exp2, ...  Write values to stdout
-      raw_input(prompt='')   prompt then read single line of input
+* Tk User-interface Toolkit *
 
-    			    **** Internal types ****
+            tkinter             Main interface to Tk
 
-   @ Code objects - represent exectuable code - function obj sans context
-   @ Frame objects - represent executable frames - may occur in traceback objs
-   @ Traceback objects - stack trace of an exception
+* Multimedia *
 
-   			      Control statements
-			      ==================
+            audioop             Useful operations on sound fragments
+            imageop             Useful operations on images
+            jpeg                Access to jpeg image compressor and decompressor
+            rgbimg              Access SGI imglib image files
 
-    		           * Calls and Evaluation *
+* Cryptographic Extensions *
 
-   ( See also Callables, in Objects section above, for ops and methods.)
+            md5         Interface to RSA's MD5 message digest algorithm
+            mpz         Interface to int part of GNU multiple precision library
+            rotor               Implementation of a rotor-based encryption algorithm
 
-     exec: exec expr [ in expr2 [, expr3]]  # Dynamic execution of python code
-     return: return [expr]	# Leave current func call with expr value
+* Stdwin * Standard Window System
 
-    			  * Conditionals and Loops *
-   (			See also Boolean values, above)
+            stdwin              Standard Window System interface
+            stdwinevents        Stdwin event, command, and selection constants
+            rect                Rectangle manipulation operations
 
-     break: break		# Terminate nearest enclosing loop
-     continue: continue		# Continue next cycle of enclosing loop
-     if:	if cond: suite [\n elif cond: suite \n ...] [\n else: suite]
-     for:	for targs in conds: suite [ \n else: suite ]
-     while:	while cond: suite [ \n else : suite ]
+* SGI IRIX * (4 & 5)
 
-    				 * Exceptions *
+            al          SGI audio facilities
+            AL          al constants
+            fl          Interface to FORMS library
+            FL          fl constants
+            flp Functions for form designer
+            fm          Access to font manager library
+            gl          Access to graphics library
+            GL          Constants for gl
+            DEVICE      More constants for gl
+            imgfile     Imglib image file interface
 
-     raise: raise expr [, expr2]   # Raise exception expr, passing expr2 if any
-     try...			# Handle exceptions:
-     try: suite [\n except [cond [, targ]]: suite \n ... \n] [else: suite]
-     try: suite \n finally: suite	# Specify a 'cleanup' handler
-   ( two 'try' forms cannot be mixed together)
+* Suns *
 
-   				System modules
-				==============
-  @			 	 * Built-ins *
+            sunaudiodev Access to sun audio interface
 
-     sys		Interpreter state (see Operating Environment, above)
-     __builtin__	Access to all built-in python identifiers
-     __main__		Scope of the interpreters main program, script or stdin
-     array		Obj efficiently representing arrays of basic values
-     math		Math functions of C standard
-     time 		Time-related functions
-     regex		Regular expression matching operations
-     marshal		Read and write some python values in binary format
-     strop		Miscellaneous string operations
-     struct		Convert between python values and C structs
 
-  @ 				 * Standard *
+Workspace exploration and idiom hints
 
-     getopt		Parse cmd line args in sys.argv.  A la UNIX 'getopt'.
-     os			Portable interface to OS dependent functionality
-     pdb		text-oriented debugger
-     rand		Pseudo-random generator, like C rand()
-     regsub		Functions useful for working with regular expressions
-     string		Useful string and characters functions and exceptions
-     wdb		window-oriented debugger
-     whrandom		Wichmann-Hill pseudo-random number generator
+        dir(<module>)   list functions, variables in <module>
+        dir()           get object keys, defaults to local name space
+        X.__methods__   list of methods supported by X (if any)
+        X.__members__   List of X's data attributes
+        if __name__ == '__main__': main()            invoke main if running as script
+        map(None, lst1, lst2, ...)                   merge lists
+        b = a[:]                                     create copy of seq structure
+        _                       in interactive mode, is last value printed
 
-  @			       * Miscellaneous *
 
-     dis		Python disassembler
-     glob		Filename globbing (a la unix shell)
-     grep		File string search
-     posixpath		Common operations on POSIX pathnames
-     profile		Python code profiler
-     repr		`...` repr operator with presentation constraints
-     string		All of builtin 'strop', plus
-     tb			Traceback browser and printer
-     tempfile		Produce a temporary-file name
-     util		Miscellaneous functions that don't belong elsewhere
 
-  @ 				   * Unix *
 
-     dbm		Dict/file-like interface to Unix ndbm database library
-     grp		Interface to Unix group database
-     posix		Standardized UNIX OS functionality - see 'os', above
-     posixpath		POSIX pathname functions - see 'os', above
-     pwd		Access to the Unix password database
-     select		Access to Unix select multiplex file synchronization
-     socket		Access to BSD socket interface
-     thread		Low-level primitives for working with process threads
 
-  @ 				* Multimedia *
 
-     audioop		Useful operations on sound fragments
-     imageop		Useful operations on images
-     jpeg		Access to jpeg image compressor and decompressor
-     rgbimg		Access SGI imglib image files
 
-  @ 			 * Cryptographic Extensions *
+Python Mode for Emacs
 
-     md5		Interface to RSA's MD5 message digest algorithm
-     mpz		Interface to int part of GNU multiple precision library
-     rotor		Implementation of a rotor-based encryption algorithm
+(Not revised, possibly not up to date)
+Type C-c ? when in python-mode for extensive help.
+INDENTATION
+Primarily for entering new code:
+        TAB      indent line appropriately
+        LFD      insert newline, then indent
+        DEL      reduce indentation, or delete single character
+Primarily for reindenting existing code:
+        C-c :    guess py-indent-offset from file content; change locally
+        C-u C-c :        ditto, but change globally
+        C-c TAB  reindent region to match its context
+        C-c <    shift region left by py-indent-offset
+        C-c >    shift region right by py-indent-offset
+MARKING & MANIPULATING REGIONS OF CODE
+C-c C-b         mark block of lines
+M-C-h           mark smallest enclosing def
+C-u M-C-h       mark smallest enclosing class
+C-c #           comment out region of code
+C-u C-c #       uncomment region of code
+MOVING POINT
+C-c C-p         move to statement preceding point
+C-c C-n         move to statement following point
+C-c C-u         move up to start of current block
+M-C-a           move to start of def
+C-u M-C-a       move to start of class
+M-C-e           move to end of def
+C-u M-C-e       move to end of class
+EXECUTING PYTHON CODE
+C-c C-c sends the entire buffer to the Python interpreter
+C-c |   sends the current region
+C-c !   starts a Python interpreter window; this will be used by
+        subsequent C-c C-c or C-c | commands
+VARIABLES
+py-indent-offset        indentation increment
+py-block-comment-prefix comment string used by py-comment-region
+py-python-command       shell command to invoke Python interpreter
+py-scroll-process-buffer        t means always scroll Python process buffer
+py-temp-directory       directory used for temp files (if needed)
+py-beep-if-tab-change   ring the bell if tab-width is changed
 
-  @ 				  * Stdwin *	Standard Window System
 
-     stdwin		Standard Window System interface
-     stdwinevents	Stdwin event, command, and selection constants
-     rect		Rectangle manipulation operations
+The Python Debugger
 
-  @ 				 * SGI IRIX * (4 & 5)
+(Not revised, possibly not up to date, see 1.5.2 Library Ref section 9.1; in 1.5.2, you may also use debugger integrated in IDLE)
 
-     al		SGI audio facilities
-     AL		al constants
-     fl		Interface to FORMS library
-     FL		fl constants
-     flp	Functions for form designer
-     fm		Access to font manager library
-     gl		Access to graphics library
-     GL		Constants for gl
-     DEVICE	More constants for gl
-     imgfile	Imglib image file interface
+Accessing
 
-  @ 				   * Suns *
+import pdb      (it's a module written in Python)
+        -- defines functions :
+           run(statement[,globals[, locals]])
+                        -- execute statement string under debugger control, with optional
+                           global & local environment.
+           runeval(expression[,globals[, locals]])
+                        -- same as run, but evaluate expression and return value.
+           runcall(function[, argument, ...])
+                        -- run function object with given arg(s)
+           pm()         -- run postmortem on last exception (like debugging a core file)
+           post_mortem(t)
+                        -- run postmortem on traceback object <t>
 
-     sunaudiodev	Access to sun audio interface
+        -- defines class Pdb :
+           use Pdb to create reusable debugger objects. Object
+           preserves state (i.e. break points) between calls.
 
-  @ 				  * Contrib *
+        runs until a breakpoint hit, exception, or end of program
+        If exception, variable '__exception__' holds (exception,value).
 
-     syslog
+Commands
 
-     metalbase
+h, help
+        brief reminder of commands
+b, break [<arg>]
+        if <arg> numeric, break at line <arg> in current file
+        if <arg> is function object, break on entry to fcn <arg>
+        if no arg, list breakpoints
+cl, clear [<arg>]
+        if <arg> numeric, clear breakpoint at <arg> in current file
+        if no arg, clear all breakpoints after confirmation
+w, where
+        print current call stack
+u, up
+        move up one stack frame (to top-level caller)
+d, down
+        move down one stack frame
+s, step
+        advance one line in the program, stepping into calls
+n, next
+        advance one line, stepping over calls
+r, return
+        continue execution until current function returns
+        (return value is saved in variable "__return__", which
+        can be printed or manipulated from debugger)
+c, continue
+        continue until next breakpoint
+a, args
+        print args to current function
+rv, retval
+        prints return value from last function that returned
+p, print <arg>
+        prints value of <arg> in current stack frame
+l, list [<first> [, <last>]]
+               List source code for the current file.
+               Without arguments, list 11 lines around the current line
+               or continue the previous listing.
+               With one argument, list 11 lines starting at that line.
+               With two arguments, list the given range;
+               if the second argument is less than the first, it is a count.
+whatis <arg>
+        prints type of <arg>
+!
+        executes rest of line as a Python statement in the current stack frame
+q quit
+        immediately stop execution and leave debugger
+<return>
+        executes last command again
+Any input debugger doesn't recognize as a command is assumed to be a
+Python statement to execute in the current stack frame, the same way
+the exclamation mark ("!") command does.
 
-   			       Idioms and hints
-			       ================
+Example
 
-    Invoke main if running as script:	     if __name__ == '__main__': main()
+(1394) python
+Python 1.0.3 (Sep 26 1994)
+Copyright 1991-1994 Stichting Mathematisch Centrum, Amsterdam
+>>> import rm
+>>> rm.run()
+Traceback (innermost last):
+         File "<stdin>", line 1
+         File "./rm.py", line 7
+           x = div(3)
+         File "./rm.py", line 2
+           return a / r
+ZeroDivisionError: integer division or modulo
+>>> import pdb
+>>> pdb.pm()
+> ./rm.py(2)div: return a / r
+(Pdb) list
+         1     def div(a):
+         2  ->     return a / r
+         3
+         4     def run():
+         5         global r
+         6         r = 0
+         7         x = div(3)
+         8         print x
+[EOF]
+(Pdb) print r
+0
+(Pdb) q
+>>> pdb.runcall(rm.run)
+etc.
 
-    General object-type miscellany
-     What type is someobj; eg, a list:	     if type(someobj) == type([]):
-     Convert number to hex or octal string:  hex(122)	  => '0x7a'
-     Convert string to number:		     eval('0x7a') => 122
+Quirks
 
-    Sequence Slice conceptualization:
-       +---+---+---+---+---+		     Indices point ~between~ chars:
-       | s | t | u | f | f |		      - first char's left edge = 0,
-       +---+---+---+---+---+		      - nth char's right edge = n.
-       0   1   2   3   4   5		     (Note that -0 == 0, so it does
-      -5  -4  -3  -2  -1		      not count from right.)
+Breakpoints are stored as filename, line number tuples. If a module is reloaded
+after editing, any remembered breakpoints are likely to be wrong.
 
-    Sequences miscellany:
-     Create merge of lists:		     map(None, lst1, lst2, ...)
-     It's faster to list.append(elem) than to list[len(list):] = [elem]
-     Copy structure of seq a to b:	     b = a[:]
+Always single-steps through top-most stack frame. That is, "c" acts like "n".
 
-    Comma (tuple vs expression grouping) nuances:
-     to specify a tuple of one element:	     ('element',)
-     to specify a tuple containing 1 tuple: (('contained', 'tuple'),)
-     "TypeError: call of non-function" often means a list missing a comma
 
-    Namespace and object surveillance:
-     get dictful object keys/key-vals:	     dir(), vars()
-     Current context globals:		     eval(__name__ + '.__dict__')
-     Current context locals:		     vars()
-     Methods supported by X (some objs):     X.__methods__	
-     X's data attributes (some objs):	     X.__members__