"""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__ .

"""

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 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)

    Done using the old way (pre-iterators; __len__ and __getitem__) to have an

    object be used by a 'for' loop.

    """

    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)

    def __repr__(self):

        """implement repr(x) which is also used by print"""

        return 'range(%r, %r, %r)' % (self.start, self.stop, self.step)

    def __len__(self):

        """implement len(x)"""

        return self.len

    def __getitem__(self, i):

        """implement x[i]"""

        if 0 <= i <= self.len:

            return self.start + self.step * i

        else:

            raise IndexError, 'range[i] index out of range'

def test():

    import time, __builtin__

    #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 oldrange(1000):

        pass

    t2 = time.time()

    for i in genrange(1000):

        pass

    t3 = time.time()

    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)'

if __name__ == '__main__':

    test()