SF patch #803449: modernize demo scripts

(Contributed by George Yoshida.)

Demo/classes/Rev.py

@@ -1,89 +1,95 @@
-# A class which presents the reverse of a sequence without duplicating it.
+'''
-# From: "Steven D. Majewski" <sdm7g@elvis.med.virginia.edu>
+A class which presents the reverse of a sequence without duplicating it.
+From: "Steven D. Majewski" <sdm7g@elvis.med.virginia.edu>
 
-# It works on mutable or inmutable sequences.
+It works on mutable or inmutable sequences.
-#
+
-# >>> for c in Rev( 'Hello World!' ) : sys.stdout.write( c )
+>>> chars = list(Rev('Hello World!'))
-# ... else: sys.stdout.write( '\n' )
+>>> print ''.join(chars)
-# ...
+!dlroW olleH
-# !dlroW olleH
+
-#
+The .forw is so you can use anonymous sequences in __init__, and still
-# The .forw is so you can use anonymous sequences in __init__, and still
+keep a reference the forward sequence. )
-# keep a reference the forward sequence. )
+If you give it a non-anonymous mutable sequence, the reverse sequence
-# If you give it a non-anonymous mutable sequence, the reverse sequence
+will track the updated values. ( but not reassignment! - another
-# will track the updated values. ( but not reassignment! - another
+good reason to use anonymous values in creating the sequence to avoid
-# good reason to use anonymous values in creating the sequence to avoid
+confusion. Maybe it should be change to copy input sequence to break
-# confusion. Maybe it should be change to copy input sequence to break
+the connection completely ? )
-# the connection completely ? )
+
-#
+>>> nnn = range(3)
-# >>> nnn = range( 0, 3 )
+>>> rnn = Rev(nnn)
-# >>> rnn = Rev( nnn )
+>>> for n in rnn: print n
-# >>> for n in rnn: print n
+...
-# ...
+2
-# 2
+1
-# 1
+0
-# 0
+>>> for n in range(4, 6): nnn.append(n)   # update nnn
-# >>> for n in range( 4, 6 ): nnn.append( n )   # update nnn
+...
-# ...
+>>> for n in rnn: print n     # prints reversed updated values
-# >>> for n in rnn: print n     # prints reversed updated values
+...
-# ...
+5
-# 5
+4
-# 4
+2
-# 2
+1
-# 1
+0
-# 0
+>>> nnn = nnn[1:-1]
-# >>> nnn = nnn[1:-1]
+>>> nnn
-# >>> nnn
+[1, 2, 4]
-# [1, 2, 4]
+>>> for n in rnn: print n     # prints reversed values of old nnn
-# >>> for n in rnn: print n     # prints reversed values of old nnn
+...
-# ...
+5
-# 5
+4
-# 4
+2
-# 2
+1
-# 1
+0
-# 0
+
-# >>>
+#
-#
+>>> WH = Rev('Hello World!')
-# WH = Rev( 'Hello World!' )
+>>> print WH.forw, WH.back
-# print WH.forw, WH.back
+Hello World! !dlroW olleH
-# nnn = Rev( range( 1, 10 ) )
+>>> nnn = Rev(range(1, 10))
-# print nnn.forw
+>>> print nnn.forw
-# print nnn
+[1, 2, 3, 4, 5, 6, 7, 8, 9]
-#
+>>> print nnn.back
-# produces output:
+[9, 8, 7, 6, 5, 4, 3, 2, 1]
-#
+
-# Hello World! !dlroW olleH
+>>> rrr = Rev(nnn)
-# [1, 2, 3, 4, 5, 6, 7, 8, 9]
+>>> rrr
-# [9, 8, 7, 6, 5, 4, 3, 2, 1]
+<1, 2, 3, 4, 5, 6, 7, 8, 9>
-#
+
-# >>>rrr = Rev( nnn )
+'''
-# >>>rrr
-# <1, 2, 3, 4, 5, 6, 7, 8, 9>
 
-from string import joinfields
 class Rev:
-    def __init__( self, seq ):
+    def __init__(self, seq):
         self.forw = seq
         self.back = self
-    def __len__( self ):
+
-        return len( self.forw )
+    def __len__(self):
-    def __getitem__( self, j ):
+        return len(self.forw)
-        return self.forw[ -( j + 1 ) ]
+
-    def __repr__( self ):
+    def __getitem__(self, j):
+        return self.forw[-(j + 1)]
+
+    def __repr__(self):
         seq = self.forw
-        if type(seq) == type( [] ) :
+        if isinstance(seq, list):
             wrap = '[]'
             sep = ', '
-        elif type(seq) == type( () ) :
+        elif isinstance(seq, tuple):
             wrap = '()'
             sep = ', '
-        elif type(seq) == type( '' ) :
+        elif isinstance(seq, str):
             wrap = ''
             sep = ''
         else:
             wrap = '<>'
             sep = ', '
-        outstrs = []
+        outstrs = [str(item) for item in self.back]
-        for item in self.back :
+        return wrap[:1] + sep.join(outstrs) + wrap[-1:]
-            outstrs.append( str( item ) )
+
-        return wrap[:1] + joinfields( outstrs, sep ) + wrap[-1:]
+def _test():
+    import doctest, Rev
+    return doctest.testmod(Rev)
+
+if __name__ == "__main__":
+    _test()

Demo/classes/Vec.py

@@ -2,27 +2,22 @@
 
 
 def vec(*v):
-    return apply(Vec, v)
+    return Vec(*v)
 
 
 class Vec:
 
     def __init__(self, *v):
-        self.v = []
+        self.v = list(v)
-        for x in v:
-            self.v.append(x)
-
 
     def fromlist(self, v):
-        self.v = []
+        if not isinstance(v, list):
-        if type(v) <> type([]):
             raise TypeError
         self.v = v[:]
         return self
 
-
     def __repr__(self):
-        return 'vec(' + `self.v`[1:-1] + ')'
+        return 'vec(' + repr(self.v)[1:-1] + ')'
 
     def __len__(self):
         return len(self.v)
@@ -30,25 +25,19 @@ def __len__(self):
     def __getitem__(self, i):
         return self.v[i]
 
-    def __add__(a, b):
+    def __add__(self, other):
         # Element-wise addition
-        v = []
+        v = map(lambda x, y: x+y, self, other)
-        for i in range(len(a)):
-            v.append(a[i] + b[i])
         return Vec().fromlist(v)
 
-    def __sub__(a, b):
+    def __sub__(self, other):
         # Element-wise subtraction
-        v = []
+        v = map(lambda x, y: x-y, self, other)
-        for i in range(len(a)):
-            v.append(a[i] - b[i])
         return Vec().fromlist(v)
 
     def __mul__(self, scalar):
         # Multiply by scalar
-        v = []
+        v = map(lambda x: x*scalar, self.v)
-        for i in range(len(self.v)):
-            v.append(self.v[i]*scalar)
         return Vec().fromlist(v)
 
 
@@ -59,6 +48,7 @@ def test():
     print a
     print b
     print a+b
+    print a-b
     print a*3.0
 
 test()