Question

I’m trying to represent an array of evenly spaced floats, an arithmetic progression, starting at a0 and with elements a0, a0 + a1, a0 + 2a1, a0 + 3a1, …
This is what numpy’s arange() method does, but it seems to allocate memory for the whole array object and I’d like to do it using an iterator class which just stores a0, a1 and n (the total number of elements, which might be large).
Does anything that does this already exist in the standard Python packages?
I couldn’t find it so, ploughed ahead with:

class mylist():
    def __init__(self, n, a0, a1):
        self._n = n
        self._a0 = a0
        self._a1 = a1

    def __getitem__(self, i):
        if i < 0 or i >= self._n:
            raise IndexError
        return self._a0 + i * self._a1

    def __iter__(self):
        self._i = 0
        return self

    def next(self):
        if self._i >= self._n:
            raise StopIteration
        value = self.__getitem__(self._i)
        self._i += 1
        return value

Is this a sensible approach or am I revinventing the wheel?

Answer 1

Well, one thing that you are doing wrong is that it should be for i, x in enumerate(a): print i, x.

Also, I’d probably use a generator method instead of the hassle with the __iter__ and next() methods, especially because your solution wouldn’t allow you to iterate over the same mylist twice at the same time with two different iterators (as self._i is local to the class).

This is probably a better solution which gives you random access as well as an efficient iterator. The support for the in and len operators are thrown in as a bonus 🙂

class mylist(object):
    def __init__(self, n, a0, a1, eps=1e-8):
        self._n = n
        self._a0 = a0
        self._a1 = a1
        self._eps = eps

    def __contains__(self, x):
        y = float(x - self._a0) / self._a1
        return 0 <= int(y) < self._n and abs(y - int(y)) < self._eps

    def __getitem__(self, i):
        if 0 <= i < self._n:
            return self._a0 + i * self._a1
        raise IndexError

    def __iter__(self):
        current = self._a0
        for i in xrange(self._n):
             yield current
             current += self._a1

    def __len__(self):
        return self._n