Pooja Danu's Blog
Day 22: Generators and Iterators in Python

Day 22: Generators and Iterators in Python

Pooja Danu's photo
Pooja Danu
·

3 min read

Table of contents

Introduction

Welcome back to our Python journey! Today, we're learning iterators and generators. In Python programming, iterators and generators play a crucial role in facilitating efficient iteration over data sequences.These are powerful constructs that enable efficient iteration over data sequences, especially when dealing with large datasets.

Iteration is a fundamental concept in programming that refers to the process of repeatedly executing a set of instructions or accessing elements in a sequence, typically until a certain condition is met. In Python, iteration is commonly achieved using loops like for and while loops.

Iterators

An iterator is an object that enables iteration over a container, such as lists, tuples, or dictionaries. It provides a way to access elements one by one without needing to know the underlying structure of the data.

m_dict = {'a': 1, 'b': 2, 'c': 3}

#converting the dictionary to iterator
iterator = iter(m_dict)

#returnin keys one at a time
print(next(iterator))  # 'a'
print(next(iterator))  # 'b'
print(next(iterator))  # 'c'

  • The iter() function converts the dictionary m_dict into an iterator named iterator.

  • Using the next() function, we retrieve and print each key from the iterator one by one. Each call to next(iterator) advances the iterator to the next key in the dictionary, returning that key. The process continues until all keys have been retrieved and printed.

    🐍
    In Python, when iterating over a dictionary, it iterates over its keys by default. If you want to iterate over key-value pairs or values only, you would need to explicitly call .items() or .values() on the dictionary.

Generators

Generators are a special type of iterator that simplifies the process of creating iterators. They allow you to define a function that behaves like an iterator, using the yield keyword.

Generators are defined using a function with one or more yield statements. Each time the yield statement is executed, the function's state is saved, allowing it to resume from where it left off when called again.

def my_gen(data):
    for item in data:
        yield item

# Usage
my_list = ["Hello", 1 , "World"]
gen = my_gen(my_list)
for item in gen:
    print(item)

Generator Expressions

Generator expressions provide a more concise way to create generators. They have a syntax similar to list comprehensions but use parentheses instead of square brackets.

Creating generators using generator expression

Generator expressions provide a concise and efficient way to create generators in Python. They have a syntax similar to list comprehensions but use parentheses () instead of square brackets []. Here's how you can create generators using generator expressions:

#squares of numbers from 0 to 9
gen = (x ** 2 for x in range(10))

#iterating over the generator
for num in gen:
    print(num)

In this example:

  • We define a generator expression (x ** 2 for x in range(10)), which generates squares of numbers from 0 to 9.

  • The expression (x ** 2 for x in range(10)) creates a generator object without eagerly computing all the values upfront.

  • We can iterate over the generator gen using a for loop, and each iteration yields the next squared number from the generator expression.

Generator expressions are memory-efficient and suitable for generating large sequences of values on-the-fly without needing to store them all in memory at once. They are particularly useful in scenarios where you need to process large datasets or generate values dynamically.

Conclusion

Iterators, as objects designed for iteration, provide a structured way to traverse through data sequences. They require the implementation of methods like __iter__() and __next__() for custom iterators, offering control over the iteration process.

Generators, on the other hand, offer a more concise and flexible approach to creating iterators. By utilizing the yield keyword within functions or comprehensions, generators enable lazy evaluation, allowing values to be generated on-the-fly without the need to store them all in memory at once. This makes them particularly advantageous when dealing with large datasets or when simplicity and efficiency are paramount.

Python