Python Generators vs Iterators

Iterators and generators have similar functionality, which might be confusing at times. This article compares iterators and generators in order to grasp the differences and clarify the ambiguity so that we can choose the right approach based on the circumstance.

Iterators in Python

Python objects that iterate through iterable objects are called Iterators. It is used to iterate over objects by returning one value at a time. Iterators are created by using the iter() function. The function next() is used to get the subsequent value from the iterator.

Example of Iterators in Python

nums = [1, 2, 3, 4]
obj = iter(nums)
print(next(obj))
print(next(obj))
print(next(obj))
print(next(obj))

Output

Generators in Python

A generator is a type of function that returns a generator object, which can return a sequence of values instead of a single result. The def keyword is commonly used to define generators. At least one yield statement is required in a generator.

Example of Generators in Python

def nums():
   for i in range(1, 5):
       yield i

obj = nums()
print(next(obj))
print(next(obj))
print(next(obj))
print(next(obj))

Output

Comparison Between Python Generators and Iterators

Implementation of Generators and Iterators

Iterators are created using classes whereas generators are created using functions.

Example of Iterators in Python

class Alphabets:

  def __iter__(self):
      self.val = 65
      return self

  def __next__(self):
      if self.val > 90:
          raise StopIteration
      temp = self.val
      self.val += 1
      return chr(temp)

my_letters = Alphabets()
my_iterator = iter(my_letters)
for letter in my_iterator:
   print(letter, end = " ")

Output

Example of Generators in Python

def Alphabets():

   for i in range(65, 91):
       yield chr(i)


my_letters = Alphabets()

for letter in my_letters:
   print(letter, end=" ")

Output

By looking at the above two code examples, we can understand that it is much easier to create generators than iterators

We can also notice that generators require a yield statement whereas iterators don’t.

Use of Local Variables by Generators and Iterators in python

Iterators don’t use any variables to iterate whereas generators use local variables and store the state of those variables whenever the loop is paused by the yield statement.

Example of Iterators in Python

li = ["A", "B", "C", "D"]
li_iter = iter(li)
print(next(li_iter))
print(next(li_iter))
print(next(li_iter))

Output

Example of Generators in Python

def gener():
   num = 1
   while True:
       yield num
       num += 1

obj = gener()
print(next(obj))
print(next(obj))
print(next(obj))

Output

Generators are Iterators in Python

In Python, all generators are iterators. This can be proved by the fact that generators are a subclass of iterators.

Example of issubclass() in Python

from collections.abc import Generator, Iterator

print(issubclass(Generator, Iterator))

Output

In the above code example, we can see that generator is a subclass of iterator and the iterator is a subclass of iterable.

Use-Cases of Generators and Iterators in python

Iterators are mostly used to convert iterables and iterate such iterables but generators are mostly used to create iterators and generate new values in a loop without disturbing the iteration of that loop.

Summary of Differences between Generators vs Iterators in Python

Iterators in Python	Generators in Python
Implemented using Class	Implemented using Function
No yield statement	Use yield statement
Use the iter() function	Do not use the iter() function.
Local variables are not used	Local variables are used
They are mostly used to convert iterables into iterators	They are mostly used to create iterators
All iterators are not generators	All generators are iterators

Python Interview Questions on Generators vs Iterators

Q1. Print the first three elements of a list using the iter() function.

Ans 1.

Complete code is as follows:

List = ["orange", "green", "black"]
list_iter = iter(List)
print(next(list_iter))
print(next(list_iter))
print(next(list_iter))

Output

Q2. Print the first three elements of a list using a generator.

Ans 2. Complete code is as follows:

def gener():
   List = ["orange", "green", "black"]
   for item in List:
       yield item

iter_obj = gener()
print(next(iter_obj))
print(next(iter_obj))
print(next(iter_obj))

Output

Q3. Create an iterator that prints the first four lower case alphabets.

Ans 3. Complete code is as follows:

def abcd():

   for i in range(97, 101):
       yield chr(i)

obj = abcd()
print(next(obj))
print(next(obj))
print(next(obj))
print(next(obj))

Output

Q4. Create an iterator using a class that prints the multiples of 5 infinitely.

Ans 4. Complete code is as follows:

class Multiples:

  def __iter__(self):
      self.val = 1
      return self

  def __next__(self):
      temp = self.val
      self.val += 1
      return temp*5

multiples5 = Multiples()
obj = iter(multiples5)

print(next(obj))
print(next(obj))
print(next(obj))

Output

Q5. Create an iterator using a function that prints the multiples of 5 infinitely.

Ans 5. Complete code is as follows:

def Multiples():
   i = 1
   while True:
       yield i*5
       i += 1

multiples5 = Multiples()
obj = multiples5
print(next(obj))
print(next(obj))
print(next(obj))

Output

Conclusion

In this article, we learned about the differences between iterators and generators. This helps us in choosing the best method to maximize the efficiency of our program. Furthermore, if you have any queries, please express them in the comments section.