diff options
| -rwxr-xr-x | Demo/classes/Range.py | 106 |
1 files changed, 64 insertions, 42 deletions
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() |