Chris Rathman / ChrisRath@aol.com

#!/usr/local/bin/python
#########################################################################
#                                                                       #
#  Reserved Words:                                                      #
#                                                                       #
#        and             elif            global          or             #
#        assert          else            if              pass           #
#        break           except          import          print          #
#        class           exec            in              raise          #
#        continue        finally         is              return         #
#        def             for             lambda          try            #
#        del             from            not             while          #
#                                                                       #
#########################################################################

#########################################################################
#                                                                       #
#  Importing Modules:                                                   #
#                                                                       #
#########################################################################
import sys                             # access module
from sys import stdout                 # access module without qualiying name
from sys import *                      # ditto for all functions/classes in module
from win32com.client import constants  # packages are supported - requires __init__.py in dir
exec "import sys"                      # dynamic imports are possible
__import__("sys")                      # another form of dynamic import
reload(sys)                            # reload module code

x = sys.argv                           # access module feature: module.feature
x = argv                               # access module feature without qualifer - from
x = sys.path                           # module search path - can be modified - PYTHONPATH
x = sys.__dict__["argv"]               # each module has dictionary used for name lookups
x = getattr(sys, "argv")               # call built in fetch function
argv = ["/"]                           # from only assigns name - sys.argv is not changed

#########################################################################
#                                                                       #
#  hello:                                                               #
#                                                                       #
#########################################################################
print "hello world"                    # stdout
print "hello", "world",                # comma on end suppresses newline
print ""
x = sys.argv                           # list of command line arguments
#sys.exit()                            # exit application

#########################################################################
#                                                                       #
#  line spanning:                                                       #
#                                                                       #
#########################################################################
x = "hello" + \
   "world"                             # span several lines- no comments after \
if (0 and                              # open parenthesis may span lines
   1): pass
x = [                                  # open list may span lines
   "hello",
   "world"
]
x = 10; y = 10                         # multiple statements on a line

#########################################################################
#                                                                       #
#  Primitive Variable Types:                                            #
#                                                                       #
#########################################################################
x = 123                                # integer
x = 123L                               # long integer
x = 3.14                               # double float
x = 3+4j                               # complex
x = "hello"                            # string
x = [0,1,2]                            # list
x = (0,1,2)                            # tuple
x = open('hello.py', 'r')              # file

x = 077                                # octal number
x = 0xFF                               # hexadecimal number
x = 3.14E-2                            # scientific format
x = None                               # null value

X = 1                                  # python is case sensitive X <> x
x = (1 < 2)                            # boolean: False = 0 (0, Empty, or None); True = 1 | !0

#########################################################################
#                                                                       #
#  Strings:                                                             #
#                                                                       #
#########################################################################
x = ""                                 # empty string
x = 'hello'                            # strings can use either single or double quote
x = r"hello\n"                         # raw string - retain backslashes
x = """hello"""                        # triple quoted strings may span several lines

y = `x`                                # convert to string
y = str(123)                           # convert to string
x = "hello" * 3                        # string repeat
x = "hello" + " world"                 # string concatenate
y = len(x)                             # string length
for char in x: y = char                # iterate through characters

                                       # string slicing
y = x[:2]                              # left(s, b)               - "he"
y = x[:-2]                             # left(s, len(s)+b)        - "hello wor"
y = x[-2:]                             # right(s, -a)             - "ld"
y = x[6]                               # mid(s, a, 1)             - "w"
y = x[2:4]                             # mid(s, a, b-a)           - "ll"
y = x[2:-3]                            # mid(s, a, len(s)+b-a)    - "llo wo"
y = x[-4:-2]                           # mid(s, len(s)-a, -a-b)   - "or"

                                       # string backslash characters
x = "\\"                               # backslash
x = "\'"                               # single quote
x = "\""                               # double quote
x = "\a"                               # bell
x = "\b"                               # backspace
x = "\e"                               # escape
x = "\000"                             # null that does not end string
x = "\n"                               # newline
x = "\v"                               # vertical tab
x = "\t"                               # tab
x = "\r"                               # carriage return
x = "\f"                               # formfeed
x = "\077"                             # octal character
x = "\x7F"                             # hex character
x = "\z"                               # any other chars - the slash & char is retained (\z)

                                       # string formatting
x = "hello %s" % "world"               # %s = string
x = "hello %c" % 0x77                  # %c = character
x = "hello %d" % 123                   # %d = decimal int
x = "hello %i" % 123                   # %i = integer
x = "hello %u" % 123                   # %u = unsigned integer
x = "hello %o" % 077                   # %o = octal integer (w/o leadin 0)
x = "hello %x" % 0xFF                  # %x = hex integer lowercase (w/o leadin 0x)
x = "hello %X" % 0xFF                  # %X = hex integer uppercase (w/o leadin 0x)
x = "hello %e" % 1.23                  # %e = floating point (1.230000e+000)
x = "hello %E" % 1.23                  # %E = floating point (1.230000E+000)
x = "hello %f" % 1.23                  # %f = floating point (1.230000)
x = "hello %g" % 1.23                  # %g = floating point (1.23)
x = "hello %G" % 1.23                  # %G = floating point (1.23)
x = "hello %s%%" % "world"             # %% = literal percent character

#########################################################################
#                                                                       #
#  Lists:                                                               #
#                                                                       #
#########################################################################
x = []                                 # empty list
x = [0, 1, 2, "abc"]                   # four item list: indexed x[0]..x[3]
x = [0, 1, 2, 3, [1, 2]]               # nested sublists
y = len(x)                             # list length
y = x[0]                               # indexed item
y = x[4][0]                            # indexed sublist
x = [0, 1] * 2                         # repeat
x = [0, 1, 2] + [3, 4]                 # concatenation
x = range(5)                           # make list over range
x = range(0, 5)                        # make list over range with start index
x = range(0, 5, 1)                     # make list over range with start index and increment
for item in x: y = item                # iterate through list
b = 3 in x                             # test list membership

                                       # list slicing
y = x[:2]                              # left(L, n)               - [0, 1]
y = x[:-2]                             # left(L, len(L)+b)        - [0, 1, 2]
y = x[-2:]                             # right(L, -a)             - [3, 4]
y = x[2:4]                             # mid(L, a, b-a)           - [2, 3]
y = x[1:-3]                            # mid(L, a, len(L)+b-a)    - [1]
y = x[-4:-2]                           # mid(L, len(L)-a, -a-b)   - [1, 2]

                                       # methods
x.append(5)                            # grow list: x[len(x):] = [a]
x.extend([7,8])                        # grow list: x[len(x):] = L
x.insert(0, 9)                         # insert into list
x.remove(9)                            # remove first item in list with value
y = x.pop()                            # remove last item from list and return value
y = x.pop(1)                           # remove indexed item from list and return value
x.reverse()                            # reverse list
x.sort()                               # sort list
y = x.index(3)                         # search list and return index if value found
y = x.count(3)                         # search list and return number of instances found

del x[3]                               # delete item from list (can also del a slice)
x[1:2] = []                            # delete slice

x[1] = 'a'                             # replace item
x[1:2] = ['a', 'b', 'c']               # replace slice

x = [0, 1, 2, 3]
y = map(lambda a: a*a, x)              # apply function to each item in list
y = filter(lambda a: a>1, x)           # return list of items that meet condition
y = reduce(lambda a,b: a+b, x)         # return value by applying iteration (sum list)

#########################################################################
#                                                                       #
#  Tuples:                                                              #
#                                                                       #
#########################################################################
x = ()                                 # empty tuple
x = (0,)                               # one item tuple
x = (0, 1, 2, "abc")                   # four item tuple: indexed x[0]..x[3]
x = 0, 1, 2, "abc"                     # parenthesis are optional
x = (0, 1, 2, 3, (1, 2))               # nested subtuples
y = x[0]                               # indexed item
y = x[4][0]                            # indexed subtuple
x = (0, 1) * 2                         # repeat
x = (0, 1, 2) + (3, 4)                 # concatenation
for item in x: y = item                # iterate through tuple
b = 3 in x                             # test tuple membership

                                       # tuple slicing
y = x[:2]                              # left(L, n)               - [0, 1]
y = x[:-2]                             # left(L, len(L)+b)        - [0, 1, 2]
y = x[-2:]                             # right(L, -a)             - [3, 4]
y = x[2:4]                             # mid(L, a, b-a)           - [2, 3]
y = x[1:-3]                            # mid(L, a, len(L)+b-a)    - [1]
y = x[-4:-2]                           # mid(L, len(L)-a, -a-b)   - [1, 2]

#########################################################################
#                                                                       #
#  Dictionaries:                                                        #
#                                                                       #
#########################################################################
x = {}                                 # empty dictionary
x = {"a": 10, "b": 20}                 # two item dictionary
x = {"a": 1, "b": {"c": 2, "d": 3}}    # nested dictionary
y = x["a"]                             # indexing by key
y = x["b"]["c"]                        # indexed subdictionary
x["e"] = 4                             # add an entry
x["e"] = 5                             # change an entry
del x["e"]                             # delete an entry
y = len(x)                             # number of items
y = x.has_key("a")                     # test if has key
y = x.get("a")                         # indexing by key
y = x.get("a", "z")                    # if key not found then return second arg
for item in x.keys(): y = item         # iterate over keys
for item in x.values(): y = item       # iterate over values
for key, val in x.items(): y = key     # iterate over copy of (key, value) pairs
y = x.copy()                           # shallow copy
x.update(y)                            # update dictionary with another dictionary's values
x.clear()                              # remove all items

#########################################################################
#                                                                       #
#  Files:                                                               #
#                                                                       #
#########################################################################
x = open("test.txt", "w")              # open file for write
x.write("hello\n")                     # write string
x.writelines(["fred\n", "hank\n"])     # write all strings in list
x.flush()                              # flush buffer
y = x.fileno()                         # file handle number
b = x.isatty()                         # true if tty device
b = x.closed                           # current state of file object
y = x.name                             # file name
b = x.softspace                        # boolean to indicate whether print requires space
x.close()                              # close file

x = open("test.txt", "r")              # open file for input

while 1:                               # iterate through the file one line at a time
   y = x.readline()
   if (not y): break
for each in x.readlines(): y = each    # iterate through the file

y = x.read()                           # read entire file into a string
y = x.read(5)                          # read n characters
y = x.readline()                       # read next line
y = x.readlines()                      # read file into list of strings
y = x.seek(0)                          # seek to the specified byte
y = x.tell()                           # tell current file position
x.close()

import pickle
x = open("test.txt", "w")
pickle.dump([0, 1, 2], x)              # save an object off to file - serialize
x.close

x = open("test.txt", "r")
y = pickle.load(x)                     # restore an object from file
x.close

#########################################################################
#                                                                       #
#  Operators:                                                           #
#                                                                       #
#        ``   convert to string             &   bitwise and             #
#        ()   tuple                         ^   bitwise exclusive or    #
#        []   list                          |   bitwise or              #
#        {}   dictionary                    <   less than               #
#       [x]   indexing                     <=   less than or equal      #
#     [x:y]   slicing                       >   greater than            #
#       m.f   qualification                >=   greater than or equal   #
#       f()   function call                ==   equal                   #
#         -   unary negation               <>   not equal               #
#         +   unary positive               !=   not equal               #
#         ~   bitwise compliment           is   identity                #
#        **   exponentiation           is not   identity not            #
#         *   multiply | repeat            in   sequence membership     #
#         /   divide                   not in   sequence non-membership #
#         %   remainder (modulo)          not   logical not             #
#         +   add                         and   logical and             #
#         -   subtract                     or   logical or              #
#        <<   shift left               lambda   anonymous function      #
#        >>   shift right                                               #
#                                                                       #
#########################################################################
x = 0                                  # assignment
x = y = 0                              # compound assignment
[x, y, z] = [0, 1, 2]                  # positional list assignment: x=0, y=1, z=2
x, y, z = (0, 1, 2)                    # positional tuple assignment: x=0, y=1, z=2
b = (0 < x < 2)                        # range test

x = -5                                 # unary minus
x = +5                                 # unary plus
x = ~0x7f                              # bitwise compliment
x = 2 ** 8                             # power operator
x = 5 / 2                              # divide - if both int's then div function
x = 5 % 2                              # remainder modulo
x = 5 + 2                              # add
x = 5 - 2                              # subtract
x = 0x0f << 2                          # shift left
x = 0x3c >> 2                          # shift right
x = 0x0f & 0x8f                        # bitwise and
x = 0x0f | 0x80                        # bitwise or
x = 0x0f ^ 0x80                        # bitwise xor

x = [0, 1, 2]
y = [0, 1, 2]

b = (x == y)                           # equal
b = (x != y)                           # not equal - preferred
b = (x <> y)                           # not equal
b = (x < y)                            # less than
b = (x <= y)                           # less than or equal
b = (x > y)                            # greater than
b = (x >= y)                           # greater than or equal

b = (x is y)                           # identity reference
b = (x is not y)                       # different reference
b = (1 in x)                           # membership
b = (1 not in x)                       # not member
b = not 0                              # logical not
b = 0 and 1                            # logical and
b = 0 or 1                             # logical or

x = (1+2j).conjugate()                 # conjugate of complex number

#########################################################################
#                                                                       #
#  Flow Control:                                                        #
#                                                                       #
#########################################################################
x = 10
y = 10
b = 1

if (b):                                # if then else
   y = 1
elif (x == 10):
   y = 2
else:
   y = 3

while (x != 0):                        # while loop
   x = x - 1
   pass                                # empty placeholder
   if (b): continue                    # continue with next loop
   break;                              # break out of loop
else:                                  # run if didn't exit loop with break
   x = x + 1

for x in range(4):                     # for loop
   y = y + 1
   pass
   if (b): continue
   break;
else:                                  # run if didn't exit loop with break
   y = y + 1

#########################################################################
#                                                                       #
#  Exceptions and Assertions:                                           #
#                                                                       #
#########################################################################
class myGeneralError: pass             # define class and subclass to use with exceptions
class mySpecificError(myGeneralError): pass

try:                                   # try-catch block
   raise AttributeError                # throw an exception
   raise IOError, "bad IO"             # with an exception message
   raise mySpecificError()             # with user defined exception class
except AttributeError:                 # catch a specific exception
   pass
except myGeneralError:                 # catch user defined exception (subclasses also caught)
   pass
except IOError, msg:                   # catch a specific exception with extra data
   pass
except (RuntimeError, StandardError):  # catch any of the list of exceptions
   pass
except:                                # catch all exceptions not handled above
   pass
else:                                  # run if no exceptions thrown
   pass

try:                                   # try-finally block - note exception propogates up
   x = 1
finally:                               # always perform this block
   pass

assert(1<2)                            # raise AssertionError if condition not met
assert(1<2), "Assertion message"       # with message to display

#########################################################################
#                                                                       #
#  Functions:                                                           #
#                                                                       #
#########################################################################
def factorial(n):                      # define a function
   if (n == 1):
      return (1)
   else:
      return (n * factorial(n-1))

x = factorial(5)                       # call a function
x = factorial                          # indirect call to function
y = x(5)

def accessglobal():
   global glib                         # assign to var from global scope
   glib = 100

glib = 0
accessglobal()

def outer(a, b):
   i = 100
   def inner(c=a, d=b):                # only access to outer vars is thru default params
      i = 101                          # var is local to inner scope
   inner()                             # outer scope var not changed

x = outer(1, 2)


def test(a, b, c=0, d=0):              # default values for optional parameters
   pass                                # vals eval'd when def parsed - not when function called

test(1, 2)
test(1, 2, 3, 4)
test(a=1, b=2)                         # keyword matched parameters
test(1, d=1, b=2)

def posA(a, *b):                       # match remaining positional chars in tuple
   pass

posA(1, 2, 3, 4)

def posB(a, **b):                      # match remaining positional chars in dictionary
   pass

posB(1, b=2, c=3, d=4)

x = lambda a: a * a                    # lambda functions
y = x(2)

x = apply(factorial, (5,))             # built-in apply function

#########################################################################
#                                                                       #
#  Classes:                                                             #
#                                                                       #
#########################################################################
class Shape:
   def __init__(self, x, y):
      self.x = x
      self.y = y

class Drawable:
   def draw(self):
      pass

def getNumInstances():                 # class functions not supported - use module function
   return Circle.numInstances

class Circle(Shape, Drawable):
   numInstances = 0                    # class attribute (static)

   def __init__(self, x, y, radius):   # constructor
      Shape.__init__(self, x, y)
      self.radius = radius
      Circle.numInstances = Circle.numInstances + 1
   def __del__(self):                  # destructor
      pass

   def draw(self): print "Drawing a", self.__repr__()          # normal instance method
   def __mangle(self): pass                                    # mangle: _Circle__mangle

   def __repr__(self):                                         # print X or `X`
      return "Circle at:(%d,%d), radius %d" % (self.x, self.y, self.radius)
   def __str__(self): return self.__repr__()                   # convert to string
   def __hash__(self): return 0                                # 32 bit hash int
   def __nonzero__(self): return 1                             # truth test
   def __cmp__(self, other): return 0                          # compare self to other

   def __getattr__(self, name): return self.__dict__[name]     # control attribute access
   def __setattr__(self, name, val): self.__dict__[name] = val # set attribute value
   def __delattr__(self, name): pass                           # delete attribute
   def __call__(self, *args): return self.__repr__()           # function call x()

   def __len__(self): return 1                                 # get length
   def __getitem__(self, key): pass                            # get indexed item
   def __setitem__(self, key, val): pass                       # set indexed item
   def __delitem__(self, key): pass                            # delete indexed item

   def __getslice__(self, i, j): pass                          # get indexed slice
   def __setslice__(self, i, j, val): pass                     # set indexed slice
   def __delslice__(self, i, j): pass                          # delete indexed slice

   def __add__(self, other): pass                              # + operator
   def __sub__(self, other): pass                              # - operator
   def __mul__(self, other): pass                              # * operator
   def __div__(self, other): pass                              # / operator
   def __mod__(self, other): pass                              # % operator
   def __divmod__(self, other): return (1, 2)                  # divmod()
   def __pow__(self, other, *modulo): pass                     # pow()
   def __lshift__(self, other): pass                           # << operator
   def __rshift__(self, other): pass                           # >> operator
   def __and__(self, other): pass                              # & operator
   def __or__(self, other): pass                               # | operator
   def __xor__(self, other): pass                              # ^ operator

   def __radd__(self, other): pass                             # + operator - reversed
   def __rsub__(self, other): pass                             # - operator - reversed
   def __rmul__(self, other): pass                             # * operator - reversed
   def __rdiv__(self, other): pass                             # / operator - reversed
   def __rmod__(self, other): pass                             # % operator - reversed
   def __rdivmod__(self, other): return (1, 2)                 # divmod() - reversed
   def __rpow__(self, other): pass                             # pow() - reversed
   def __rlshift__(self, other): pass                          # << operator - reversed
   def __rrshift__(self, other): pass                          # >> operator - reversed
   def __rand__(self, other): pass                             # & operator - reversed
   def __ror__(self, other): pass                              # | operator - reversed
   def __rxor__(self, other): pass                             # ^ operator - reversed

   def __pos__(self): pass                                     # + operator - unary plus
   def __neg__(self): pass                                     # - operator - unary minus
   def __abs__(self): pass                                     # abs()
   def __invert__(self): pass                                  # invert function

   def __complex__(self): pass                                 # complex()
   def __int__(self): pass                                     # int()
   def __long__(self): pass                                    # long()
   def __float__(self): pass                                   # float()
   def __oct__(self): pass                                     # oct()
   def __hex__(self): pass                                     # hex()
   def __coerce__(self, other): pass                           # coerce for mixed mode

scribble = Circle(15, 25, 8)           # allocate object
scribble.draw()                        # method call
Circle.draw(scribble)                  # alternative form of method call
x = getNumInstances()                  # static function emulation
x = scribble.__dict__                  # dictionary used to store object attributes
x = scribble.__class__                 # class which object belongs to
del scribble                           # manually delete object

#########################################################################
#                                                                       #
#  Documentation strings:                                               #
#                                                                       #
#########################################################################
def docMe():
   "this is documentation for a function"
   pass

class docYou:
   "this is documentation for a class"

   def methYou(self):
      "this is a documentation for a method"
      pass

x = docMe.__doc__                      # retrieve documentation string
x = docYou.__doc__
x = docYou.methYou.__doc__

#########################################################################
#                                                                       #
#  __builtins__                                                         #
#                                                                       #
#        __debug__      divmod         isinstance     raw_input         #
#        __doc__        eval           issubclass     reduce            #
#        __import__     execfile       len            reload            #
#        __name__       exit           list           repr              #
#        abs            filter         locals         round             #
#        apply          float          long           setattr           #
#        buffer         getattr        map            slice             #
#        callable       globals        max            str               #
#        chr            hasattr        min            tuple             #
#        cmp            hash           oct            type              #
#        coerce         hex            open           vars              #
#        compile        id             ord            xrange            #
#        complex        input          pow                              #
#        delattr        int            quit                             #
#        dir            intern         range                            #
#                                                                       #
#        ArithmeticError         IndexError           RuntimeError      #
#        AssertionError          KeyError             StandardError     #
#        AttributeError          KeyboardInterrupt    SyntaxError       #
#        EOFError                LookupError          SystemError       #
#        Ellipsis                MemoryError          SystemExit        #
#        EnvironmentError        NameError            TypeError         #
#        Exception               None                 ValueError        #
#        FloatingPointError      NotImplementedError  ZeroDivisionError #
#        IOError                 OSError                                #
#        ImportError             OverflowError                          #
#                                                                       #
#########################################################################
if (__debug__): pass                   # flag for debug mode
x = __doc__                            # get documentation string
__import__("sys")                      # built in import function
if (__name__ == "__main__"): pass      # check if this is the top level module
x = abs(-5)                            # abs value
x = apply(factorial, (5,))             # apply function
x = buffer("hello")                    # create reference to buffer object
b = callable("hello")                  # flag whether object is callable x()
x = chr(0x2A)                          # convert ascii int to character
x = cmp(1, 2)                          # compare function (-1 0 or 1)
x = coerce(1, 2.0)                     # return tuple with two arguments coerced to common type
#compile("x = 1", "test.pyc", "exec")  # compile the string into a code object
x = complex(1, 2)                      # build complex number: same as (1+2j)
#delattr(Circle, "numInstances")       # delete attribute from object
x = dir()                              # list of items in the dictionary
x = dir(__builtins__)                  # list of built in objects
(x, y) = divmod(4, 3)                  # return both div and mod values in a tuple
x = eval("1 + 2")                      # evaluate string as python code
x = execfile("test.py")                # pull in external file
y = filter(lambda a: a>1, [1, 2, 3])   # return list of items that meet condition
x = float(3)                           # convert to floating point
x = getattr(sys, "argv")               # fetch attribute
x = globals()                          # dictionary with current global symbol table
b = hasattr(Circle, "numInstances")    # test if object has attribute
x = hash("abc")                        # return 32 bit hash value for object
x = hex(0x7f)                          # convert int to hex string
x = id("abc")                          # return the identity of the object
#try: x = input(">Prompt")             # get input from user prompt
#except: pass
x = int(3.56)                          # convert to int - truncate
x = intern("abc")                      # intern a string - for speeding up lookups
b = isinstance(x, Circle)              # test if object is instance of class or a subclass
b = issubclass(Circle, Shape)          # test if class is a subclass
x = len([1, 2, 3])                     # length of sequence
x = list([1, 2, 3])                    # convert to or copy list
x = locals()                           # dictionary with current local symbol table
x = long(3.56)                         # convert to long - truncate
y = map(lambda a: a*a, [1, 2, 3])      # apply function to each item in list
x = max([1, 2, 3])                     # max item value in sequence
x = min([1, 2, 3])                     # min item value in sequence
x = oct(077)                           # convert int to octal string
x = open("test.txt", "r")              # open file
x = ord("a")                           # convert ascii char to int
x = pow(2, 4)                          # power function
x = range(0, 5, 1)                     # make list over range with start index and increment
#try: x = raw_input(">Prompt")         # get input from user prompt
#except: pass
y = reduce(lambda a,b: a+b, [1, 2, 3]) # return value by applying iteration (sum list)
reload(sys)                            # reload module code
x = repr("hello")                      # get string representation of object
x = round(1.5)                         # round value (2.0)
x = round (123.456, 2)                 # round to decimal place (123.46)
x = round (123.456, -2)                # round to digit (100.0)
setattr(Circle, "numInstances", 2)     # set attribute value
x = slice(0, 5, 1)                     # create a slice attribute in range form
x = str(1.0)                           # convert to string
x = tuple([1, 2, 3])                   # convert to tuple
x = type([1, 2, 3])                    # object type
x = vars()                             # dictionary with current local symbol table
x = vars(Circle)                       # return local symbol table of object
x = xrange(0, 5, 1)                    # same as range, but does not create a list

x = None                               # null object

try:
   raise Exception                     # root class for all exceptions
   raise StandardError                 # base class for all exceptions except SystemExit
   raise ArithmeticError               # base class for arithmetic exceptions
   raise LookupError                   # base class for key or index exceptions
   raise EnvironmentError              # base class for external exceptions

   raise AssertionError                # assert statement fails
   raise AttributeError                # attribute reference fails
   raise EOFError                      # eof condition without reading any data
   raise FloatingPointError            # floating point operation fail
   raise ImportError                   # import statement fail
   raise IndexError                    # sequence subscript out of range
   raise IOError                       # io exception
   raise KeyError                      # dictionary key not found
   raise KeyboardInterrupt             # user hit interrupt key
   raise MemoryError                   # out of memory
   raise NameError                     # local or global name not found
   raise NotImplementedError           # used for abstract classes
   raise OverflowError                 # overflow exception
   raise OSError                       # os exception
   raise RuntimeError                  # exceptions that don't fit other classes
   raise SyntaxError                   # syntax error encountered
   raise SystemError                   # internal error
   raise SystemExit                    # sys.exit command
   raise TypeError                     # built in applied to inappropriate object
   raise ValueError                    # built in has correct type but bad value
   raise ZeroDivisionError             # divide by zero error

except:
   pass

Chris Rathman / ChrisRath@aol.com