Basics of Iterators and Generators,Uses of iterators and generators in python. advantage of iterators and generators. difference between generators and iterators.

1. Click to add Title
e-Infochips Institute of Training Research and Academics Limited
Iterators and Generators
Prepared by:
Pranali Patel
Kalindi Vora

2. Agenda
• Iterators
• Iteration protocol
• Infinite iterators
• Generators
• Generator expressions
• Relationship between iterator and generator
• Advantages

3. Iterators
• An iterator is an object which allows a programmer to traverse
through all the elements of a collection, regardless of its
specific implementation.
• An iterator is an object which implements the iterator
protocol.
• The iterator protocol consists of two methods:
• The __iter__() method which must return the iterator object
and next() method which returns the next element of sequence.

4. Examples
We use for statement for looping over a list.
>>> for i in [1, 2, 3, 4]:
... print i,
...
1
2
3
4

5. Examples
If we use it with a string, it loops over its characters.
>>> for c in "python":
... print c
...
p
y
t
h
o
n

6. Examples
If we use it with a dictionary, it loops over its keys.
>>> for k in {"x": 1, "y": 2}:
... print k
...
y
x

7. Examples
If we use it with a file, it loops over lines of the file.
>>> for line in open("a.txt"):
... print line,
...
first line
second line

8. Iteration protocol
• The built-in function iter takes an iterable object and returns an
iterator.
• Each time we call the next method on the iterator gives us the
next element.
• If there are no more elements, it raises a StopIteration.

9. Examples
>>> x = iter([1, 2, 3])
>>> x
<listiterator object at 0x1004ca850>
>>> x.next()
1
>>> x.next()
2
>>> x.next()
3
>>> x.next()
Traceback (most recent call last):
File <stdin>, line 1, in <module>
StopIteration

10. Examples
class yrange:
def __init__(self, n):
self.i = 0
self.n = n
def __iter__(self):
return self
def next(self):
if self.i < self.n:
i = self.i
self.i += 1
return i
else:
raise StopIteration()
Iterators are implemented as classes.
Here is an iterator that works like built-
in xrange function.

11. Examples
• The __iter__ method is what makes an object iterable.
• Behind the scenes, the iter function calls __iter__ method on
the given object.
• The return value of __iter__ is an iterator.
• It should have a next method and raise StopIteration when there
are no more elements.

12. Examples
>>> y = yrange(3)
>>> y.next()
0
>>> y.next()
1
>>> y.next()
2
>>> y.next()
Traceback (most recent call last):
File <stdin>, line 1, in <module>
File <stdin>, line 14, in next
StopIteration

13. Infinite Iterators
• It is not necessary that the item in an iterator object has to
exhaust.
• There can be infinite iterators (which never ends).
• We must be careful when handling such iterator.

14. Examples
>>> a = iter(InfIter())
>>> next(a)
1
>>> next(a)
3
>>> next(a)
5
>>> next(a)
7
class InfIter:
"""Infinite iterator to return all odd numbers"""
def __iter__(self):
self.num = 1
return self
def __next__(self):
num = self.num
self.num += 2
return num

15. Generators
• Generators simplifies creation of iterators.
• A generator is a function that produces a sequence of results
instead of a single value.
• A generator is a special routine that can be used to control the
iteration behaviour of a loop.
• A generator is similar to a function returning an array.
• A generator has parameters, it can be called and it generates a
sequence of result.
• But unlike functions, which return a whole array, a
generator yields one value at a time.

16. Generators
Generators in Python:
• Are defined with the def keyword
• Use the yield keyword
• May use several yield keywords
• Return an iterator

17. Examples
def yrange(n):
i = 0
while i < n:
yield i
i += 1
Each time the yield statement is executed the function
generates a new value.

18. Examples
>>> y = yrange(3)
>>> y
<generator object yrange at 0x401f30>
>>> y.next()
0
>>> y.next()
1
>>> y.next()
2
>>> y.next()
Traceback (most recent call last):
File <stdin>, line 1, in <module>
StopIteration

19. Examples
• A generator is also an iterator.
• The word “generator” is confusingly used to mean both the
function that generates and what it generates.
• When a generator function is called, it returns a generator
object without even beginning execution of the function.
• When next method is called for the first time, the function
starts executing until it reaches yield statement.
• The yielded value is returned by the next call.

20. Examples
>>> def foo():
... print "begin"
... for i in range(3):
... print "before yield", i
... yield i
... print "after yield", i
... print "end"
... >>> f = foo()
>>> f.next()
begin before yield 0
0
>>> f.next()
after yield 0
before yield 1
1
>>> f.next()
after yield 1
before yield 2
2
>>> f.next()
after yield 2
end
Traceback (most recent call last):
File <stdin>, line 1, in <module>
StopIteration
>>>

21. Examples
• Lets say we want to write a program that takes a list of filenames as
arguments and prints contents of all those files.
• The traditional way to implement it is:
def cat(filenames):
for f in filenames:
for line in open(f):
print line,

22. Examples
• Now, lets say we want to print only the line which has a
particular substring.
def grep(pattern, filenames):
for f in filenames:
for line in open(f):
if pattern in line:
print line,
• Both these programs have lot of code in common. It is hard to
move the common part to a function. But with generators makes
it possible to do it.

23. Examples
def readfiles(filenames):
for f in filenames:
for line in open(f):
yield line
def grep(pattern, lines):
return (line for line in lines if
pattern in line)
def printlines(lines):
for line in lines:
print line,
def main(pattern, filenames):
lines = readfiles(filenames)
lines = grep(pattern, lines)
printlines(lines)

24. Generator expressions
• There are two types of generators in Python:
generator functions and generator expressions.
• A generator function is any function in which the keyword yield
appears in its body.
• The appearance of the keyword yield is enough to make the
function a generator function.
• The other type of generators are the generator equivalent of a
list comprehension. Its syntax is really elegant for a limited use
case.

25. Examples
>>> numbers = [1, 2, 3, 4, 5, 6]
>>> [x * x for x in numbers]
[1, 4, 9, 16, 25, 36]
You could do the same thing with a set comprehension:
>>> {x * x for x in numbers}
{1, 4, 36, 9, 16, 25}
Or a dict comprehension:
>>> {x: x * x for x in numbers}
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36}

26. Relationship between Generator and Iterator

27. Advantages
• Cleaner code
• Iterators can work with infinite sequences
• Iterators save resources
• Generator allows to write streaming code with fewer
intermediate variables and data structures.
• Memory and CPU efficient

28. THANK YOU