From fe63faaeebe89a95df6e0bb5cb169612c4966189 Mon Sep 17 00:00:00 2001 From: Raymond Hettinger Date: Wed, 10 Sep 2003 21:12:59 +0000 Subject: [PATCH] SF patch #803449: modernize demo scripts (Contributed by George Yoshida.) --- Demo/classes/Rev.py | 154 +++++++++++++++++++++++--------------------- Demo/classes/Vec.py | 30 +++------ 2 files changed, 90 insertions(+), 94 deletions(-) diff --git a/Demo/classes/Rev.py b/Demo/classes/Rev.py index 467bd578b71..7fd78e03ea5 100755 --- a/Demo/classes/Rev.py +++ b/Demo/classes/Rev.py @@ -1,89 +1,95 @@ -# A class which presents the reverse of a sequence without duplicating it. -# From: "Steven D. Majewski" +''' +A class which presents the reverse of a sequence without duplicating it. +From: "Steven D. Majewski" -# It works on mutable or inmutable sequences. -# -# >>> for c in Rev( 'Hello World!' ) : sys.stdout.write( c ) -# ... else: sys.stdout.write( '\n' ) -# ... -# !dlroW olleH -# -# The .forw is so you can use anonymous sequences in __init__, and still -# keep a reference the forward sequence. ) -# If you give it a non-anonymous mutable sequence, the reverse sequence -# will track the updated values. ( but not reassignment! - another -# good reason to use anonymous values in creating the sequence to avoid -# confusion. Maybe it should be change to copy input sequence to break -# the connection completely ? ) -# -# >>> nnn = range( 0, 3 ) -# >>> rnn = Rev( nnn ) -# >>> for n in rnn: print n -# ... -# 2 -# 1 -# 0 -# >>> for n in range( 4, 6 ): nnn.append( n ) # update nnn -# ... -# >>> for n in rnn: print n # prints reversed updated values -# ... -# 5 -# 4 -# 2 -# 1 -# 0 -# >>> nnn = nnn[1:-1] -# >>> nnn -# [1, 2, 4] -# >>> for n in rnn: print n # prints reversed values of old nnn -# ... -# 5 -# 4 -# 2 -# 1 -# 0 -# >>> -# -# WH = Rev( 'Hello World!' ) -# print WH.forw, WH.back -# nnn = Rev( range( 1, 10 ) ) -# print nnn.forw -# print nnn -# -# produces output: -# -# Hello World! !dlroW olleH -# [1, 2, 3, 4, 5, 6, 7, 8, 9] -# [9, 8, 7, 6, 5, 4, 3, 2, 1] -# -# >>>rrr = Rev( nnn ) -# >>>rrr -# <1, 2, 3, 4, 5, 6, 7, 8, 9> +It works on mutable or inmutable sequences. + +>>> chars = list(Rev('Hello World!')) +>>> print ''.join(chars) +!dlroW olleH + +The .forw is so you can use anonymous sequences in __init__, and still +keep a reference the forward sequence. ) +If you give it a non-anonymous mutable sequence, the reverse sequence +will track the updated values. ( but not reassignment! - another +good reason to use anonymous values in creating the sequence to avoid +confusion. Maybe it should be change to copy input sequence to break +the connection completely ? ) + +>>> nnn = range(3) +>>> rnn = Rev(nnn) +>>> for n in rnn: print n +... +2 +1 +0 +>>> for n in range(4, 6): nnn.append(n) # update nnn +... +>>> for n in rnn: print n # prints reversed updated values +... +5 +4 +2 +1 +0 +>>> nnn = nnn[1:-1] +>>> nnn +[1, 2, 4] +>>> for n in rnn: print n # prints reversed values of old nnn +... +5 +4 +2 +1 +0 + +# +>>> WH = Rev('Hello World!') +>>> print WH.forw, WH.back +Hello World! !dlroW olleH +>>> nnn = Rev(range(1, 10)) +>>> print nnn.forw +[1, 2, 3, 4, 5, 6, 7, 8, 9] +>>> print nnn.back +[9, 8, 7, 6, 5, 4, 3, 2, 1] + +>>> 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 __getitem__( self, j ): - return self.forw[ -( j + 1 ) ] - def __repr__( self ): + + def __len__(self): + return len(self.forw) + + 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 = [] - for item in self.back : - outstrs.append( str( item ) ) - return wrap[:1] + joinfields( outstrs, sep ) + wrap[-1:] + outstrs = [str(item) for item in self.back] + return wrap[:1] + sep.join(outstrs) + wrap[-1:] + +def _test(): + import doctest, Rev + return doctest.testmod(Rev) + +if __name__ == "__main__": + _test() diff --git a/Demo/classes/Vec.py b/Demo/classes/Vec.py index 0a56ddbe1fe..56cb839392a 100755 --- a/Demo/classes/Vec.py +++ b/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 = [] - for x in v: - self.v.append(x) - + self.v = list(v) def fromlist(self, v): - self.v = [] - if type(v) <> type([]): + if not isinstance(v, list): 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 @@ class Vec: def __getitem__(self, i): return self.v[i] - def __add__(a, b): + def __add__(self, other): # Element-wise addition - v = [] - for i in range(len(a)): - v.append(a[i] + b[i]) + v = map(lambda x, y: x+y, self, other) return Vec().fromlist(v) - def __sub__(a, b): + def __sub__(self, other): # Element-wise subtraction - v = [] - for i in range(len(a)): - v.append(a[i] - b[i]) + v = map(lambda x, y: x-y, self, other) return Vec().fromlist(v) def __mul__(self, scalar): # Multiply by scalar - v = [] - for i in range(len(self.v)): - v.append(self.v[i]*scalar) + v = map(lambda x: x*scalar, self.v) 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()