FCL/sf/adapt/qemu: comparison symbian-qemu-0.9.1-12/python-2.6.1/Misc/cheatsheet

equal deleted inserted replaced

-:ffa851df0825
+:2fb8b9db1c86
+Python 2.3 Quick Reference
+25 Jan 2003  upgraded by Raymond Hettinger for Python 2.3
+16 May 2001  upgraded by Richard Gruet and Simon Brunning for Python 2.0
+2000/07/18  upgraded by Richard Gruet, rgruet@intraware.com for Python 1.5.2
+from V1.3 ref
+1995/10/30, by Chris Hoffmann, choffman@vicorp.com
+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/
+http://www.vex.net/parnassus/
+http://aspn.activestate.com/ASPN/Cookbook/Python
+FAQ:       http://www.python.org/cgi-bin/faqw.py
+Full documentation: http://www.python.org/doc/
+Excellent reference books:
+Python Essential Reference by David Beazley (New Riders)
+Python Pocket Reference by Mark Lutz (O'Reilly)
+Invocation Options
+python [-diOStuUvxX?] [-c command | script | - ] [args]
+Invocation Options
+Option                                  Effect
+-c cmd  program passed in as string (terminates option list)
+-d      Outputs parser debugging information (also PYTHONDEBUG=x)
+-E      ignore environment variables (such as PYTHONPATH)
+-h      print this help message and exit
+-i      Inspect interactively after running script (also PYTHONINSPECT=x) and
+force prompts, even if stdin appears not to be a terminal
+-m mod  run library module as a script (terminates option list
+-O      optimize generated bytecode (a tad; also PYTHONOPTIMIZE=x)
+-OO     remove doc-strings in addition to the -O optimizations
+-Q arg  division options: -Qold (default), -Qwarn, -Qwarnall, -Qnew
+-S      Don't perform 'import site' on initialization
+-t      Issue warnings about inconsistent tab usage (-tt: issue errors)
+-u      Unbuffered binary stdout and stderr (also PYTHONUNBUFFERED=x).
+-v      Verbose (trace import statements) (also PYTHONVERBOSE=x)
+-W arg : warning control (arg is action:message:category:module:lineno)
+-x      Skip first line of source, allowing use of non-unix Forms of #!cmd
+-?      Help!
+-3      warn about Python 3.x incompatibilities
+-c      Specify the command to execute (see next section). This terminates the
+command option list (following options are passed as arguments to the command).
+the name of a python file (.py) to execute read from stdin.
+script  Anything afterward is passed as options to python script or command,
+not interpreted as an option to interpreter itself.
+args    passed to script or command (in sys.argv[1:])
+If no script or command, Python enters interactive mode.
+* Available IDEs in std distrib: IDLE (tkinter based, portable), Pythonwin
+(Windows).
+Environment variables
+Environment variables
+Variable                                 Effect
+PYTHONHOME       Alternate prefix directory (or prefix;exec_prefix). The
+default module search path uses prefix/lib
+Augments the default search path for module files. The format
+is the same as the shell's $PATH: one or more directory
+pathnames separated by ':' or ';' without spaces around
+(semi-)colons!
+PYTHONPATH       On Windows first search for Registry key HKEY_LOCAL_MACHINE\
+Software\Python\PythonCore\x.y\PythonPath (default value). You
+may also define a key named after your application with a
+default string value giving the root directory path of your
+app.
+If this is the name of a readable file, the Python commands in
+PYTHONSTARTUP    that file are executed before the first prompt is displayed in
+interactive mode (no default).
+PYTHONDEBUG      If non-empty, same as -d option
+PYTHONINSPECT    If non-empty, same as -i option
+PYTHONSUPPRESS   If non-empty, same as -s option
+PYTHONUNBUFFERED If non-empty, same as -u option
+PYTHONVERBOSE    If non-empty, same as -v option
+PYTHONCASEOK     If non-empty, ignore case in file/module names (imports)
+Notable lexical entities
+Keywords
+and       del       for       is        raise
+assert    elif      from      lambda    return
+break     else      global    not       try
+class     except    if        or        while
+continue  exec      import    pass      yield
+def       finally   in        print
+* (list of keywords in std module: keyword)
+* Illegitimate Tokens (only valid in strings): @ $ ?
+* A statement must all be on a single line. To break a statement over
+multiple lines use "\", as with the C preprocessor.
+Exception: can always break when inside any (), [], or {} pair, or in
+triple-quoted strings.
+* More than one statement can appear on a line if they are separated with
+semicolons (";").
+* Comments start with "#" and continue to end of line.
+Identifiers
+(letter | "_")  (letter | digit | "_")*
+* Python identifiers keywords, attributes, etc. are case-sensitive.
+* Special forms: _ident (not imported by 'from module import *'); __ident__
+(system defined name);
+__ident (class-private name mangling)
+Strings
+"a string enclosed by double quotes"
+'another string delimited by single quotes and with a " inside'
+'''a string containing embedded newlines and quote (') marks, can be
+delimited with triple quotes.'''
+""" may also use 3- double quotes as delimiters """
+u'a unicode string'   U"Another unicode string"
+r'a raw string where \ are kept (literalized): handy for regular
+expressions and windows paths!'
+R"another raw string"    -- raw strings cannot end with a \
+ur'a unicode raw string'   UR"another raw unicode"
+Use \ at end of line to continue a string on next line.
+adjacent strings are concatened, e.g. 'Monty' ' Python' is the same as
+'Monty Python'.
+u'hello' + ' world'  --> u'hello world'   (coerced to unicode)
+String Literal Escapes
+\newline  Ignored (escape newline)
+\\ Backslash (\)        \e Escape (ESC)        \v Vertical Tab (VT)
+\' Single quote (')     \f Formfeed (FF)       \OOO char with octal value OOO
+\" Double quote (")     \n Linefeed (LF)
+\a Bell (BEL)           \r Carriage Return (CR) \xHH  char with hex value HH
+\b Backspace (BS)       \t Horizontal Tab (TAB)
+\uHHHH  unicode char with hex value HHHH, can only be used in unicode string
+\UHHHHHHHH  unicode char with hex value HHHHHHHH, can only be used in unicode string
+\AnyOtherChar is left as-is
+* NUL byte (\000) is NOT an end-of-string marker; NULs may be embedded in
+strings.
+* Strings (and tuples) are immutable: they cannot be modified.
+Numbers
+Decimal integer: 1234, 1234567890546378940L        (or l)
+Octal integer: 0177, 0177777777777777777 (begin with a 0)
+Hex integer: 0xFF, 0XFFFFffffFFFFFFFFFF (begin with 0x or 0X)
+Long integer (unlimited precision): 1234567890123456
+Float (double precision): 3.14e-10, .001, 10., 1E3
+Complex: 1J, 2+3J, 4+5j (ends with J or j, + separates (float) real and
+imaginary parts)
+Sequences
+* String of length 0, 1, 2 (see above)
+'', '1', "12", 'hello\n'
+* Tuple of length 0, 1, 2, etc:
+() (1,) (1,2)     # parentheses are optional if len > 0
+* List of length 0, 1, 2, etc:
+[] [1] [1,2]
+Indexing is 0-based. Negative indices (usually) mean count backwards from end
+of sequence.
+Sequence slicing [starting-at-index : but-less-than-index]. Start defaults to
+'0'; End defaults to 'sequence-length'.
+a = (0,1,2,3,4,5,6,7)
+a[3] ==> 3
+a[-1] ==> 7
+a[2:4] ==> (2, 3)
+a[1:] ==> (1, 2, 3, 4, 5, 6, 7)
+a[:3] ==> (0, 1, 2)
+a[:] ==> (0,1,2,3,4,5,6,7)  # makes a copy of the sequence.
+Dictionaries (Mappings)
+{}                              # Zero length empty dictionary
+{1 : 'first'}                   # Dictionary with one (key, value) pair
+{1 : 'first',  'next': 'second'}
+dict([('one',1),('two',2)])     # Construct a dict from an item list
+dict('one'=1, 'two'=2)          # Construct a dict using keyword args
+dict.fromkeys(['one', 'keys'])  # Construct a dict from a sequence
+Operators and their evaluation order
+Operators and their evaluation order
+Highest             Operator                             Comment
+(...) [...] {...} `...`           Tuple, list & dict. creation; string
+conv.
+s[i]  s[i:j]  s.attr f(...)       indexing & slicing; attributes, fct
+calls
++x, -x, ~x                        Unary operators
+x**y                              Power
+x*y  x/y  x%y x//y                mult, division, modulo, floor division
+x+y  x-y                          addition, subtraction
+x<<y   x>>y                       Bit shifting
+x&y                               Bitwise and
+x^y                               Bitwise exclusive or
+x|y                               Bitwise or
+x<y  x<=y  x>y  x>=y  x==y x!=y   Comparison,
+x<>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
+Alternate names are defined in module operator (e.g. __add__ and add for +)
+Most operators are overridable.
+Many binary operators also support augmented assignment:
+x += 1                            # Same as x = x + 1
+Basic Types and Their Operations
+Comparisons (defined between *any* types)
+Comparisons
+Comparison         Meaning          Notes
+<          strictly less than        (1)
+<=         less than or equal to
+>          strictly greater than
+>=         greater than or equal to
+==         equal to
+!= 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__.
+The above comparisons return True or False which are of type bool
+(a subclass of int) and behave exactly as 1 or 0 except for their type and
+that they print as True or False instead of 1 or 0.
+(1) X < Y < Z < W has expected meaning, unlike C
+(2) Compare object identities (i.e. id(object)), not object values.
+Boolean values and operators
+Boolean values and operators
+Value or Operator                         Returns           Notes
+None, numeric zeros, empty sequences and      False
+mappings
+all other values                              True
+not x                                         True if x is False, else
+True
+x or y                                        if x is False then y, else   (1)
+x
+x and y                                       if x is False then x, else   (1)
+y
+Notes :
+Truth testing behavior can be overridden for a given class by defining
+special method __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
+FloatingPointError
+raised when a floating point operation fails
+Operations on all sequence types (lists, tuples, strings)
+Operations on all sequence types
+Operation                     Result                     Notes
+x in s     True if an item of s is equal to x, else False
+x not in s False if an item of s is equal to x, else True
+for x in s: loops over the sequence
+s + t      the concatenation of s and t
+s * n, n*s n copies of s concatenated
+s[i]       i'th item of s, origin 0                       (1)
+s[i:j]     slice of s from i (included) to j (excluded) (1), (2)
+len(s)     length of s
+min(s)     smallest item of s
+max(s)     largest item of (s)
+iter(s)    returns an iterator over s.  iterators define __iter__ and next()
+Notes :
+(1) if i or j is negative, the index is relative to the end of the string,
+ie len(s)+ i or len(s)+j is
+substituted. But note that -0 is still 0.
+(2) The slice of s from i to j is defined as the sequence of items with
+index k such that i <= k < j.
+If i or j is greater than len(s), use len(s). If i is omitted, use
+len(s). If i is greater than or
+equal to j, the slice is empty.
+Operations on mutable (=modifiable) sequences (lists)
+Operations on mutable sequences
+Operation                      Result                   Notes
+s[i] =x          item i of s is replaced by x
+s[i:j] = t       slice of s from i to j is replaced by t
+del s[i:j]       same as s[i:j] = []
+s.append(x)      same as s[len(s) : len(s)] = [x]
+s.count(x)       return number of i's for which s[i] == x
+s.extend(x)      same as s[len(s):len(s)]= x
+s.index(x)       return smallest i such that s[i] == x      (1)
+s.insert(i, x)   same as s[i:i] = [x] if i >= 0
+s.pop([i])       same as x = s[i]; del s[i]; return x       (4)
+s.remove(x)      same as del s[s.index(x)]                  (1)
+s.reverse()      reverse the items of s in place            (3)
+s.sort([cmpFct]) sort the items of s in place             (2), (3)
+Notes :
+(1) raise a ValueError exception when x is not found in s (i.e. out of
+range).
+(2) The sort() method takes an optional argument specifying a comparison
+fct of 2 arguments (list items) which should
+return -1, 0, or 1 depending on whether the 1st argument is
+considered smaller than, equal to, or larger than the 2nd
+argument. Note that this slows the sorting process down considerably.
+(3) The sort() and reverse() methods modify the list in place for economy
+of space when sorting or reversing a large list.
+They don't return the sorted or reversed list to remind you of this
+side effect.
+(4) [New 1.5.2] The optional  argument i defaults to -1, so that by default the last
+item is removed and returned.
+Operations on mappings (dictionaries)
+Operations on mappings
+Operation                          Result                  Notes
+len(d)                     the number of items in d
+d[k]                       the item of d with key k                 (1)
+d[k] = x                   set d[k] to x
+del d[k]                   remove d[k] from d                       (1)
+d.clear()                  remove all items from d
+d.copy()                   a shallow copy of d
+d.get(k,defaultval)        the item of d with key k                 (4)
+d.has_key(k)               True if d has key k, else False
+d.items()                  a copy of d's list of (key, item) pairs  (2)
+d.iteritems()              an iterator over (key, value) pairs      (7)
+d.iterkeys()               an iterator over the keys of d           (7)
+d.itervalues()             an iterator over the values of d         (7)
+d.keys()                   a copy of d's list of keys               (2)
+d1.update(d2)              for k, v in d2.items(): d1[k] = v        (3)
+d.values()                 a copy of d's list of values             (2)
+d.pop(k)                   remove d[k] and return its value
+d.popitem()                remove and return an arbitrary           (6)
+(key, item) pair
+d.setdefault(k,defaultval) the item of d with key k                 (5)
+Notes :
+TypeError is raised if key is not acceptable
+(1) KeyError is raised if key k is not in the map
+(2) Keys and values are listed in random order
+(3) d2 must be of the same type as d1
+(4) Never raises an exception if k is not in the map, instead it returns
+defaultVal.
+defaultVal is optional, when not provided and k is not in the map,
+None is returned.
+(5) Never raises an exception if k is not in the map, instead it returns
+defaultVal, and adds k to map with value defaultVal. defaultVal is
+optional. When not provided and k is not in the map, None is returned and
+added to map.
+(6) Raises a KeyError if the dictionary is emtpy.
+(7) While iterating over a dictionary, the values may be updated but
+the keys cannot be changed.
+Operations on strings
+Note that these string methods largely (but not completely) supersede the
+functions available in the string module.
+Operations on strings
+Operation                             Result                          Notes
+s.capitalize()    return a copy of s with only its first character
+capitalized.
+s.center(width)   return a copy of s centered in a string of length width  (1)
+.
+s.count(sub[      return the number of occurrences of substring sub in     (2)
+,start[,end]])    string s.
+s.decode(([       return a decoded version of s.                           (3)
+encoding
+[,errors]])
+s.encode([        return an encoded version of s. Default encoding is the
+encoding        current default string encoding.                         (3)
+[,errors]])
+s.endswith(suffix return true if s ends with the specified suffix,         (2)
+[,start[,end]]) otherwise return False.
+s.expandtabs([    return a copy of s where all tab characters are          (4)
+tabsize])         expanded using spaces.
+s.find(sub[,start return the lowest index in s where substring sub is      (2)
+[,end]])          found. Return -1 if sub is not found.
+s.index(sub[      like find(), but raise ValueError when the substring is  (2)
+,start[,end]])    not found.
+s.isalnum()       return True if all characters in s are alphanumeric,     (5)
+False otherwise.
+s.isalpha()       return True if all characters in s are alphabetic,       (5)
+False otherwise.
+s.isdigit()       return True if all characters in s are digit             (5)
+characters, False otherwise.
+s.islower()       return True if all characters in s are lowercase, False  (6)
+otherwise.
+s.isspace()       return True if all characters in s are whitespace        (5)
+characters, False otherwise.
+s.istitle()       return True if string s is a titlecased string, False    (7)
+otherwise.
+s.isupper()       return True if all characters in s are uppercase, False  (6)
+otherwise.
+s.join(seq)       return a concatenation of the strings in the sequence
+seq, seperated by 's's.
+s.ljust(width)    return s left justified in a string of length width.    (1),
+(8)
+s.lower()         return a copy of s converted to lowercase.
+s.lstrip()        return a copy of s with leading whitespace removed.
+s.replace(old,    return a copy of s with all occurrences of substring     (9)
+new[, maxsplit])  old replaced by new.
+s.rfind(sub[      return the highest index in s where substring sub is     (2)
+,start[,end]])    found. Return -1 if sub is not found.
+s.rindex(sub[     like rfind(), but raise ValueError when the substring    (2)
+,start[,end]])    is not found.
+s.rjust(width)    return s right justified in a string of length width.   (1),
+(8)
+s.rstrip()        return a copy of s with trailing whitespace removed.
+s.split([sep[     return a list of the words in s, using sep as the       (10)
+,maxsplit]])      delimiter string.
+s.splitlines([    return a list of the lines in s, breaking at line       (11)
+keepends])        boundaries.
+s.startswith      return true if s starts with the specified prefix,
+(prefix[,start[   otherwise return false.                                  (2)
+,end]])
+s.strip()         return a copy of s with leading and trailing whitespace
+removed.
+s.swapcase()      return a copy of s with uppercase characters converted
+to lowercase and vice versa.
+return a titlecased copy of s, i.e. words start with
+s.title()         uppercase characters, all remaining cased characters
+are lowercase.
+s.translate(table return a copy of s mapped through translation table     (12)
+[,deletechars])   table.
+s.upper()         return a copy of s converted to uppercase.
+s.zfill(width)    return a string padded with zeroes on the left side and
+sliding a minus sign left if necessary.  never truncates.
+Notes :
+(1) Padding is done using spaces.
+(2) If optional argument start is supplied, substring s[start:] is
+processed. If optional arguments start and end are supplied, substring s[start:
+end] is processed.
+(3) Optional argument errors may be given to set a different error handling
+scheme. The default for errors is 'strict', meaning that encoding errors raise
+a ValueError. Other possible values are 'ignore' and 'replace'.
+(4) If optional argument tabsize is not given, a tab size of 8 characters
+is assumed.
+(5) Returns false if string s does not contain at least one character.
+(6) Returns false if string s does not contain at least one cased
+character.
+(7) A titlecased string is a string in which uppercase characters may only
+follow uncased characters and lowercase characters only cased ones.
+(8) s is returned if width is less than len(s).
+(9) If the optional argument maxsplit is given, only the first maxsplit
+occurrences are replaced.
+(10) If sep is not specified or None, any whitespace string is a separator.
+If maxsplit is given, at most maxsplit splits are done.
+(11) Line breaks are not included in the resulting list unless keepends is
+given and true.
+(12) table must be a string of length 256. All characters occurring in the
+optional argument deletechars are removed prior to translation.
+String formatting with the % operator
+formatString % args--> evaluates to a string
+* formatString uses C printf format codes : %, c, s, i, d, u, o, x, X, e, E,
+f, g, G, r (details below).
+* Width and precision may be a * to specify that an integer argument gives
+the actual width or precision.
+* The flag characters -, +, blank, # and 0 are understood. (details below)
+* %s will convert any type argument to string (uses str() function)
+* args may be a single arg or a tuple of args
+'%s has %03d quote types.' % ('Python', 2)  # => 'Python has 002 quote types.'
+* Right-hand-side can also be a mapping:
+a = '%(lang)s has %(c)03d quote types.' % {'c':2, 'lang':'Python}
+(vars() function very handy to use on right-hand-side.)
+Format codes
+Conversion                               Meaning
+d          Signed integer decimal.
+i          Signed integer decimal.
+o          Unsigned octal.
+u          Unsigned decimal.
+x          Unsigned hexadecimal (lowercase).
+X          Unsigned hexadecimal (uppercase).
+e          Floating point exponential format (lowercase).
+E          Floating point exponential format (uppercase).
+f          Floating point decimal format.
+F          Floating point decimal format.
+g          Same as "e" if exponent is greater than -4 or less than precision,
+"f" otherwise.
+G          Same as "E" if exponent is greater than -4 or less than precision,
+"F" otherwise.
+c          Single character (accepts integer or single character string).
+r          String (converts any python object using repr()).
+s          String (converts any python object using str()).
+%          No argument is converted, results in a "%" character in the result.
+(The complete specification is %%.)
+Conversion flag characters
+Flag                                  Meaning
+#    The value conversion will use the ``alternate form''.
+0    The conversion will be zero padded.
+-    The converted value is left adjusted (overrides "-").
+(a space) A blank should be left before a positive number (or empty
+string) produced by a signed conversion.
++    A sign character ("+" or "-") will precede the conversion (overrides a
+"space" flag).
+File Objects
+Created with built-in function open; may be created by other modules' functions
+as well.
+Operators on file objects
+File operations
+Operation                                Result
+f.close()         Close file f.
+f.fileno()        Get fileno (fd) for file f.
+f.flush()         Flush file f's internal buffer.
+f.isatty()        True if file f is connected to a tty-like dev, else False.
+f.read([size])    Read at most size bytes from file f and return as a string
+object. If size omitted, read to EOF.
+f.readline()      Read one entire line from file f.
+f.readlines()     Read until EOF with readline() and return list of lines read.
+Set file f's position, like "stdio's fseek()".
+f.seek(offset[,   whence == 0 then use absolute indexing.
+whence=0])        whence == 1 then offset relative to current pos.
+whence == 2 then offset relative to file end.
+f.tell()          Return file f's current position (byte offset).
+f.write(str)      Write string to file f.
+f.writelines(list Write list of strings to file f.
+)
+File Exceptions
+EOFError
+End-of-file hit when reading (may be raised many times, e.g. if f is a
+tty).
+IOError
+Other I/O-related I/O operation failure.
+OSError
+OS system call failed.
+Advanced Types
+-See manuals for more details -
++ Module objects
++ Class objects
++ Class instance objects
++ Type objects (see module: types)
++ File objects (see above)
++ Slice objects
++ XRange objects
++ Callable types:
+o User-defined (written in Python):
+# User-defined Function objects
+# User-defined Method objects
+o Built-in (written in C):
+# Built-in Function objects
+# Built-in Method objects
++ Internal Types:
+o Code objects (byte-compile executable Python code: bytecode)
+o Frame objects (execution frames)
+o Traceback objects (stack trace of an exception)
+Statements
+pass            -- Null statement
+del name[,name]* -- Unbind name(s) from object. Object will be indirectly
+(and automatically) deleted only if no longer referenced.
+print [>> fileobject,] [s1 [, s2 ]* [,]
+-- Writes to sys.stdout, or to fileobject if supplied.
+Puts spaces between arguments. Puts newline at end
+unless statement ends with comma.
+Print is not required when running interactively,
+simply typing an expression will print its value,
+unless the value is None.
+exec x [in globals [,locals]]
+-- Executes x in namespaces provided. Defaults
+to current namespaces. x can be a string, file
+object or a function object.
+callable(value,... [id=value], [*args], [**kw])
+-- Call function callable with parameters. Parameters can
+be passed by name or be omitted if function
+defines default values. E.g. if callable is defined as
+"def callable(p1=1, p2=2)"
+"callable()"       <=>  "callable(1, 2)"
+"callable(10)"     <=>  "callable(10, 2)"
+"callable(p2=99)"  <=>  "callable(1, 99)"
+*args is a tuple of positional arguments.
+**kw is a dictionary of keyword arguments.
+Assignment operators
+Caption
+Operator                    Result                     Notes
+a = b    Basic assignment - assign object b to label a  (1)
+a += b   Roughly equivalent to a = a + b                (2)
+a -= b   Roughly equivalent to a = a - b                (2)
+a *= b   Roughly equivalent to a = a * b                (2)
+a /= b   Roughly equivalent to a = a / b                (2)
+a %= b   Roughly equivalent to a = a % b                (2)
+a **= b  Roughly equivalent to a = a ** b               (2)
+a &= b   Roughly equivalent to a = a & b                (2)
+a |= b   Roughly equivalent to a = a | b                (2)
+a ^= b   Roughly equivalent to a = a ^ b                (2)
+a >>= b  Roughly equivalent to a = a >> b               (2)
+a <<= b  Roughly equivalent to a = a << b               (2)
+Notes :
+(1) Can unpack tuples, lists, and strings.
+first, second = a[0:2]; [f, s] = range(2); c1,c2,c3='abc'
+Tip: x,y = y,x swaps x and y.
+(2) Not exactly equivalent - a is evaluated only once. Also, where
+possible, operation performed in-place - a is modified rather than
+replaced.
+Control Flow
+if condition: suite
+[elif condition: suite]*
+[else: suite]   -- usual if/else_if/else statement
+while condition: suite
+[else: suite]
+-- usual while statement. "else" suite is executed
+after loop exits, unless the loop is exited with
+"break"
+for element in sequence: suite
+[else: suite]
+-- iterates over sequence, assigning each element to element.
+Use built-in range function to iterate a number of times.
+"else" suite executed at end unless loop exited
+with "break"
+break           -- immediately exits "for" or "while" loop
+continue        -- immediately does next iteration of "for" or "while" loop
+return [result] -- Exits from function (or method) and returns result (use a tuple to
+return more than one value). If no result given, then returns None.
+yield result    -- Freezes the execution frame of a generator and returns the result
+to the iterator's .next() method.  Upon the next call to next(),
+resumes execution at the frozen point with all of the local variables
+still intact.
+Exception Statements
+assert expr[, message]
+-- expr is evaluated. if false, raises exception AssertionError
+with message. Inhibited if __debug__ is 0.
+try: suite1
+[except [exception [, value]: suite2]+
+[else: suite3]
+-- statements in suite1 are executed. If an exception occurs, look
+in "except" clauses for matching <exception>. If matches or bare
+"except" execute suite of that clause. If no exception happens
+suite in "else" clause is executed after suite1.
+If exception has a value, it is put in value.
+exception can also be tuple of exceptions, e.g.
+"except (KeyError, NameError), val: print val"
+try: suite1
+finally: suite2
+-- statements in suite1 are executed. If no
+exception, execute suite2 (even if suite1 is
+exited with a "return", "break" or "continue"
+statement). If exception did occur, executes
+suite2 and then immediately reraises exception.
+raise exception [,value [, traceback]]
+-- raises exception with optional value
+value. Arg traceback specifies a traceback object to
+use when printing the exception's backtrace.
+raise           -- a raise statement without arguments re-raises
+the last exception raised in the current function
+An exception is either a string (object) or a class instance.
+Can create a new one simply by creating a new string:
+my_exception = 'You did something wrong'
+try:
+if bad:
+raise my_exception, bad
+except my_exception, value:
+print 'Oops', value
+Exception classes must be derived from the predefined class: Exception, e.g.:
+class text_exception(Exception): pass
+try:
+if bad:
+raise text_exception()
+# This is a shorthand for the form
+# "raise <class>, <instance>"
+except Exception:
+print 'Oops'
+# This will be printed because
+# text_exception is a subclass of Exception
+When an error message is printed for an unhandled exception which is a
+class, the class name is printed, then a colon and a space, and
+finally the instance converted to a string using the built-in function
+str().
+All built-in exception classes derives from 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.
+bool(x)             Returns True when the argument x is true and False otherwise.
+buffer(obj)         Creates a buffer reference to an object.
+callable(x)         Returns True if x callable, else False.
+chr(i)              Returns one-character string whose ASCII code isinteger i
+classmethod(f)      Converts a function f, into a method with the class as the
+first argument.  Useful for creating alternative constructors.
+cmp(x,y)            Returns negative, 0, positive if x <, ==, > to y
+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
+dict([items])       Create a new dictionary from the specified item list.
+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)
+enumerate(seq)      Return a iterator giving:  (0, seq[0]), (1, seq[1]), ...
+eval(s[, globals[,  Eval string s in (optional) globals, locals contexts.s must
+locals]])           have no NUL's or newlines. s can also be acode object.
+Example: x = 1; incr_x = eval('x + 1')
+execfile(file[,     Executes a file without creating a new module, unlike
+globals[, locals]]) import.
+file()              Synonym for open().
+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)
+help(f)             Display documentation on object f.
+hex(x)              Converts a number x to a hexadecimal string.
+id(object)          Returns a unique 'identity' integer for an object.
+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
+iter(collection)    Returns an iterator over the collection.
+len(obj)            (sequence, dictionary, or instance of class implementing
+__len__).
+list(sequence)      Converts sequence into a list. If already a list,returns a
+copy of it.
+locals()            Returns a dictionary containing current local variables.
+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.
+object()            Create a base type.  Used as a superclass for new-style objects.
+open(name           Open a file.
+[, mode
+[, buffering]])
+pow(x, y [, z])     Returns x to power y [modulo z]. See also ** operator.
+property()          Created a property with access controlled by functions.
+range(start [,end   Returns list of ints from >= start and < end.With 1 arg,
+[, step]])          list from 0..arg-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
+staticmethod()      Convert a function to method with no self or class
+argument.  Useful for methods associated with a class that
+do not need access to an object's internal state.
+str(object)         printablerepresentation of an object. Class overridable
+(__str__).See also repr().
+super(type)         Create an unbound super object.  Used to call cooperative
+superclass methods.
+sum(sequence,       Add the values in the sequence and return the sum.
+[start])
+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()'
+StopIteration
+Signal the end from iterator.next()
+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
+Warning
+UserWarning
+DeprecationWarning
+PendingDeprecationWarning
+SyntaxWarning
+RuntimeWarning
+FutureWarning
+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 False or True 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:
+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)
+Classes:    [in bold: writable since 1.5.2]
+__doc__ (string/None, R/W): doc string (<=> __dict__['__doc__'])
+__module__ is the module name in which the class was defined
+__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
+func_dict (dict, R/W):  same as __dict__ contains the namespace supporting
+arbitrary function attributes
+func_closure (R/O): None or a tuple of cells that contain bindings
+for the function's free 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
+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_cellvars (tuple, R/O)) the names of local variables referenced by
+nested functions
+co_freevars (tuple, R/O)) names of free variables
+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_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 occurred
+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
+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).
+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 one
+)                  higher than you might expect, because of object arg temp
+reference.
+setcheckinterval(  Sets the interpreter's thread switching interval (in number
+interval)          of virtual code instructions, default:100).
+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 local variable in a
+function handling 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.)
+()
+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)
+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'
+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.
+posix
+don't import this module directly, import os instead !
+(see also module: shutil for file copy & remove fcts)
+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.
+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.
+posixpath
+Do not import this module directly, import os instead and refer to this module
+as os.path. (e.g. os.path.exists(p)) !
+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.
+shutil
+high-level file operations (copying, deleting).
+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
+(and also: copyfile, copymode, copystat, copy2)
+time
+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
+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.
+and also: clock, ctime.
+string
+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.
+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.
+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 occurrences 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.
+re (sre)
+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.
+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 occurrence 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.
+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
+Variables
+Variable                       Meaning
+error    Exception when pattern string isn't a valid regexp.
+Functions
+Function                                 Result
+Compile a RE pattern string into a regular expression object.
+Flags (combinable by |):
+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])
+Regular Expression Objects
+(RE objects are returned by the compile fct)
+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
+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])
+Match Objects
+(Match objects are returned by the match & search functions)
+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()
+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.
+math
+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)
+degrees(x)
+exp(x)
+fabs(x)
+floor(x)
+fmod(x, y)
+frexp(x)        -- Unlike C: (float, int) = frexp(float)
+ldexp(x, y)
+log(x [,base])
+log10(x)
+modf(x)         -- Unlike C: (float, float) = modf(float)
+pow(x, y)
+radians(x)
+sin(x)
+sinh(x)
+sqrt(x)
+tan(x)
+tanh(x)
+getopt
+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']
+List of modules and packages in base distribution
+(built-ins and content of python Lib directory)
+(Python NT distribution, may be slightly different in other distributions)
+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.
+bz2              Support for bz2 compression/decompression.
+calendar         Calendar printing functions.
+cgi              Wraps the WWW Forms Common Gateway Interface (CGI).
+cgitb            Utility for handling CGI tracebacks.
+CGIHTTPServer    CGI http services.
+cmd              A generic class to build line-oriented command interpreters.
+datetime         Basic date and time types.
+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.
+csv              Read and write files with comma separated values.
+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]
+difflib          Tool for creating delta between sequences.
+dis              Bytecode disassembler.
+distutils        Package installation system.
+doctest          Tool for running and verifying tests inside doc strings.
+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]
+email            Comprehensive support for internet email.
+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.
+heapq            Priority queue implemented using lists organized as heaps.
+HMAC             Keyed-Hashing for Message Authentication -- RFC 2104.
+htmlentitydefs   Proposed entity definitions for HTML.
+htmllib          HTML parsing utilities.
+HTMLParser       A parser for HTML and XHTML.
+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.
+inspect          Tool for probing live Python objects.
+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.
+logging          Python logging facility.
+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.
+optparse         A comprehensive tool for processing command line options.
+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.
+pkgunil          Utilities for working with Python packages.
+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.
+pydoc            Utility for generating documentation from source files.
+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
+re               Regular Expressions.
+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 robots.txt files, useful for web spiders.
+sched            A generally useful event scheduler class.
+sets             Module for a set datatype.
+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.
+tarfile          Facility for reading and writing to the *nix tarfile format.
+telnetlib        TELNET client class. Based on RFC 854.
+tempfile         Temporary file name allocation.
+textwrap         Object for wrapping and filling text.
+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.
+unittest         Utilities for implementing unit testing.
+wave             Stuff to parse WAVE files.
+weakref          Tools for creating and managing weakly referenced objects.
+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.
+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.
+xmlrpclib        Support for remote procedure calls using XML.
+zipfile          Read & write PK zipped files.
+[DEL:zmod:DEL]   [DEL:Demonstration of abstruse mathematical concepts.:DEL]
+* Built-ins *
+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 (also the newer datetime module)
+marshal             Read and write some python values in binary format
+struct              Convert between python values and C structs
+* Standard *
+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
+random              Mersenne Twister pseudo-random number generator
+thread              Low-level primitives for working with process threads
+threading           idem, new recommanded interface.
+* Unix/Posix *
+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
+* Tk User-interface Toolkit *
+tkinter             Main interface to Tk
+* 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 *
+md5         Interface to RSA's MD5 message digest algorithm
+sha         Interface to the SHA message digest algorithm
+HMAC        Keyed-Hashing for Message Authentication -- RFC 2104.
+* SGI IRIX * (4 & 5)
+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
+* Suns *
+sunaudiodev Access to sun audio interface
+Workspace exploration and idiom hints
+dir(<module>)   list functions, variables in <module>
+dir()           get object keys, defaults to local name space
+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
+Python Mode for Emacs
+(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
+C-c C-w runs PyChecker
+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
+The Python Debugger
+(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)
+Accessing
+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>
+-- defines class Pdb :
+use Pdb to create reusable debugger objects. Object
+preserves state (i.e. break points) between calls.
+runs until a breakpoint hit, exception, or end of program
+If exception, variable '__exception__' holds (exception,value).
+Commands
+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
+j, jump lineno
+Set the next line that will be executed
+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.
+Example
+(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.
+Quirks
+Breakpoints are stored as filename, line number tuples. If a module is reloaded
+after editing, any remembered breakpoints are likely to be wrong.
+Always single-steps through top-most stack frame. That is, "c" acts like "n".