Load the demonstration software

Author: jeffsilverm

assertions.py

@@ -0,0 +1,38 @@
+"""
+Precondition, postcondition, invariant
+
+A while-loop can be derived by filling in this template
+with blocks S and T and condition P
+that establish invariant I and postcondition I and not P
+
+    S
+    # pre: I
+    while (P):
+        # I
+        T
+    # post: I and not P
+"""
+
+def quotient(n, d):
+    """
+    Divide n by d, integer division by repeated subtraction
+    n: dividend, d: divisor, q: quotient, r: remainder
+    The definition of integer division is: n == q*d + r and r < d
+    """
+    assert n >= 0 and d > 0        # function precondition
+    r = n    
+    q = 0
+    # assert n == q*d + r            # loop precondition 
+    while (r >= d):
+        # assert n == q*d + r        # loop invariant
+        r = r - d
+        q = q + 1
+    # assert n == q*d + r and r < d  # postcondition
+    return q
+
+print '9/3 %s' % quotient(9,3)
+print '8/3 %s' % quotient(8,3)
+print '3/3 %s' % quotient(3,3)
+print '2/3 %s' % quotient(2,3)
+
+# what happens if preconditions are violated?

class_inheritence_demo_1.py

@@ -0,0 +1,18 @@
+#! /usr/bin/python
+#
+#
+class A(object) :
+    x = 1.0
+    z = "spam!"
+
+class B(A) :
+    y = 2.7
+    z = "vikings"
+
+b = B( )
+
+print b.x, b.y, b.z
+
+a = A( )
+print a.x, a.z
+

comprehensions.py

@@ -0,0 +1,54 @@
+"""
+More list comprehension explanations and examples
+"""
+
+from route import puget
+from phones import phones, physics_dept
+
+print phones
+
+# use a loop to build up a list from a source, filter, and pattern:
+def physics_people():
+    names = []
+    for (name, phone) in phones: # phones is the source
+        if physics_dept(phone):  # physics_deptn(phone) is the filter
+            names.append(name)   # name is the pattern
+    return names
+
+print physics_people()
+
+# a list comprehension expresses the same thing in one expression
+#     [ pattern for     item      in source if filter ]
+print [ name    for (name, phone) in phones if physics_dept(phone) ]
+
+# the pattern can be elaborate
+print [ "%s's phone is %s" % (name,phone)
+        for (name, phone) in phones if physics_dept(phone) ]
+
+
+# note the difference between filter and conditional expr. in pattern
+
+def odd(i): return i%2 # 1 (true) when i is odd, 0 (false) when even
+
+print [ (i, 'odd') for i in range(5) if odd(i) ] # filter
+
+print [ (i, 'odd' if odd(i) else 'even') for i in range(5) ] # pattern
+
+
+# map pattern: apply a function to each element in the source
+
+print [ odd(i) for i in range(5) ]
+
+# built-in map function is an alternative
+
+print map(odd, range(5)) # 
+
+# filter pattern: use a filter (Boolean function) to select elements from source
+
+print [ i for i in range(5) if odd(i) ]
+
+# built-in filter function is an alternative
+
+print filter(odd, range(5)) 
+
+

docstrings.py

@@ -0,0 +1,19 @@
+#! /usr/bin/python
+#
+# Demonstrates how to document a very confusing function
+
+def confusion ( a, b, c ) :
+  """This is a very confusing function and you are wise to read the documentation
+for it.
+a is the first argument
+b is the second argument
+c is the third argument
+"""
+  return ( a,b,c )
+
+
+print help(confusion)
+print "*" * 30
+print confusion.__doc__
+
+

duck.py

@@ -0,0 +1,38 @@
+#! /usr/bin/env python
+#
+#
+# This program demonstrates "duck typing", which is a form of polymorphism
+# Week 8
+#
+class A(object) :
+    pass
+
+class C(object) :
+    pass
+
+class B(A):
+    def f(self, x):
+        print "I am in function f in class B, x is ", x
+
+class D(C):
+    def f(self, x):
+        print "I am in function f in class D, x is ", x
+
+
+b = B()
+d = D()
+
+b.f("instance b")
+d.f("instance d")
+
+def do_something(z):
+    print "In do_something",
+    y = 42   # A different universe of humor
+    z.f(y)
+   
+
+print "calling do_something with b", 
+do_something(b)
+print "calling do_something with d", 
+do_something(d)
+

file_exception.py

@@ -0,0 +1,26 @@
+#! /usr/bin/python
+#
+#
+opened = False
+while not opened :
+    filename = raw_input("Enter the filename ")
+    try :
+        f=file(filename,"r")
+    except IOError:
+        print "Unable to open "+filename
+        opened = False
+    else :
+        opened = True
+print "opened file "+filename+"for reading"
+
+for line in f :
+    try :
+        a_float_num = float(line)
+        print "Read %g" % a_float_num
+    except ValueError, e:
+        print "Read something that wasn't a floating point number\n%s" % e
+    except IOError:
+        print "An I/O error occurred - continuing"
+
+f.close()
+

intro_to_constructors.py

@@ -0,0 +1,11 @@
+#! /usr/bin/python
+#
+#
+class C(object) :
+    def __init__(self, x, y) :
+        self.x = x
+        self.y = y
+
+i = C("Kg","Slug")
+
+print i.x, i.y

intro_to_inheritence.py

@@ -0,0 +1,31 @@
+#! /usr/bin/python
+#
+#
+
+class A(object) :
+    def who_am_i(self):
+        print "I am in class A"
+    favorite_color = "Blue"
+    y = "Why?"
+
+class B(A) :
+    def who_am_i(self):
+        print "I am in class B"
+    favorite_color = "Green"
+    x = 42
+
+a = A()
+a.who_am_i()
+try :
+    print a.x
+except AttributeError, e :
+    print "WHOOPS!", e
+print a.y
+
+b = B()
+b.who_am_i()
+print b.x
+print b.y
+
+
+        

intro_to_methods.py

@@ -0,0 +1,14 @@
+#! /usr/bin/python
+#
+#
+# intro_to_methods.py
+#
+class F(object):
+    def f(self,x) :
+        self.x = x
+    def p(self) :
+        print self.x
+
+f = F()
+f.f(4)
+f.p()

intro_to_polymorphism.py

@@ -0,0 +1,35 @@
+#! /usr/bin/python
+#
+#
+import multiple_inheritence as mi
+
+def test_instance_of ( obj, obj_name, obj_class ) :
+    print obj_name, "is", "" if isinstance(obj, obj_class) else "not", \
+            "an instance of ", obj_class.__name__
+
+
+test_instance_of ( mi.e, 'e', mi.E )
+test_instance_of ( mi.a, 'a', mi.E )
+test_instance_of ( mi.e, 'e', mi.A )
+test_instance_of ( mi.b, 'b', mi.A )
+
+def dispatcher ( g ):
+    if isinstance(g, mi.A) :
+        print g.a
+    elif isinstance(g, mi.C) :
+        print g.c
+    else :
+        print g.e
+
+dispatcher ( mi.a )
+dispatcher ( mi.b )
+dispatcher ( mi.c )
+dispatcher ( mi.d )
+dispatcher ( mi.e )
+try :
+    dispatcher ( "gee" )
+except AttributeError, err :
+    print "WHOOPS!", err
+
+    
+    

multiple_inheritence.py

@@ -0,0 +1,43 @@
+#! /usr/bin/python
+#
+# Week 8
+class A(object) :
+    def who_am_i(self) :
+        print "Defined in A"
+    a = "eh?"
+
+class B(A) :
+    def who_am_i(self) :
+        print "Defined in B"
+    b = "bee"
+
+class C(object) :
+    def who_am_i(self) :
+        print "Defined in C"
+    c = "sea"
+
+class D(C) :
+    def who_am_i(self) :
+        print "Defined in D"
+    d = "Dee" # A river in Wales, see http://en.wikipedia.org/wiki/River_Dee_(Wales)
+
+class E(B,D) :
+    def who_am_i(self) :
+        print "Defined in E"
+    e = "ea."   # an abbreviation for "each"
+
+a = A()
+b = B()
+c = C()
+d = D()
+e = E()
+
+if __name__ == "__main__" :
+
+    a.who_am_i()
+    b.who_am_i()
+    c.who_am_i()
+    d.who_am_i()
+    e.who_am_i()
+
+    print e.a, e.b, e.c, e.d, e.e

nested.py

@@ -0,0 +1,30 @@
+"""
+print nested data structure with increasing indentation at each level
+
+  [ 'I....', 'II...', [ 'A...', 'B...' ], 'III....' ]
+
+is printed
+
+  I...
+  II...
+    A...
+    B...
+  III...
+"""
+
+outline = [ 'I....', 'II...', [ 'A...', [ 1, 2 ], 'B...' ], 'III....' ]
+
+def print_nested(spaces, data):
+    """
+    print nested data with increasing indentation at each level
+    data is list of non-lists (strings, numbers...) and/or nested lists
+    spaces is indentation, typically '' (empty string) at top level
+    """
+    if isinstance(data, list):
+        for item in data:
+            print_nested(spaces + '  ', item) # recursive calls
+    else:
+        print '%s%s' % (spaces, data)         # base case
+
+if __name__ == '__main__':
+    print_nested('', outline)