Add code for a range function that uses generators.
Cleaned up existing code by abstracting code to parse arguments. Also removed
any unneeded operations (such as calling 'int' on a division when using floor
division also works). Fixed a bug where the values returned by
OldStyleRange could be short by one value. Added more documentation.
Testing code also has a basic sanity check.
diff --git a/Demo/classes/Range.py b/Demo/classes/Range.py
index 68f3c61..3f1daae 100755
--- a/Demo/classes/Range.py
+++ b/Demo/classes/Range.py
@@ -1,71 +1,93 @@
-# Example of a generator: re-implement the built-in range function
-# without actually constructing the list of values. (It turns out
-# that the built-in function is about 20 times faster -- that's why
-# it's built-in. :-)
+"""Example of a generator: re-implement the built-in range function
+without actually constructing the list of values.
+OldStyleRange is coded in the way required to work in a 'for' loop before
+iterators were introduced into the language; using __getitem__ and __len__ .
-# Wrapper function to emulate the complicated range() arguments
+"""
+def handleargs(arglist):
+ """Take list of arguments and extract/create proper start, stop, and step
+ values and return in a tuple"""
+ try:
+ if len(arglist) == 1:
+ return 0, int(arglist[0]), 1
+ elif len(arglist) == 2:
+ return int(arglist[0]), int(arglist[1]), 1
+ elif len(arglist) == 3:
+ if arglist[2] == 0:
+ raise ValueError("step argument must not be zero")
+ return tuple(int(x) for x in arglist)
+ else:
+ raise TypeError("range() accepts 1-3 arguments, given", len(arglist))
+ except TypeError:
+ raise TypeError("range() arguments must be numbers or strings "
+ "representing numbers")
-def range(*a):
- if len(a) == 1:
- start, stop, step = 0, a[0], 1
- elif len(a) == 2:
- start, stop = a
- step = 1
- elif len(a) == 3:
- start, stop, step = a
- else:
- raise TypeError, 'range() needs 1-3 arguments'
- return Range(start, stop, step)
+def genrange(*a):
+ """Function to implement 'range' as a generator"""
+ start, stop, step = handleargs(a)
+ value = start
+ while value < stop:
+ yield value
+ value += step
+class oldrange:
+ """Class implementing a range object.
+ To the user the instances feel like immutable sequences
+ (and you can't concatenate or slice them)
-# Class implementing a range object.
-# To the user the instances feel like immutable sequences
-# (and you can't concatenate or slice them)
+ Done using the old way (pre-iterators; __len__ and __getitem__) to have an
+ object be used by a 'for' loop.
-class Range:
+ """
- # initialization -- should be called only by range() above
- def __init__(self, start, stop, step):
- if step == 0:
- raise ValueError, 'range() called with zero step'
- self.start = start
- self.stop = stop
- self.step = step
- self.len = max(0, int((self.stop - self.start) / self.step))
+ def __init__(self, *a):
+ """ Initialize start, stop, and step values along with calculating the
+ nubmer of values (what __len__ will return) in the range"""
+ self.start, self.stop, self.step = handleargs(a)
+ self.len = max(0, (self.stop - self.start) // self.step)
- # implement repr(x) and is also used by print x
def __repr__(self):
+ """implement repr(x) which is also used by print"""
return 'range(%r, %r, %r)' % (self.start, self.stop, self.step)
- # implement len(x)
def __len__(self):
+ """implement len(x)"""
return self.len
- # implement x[i]
def __getitem__(self, i):
- if 0 <= i < self.len:
+ """implement x[i]"""
+ if 0 <= i <= self.len:
return self.start + self.step * i
else:
raise IndexError, 'range[i] index out of range'
-# Small test program
-
def test():
import time, __builtin__
- print range(10), range(-10, 10), range(0, 10, 2)
- for i in range(100, -100, -10): print i,
- print
+ #Just a quick sanity check
+ correct_result = __builtin__.range(5, 100, 3)
+ oldrange_result = list(oldrange(5, 100, 3))
+ genrange_result = list(genrange(5, 100, 3))
+ if genrange_result != correct_result or oldrange_result != correct_result:
+ raise Exception("error in implementation:\ncorrect = %s"
+ "\nold-style = %s\ngenerator = %s" %
+ (correct_result, oldrange_result, genrange_result))
+ print "Timings for range(1000):"
t1 = time.time()
- for i in range(1000):
+ for i in oldrange(1000):
pass
t2 = time.time()
- for i in __builtin__.range(1000):
+ for i in genrange(1000):
pass
t3 = time.time()
- print t2-t1, 'sec (class)'
- print t3-t2, 'sec (built-in)'
+ for i in __builtin__.range(1000):
+ pass
+ t4 = time.time()
+ print t2-t1, 'sec (old-style class)'
+ print t3-t2, 'sec (generator)'
+ print t4-t3, 'sec (built-in)'
-test()
+if __name__ == '__main__':
+ test()