Creating an Iterator in Python
An "iterable" object in Python is one that we can iterate on it using a for loop. For example a list is "iterable" because we can iterate over its elements:
from __future__ import print_function names = ['Foo', 'Bar', 'Zorg'] for name in names: print(name)
Foo Bar Zorg
A string is also iterable because we can iterate over its characters:
from __future__ import print_function name = 'Foo Bar' for c in name: print(c)
F o o
B a r
A much more interesting example might be the use of xrange that creates an iterable object without taking up precious memory.
from __future__ import print_function import sys r = xrange(10000) for v in r: pass print(sys.getsizeof(r)) # 40
See range vs. xrange for a longer discussion on the topic.
Why to create your own iterator?
Before showing how to create your own iterator, let's try to figure out why and when would we want to do that?
In all the following case you could achieve the same result without using a real iterator object, but creating an iterator object will allow us to use a simple for-loop which will make our code look more similar to other code written in Python.
That case can already benefit from an iterator, but what if you work with a bunch of people researching the Fibonacci series. Each one of them will want to go over the Fibonacci series and stop at some condition. We just don't know what condition will be.
So we can create an iterator object that will be able to iterate over the Fibonacci numbers until the code of the researcher says it to stop or until power runs out of the computer.
Create an iterable
An iterable object can be created by any class. It only needs 3 things: 2 required and one optional.
The two required are:
- A method called __iter__ that will return the instance object. A very simple piece of code.
- A method called next that will return the next value of the iterable.
These two will create an unbounded or unlimited iterator.
Optionally you might want your iterator to stop at a certain point by itself. You can achieve that by having the next method raise a StopIteration exception.
In this example the constructor of the Fibonacci class is expected to receive a number, the number of elements we would like to iterate over. It does not calculate all the numbers at once, instead it computes the next element every time the next method is called which is done internally by the for loop.
When the iteration counter reaches the limit originally provided, itraises a StopIteration exception which is caught by the for loop (again without us doing anything special) and terminates the for-loop.
#!/usr/bin/env python from __future__ import print_function class Fibonacci(object): def __init__(self, limit): self.limit = limit self.count = 0 self.values =  def __iter__(self): return self def next(self): self.count += 1 if self.count > self.limit: raise StopIteration if len(self.values) < 2: self.values.append(1) else: self.values = [self.values[-1], self.values[-1] + self.values[-2]] return self.values[-1] for f in Fibonacci(5): print(f) if f % 17 == 0: print('found') break print('-----') for f in Fibonacci(15): print(f) if f % 17 == 0: print('found') break
In the next solution we don't need to provide a limit, our iterator never raises an exception, and therefor it never stops by itself. We assume that the user who uses this iterafor will have some code in place that will stop the iteration by calling break on some condition. This condition can be related to the series itself, (e.g. we have iterated over 100 elements), or it can be totally unrelated. (e.g. some user input. Elapsed time. Day of the week. Etc.)
#!/usr/bin/env python from __future__ import print_function class Fibonacci(object): def __init__(self): self.values =  def __iter__(self): return self def next(self): if len(self.values) < 2: self.values.append(1) else: self.values = [self.values[-1], self.values[-1] + self.values[-2]] return self.values[-1] for f in Fibonacci(): if f % 17 == 0: print(f) break if f > 10000: break