Generators in Python

Generators in Python are a powerful tool that can be used to create iterators over large or infinite sequences of data or values. Unlike lists or arrays, generators do not store all of the values in memory at once, which can be very useful when working with large data sets or infinite sequences.

What are Python Generators?

Generators are a type of iterable, like lists or tuples, but they do not store their contents in memory. Instead, they generate the items on the fly as you iterate over them, using a function that yields items instead of returning them. This “lazy evaluation” allows generators to be highly memory-efficient, especially useful when dealing with large data sets.

‘yield’ keyword

Generators are created using the yield keyword. A generator function is defined like a normal function but uses the yield keyword instead of return. When a generator function is called, it returns an iterator or generator object and does not execute the function immediately. This iterator object can then be used to iterate over the values in the generator.

The yield keyword is similar to a return statement used for returning values or objects in Python. However, there is a slight difference. The yield statement returns a generator object to the one who calls the function which contains yield, instead of simply returning a value.


A generator object is a special type of iterator in Python. It is created by 
a generator function, which is a function that uses the yield keyword instead 
of the return keyword. When a generator function is called, it returns a 
generator object. This object can then be used to iterate over the values 
that the generator function yields.

Generator objects are useful for a number of reasons. First, they can be used 
to create iterators over large or infinite sequences of data without 
having to store all of the data in memory at once. Second, they can be 
used to create lazy iterators, which means that the values in the 
sequence are not generated until they are actually needed. This can be useful 
for performance reasons, especially when working with 
large or infinite sequences of data.


The yield keyword is used to pause the execution of the generator function and return a value. The generator function will then resume execution when the next value is requested. The yield keyword is a powerful tool that can be used to create efficient and memory-saving code. It is often used in conjunction with iterators and for loops.

Here is an example of a generator function:

def my_generator(max_num):
  for num in range(max_num):
    yield num

This function will generate the numbers from 0 to max_num-1, one at a time. To use the generator, we can call it and then iterate over the returned iterator object:

generator = my_generator(10)
for i in generator:

This will print the numbers from 0 to 9 to the console.

Generators can be used in a variety of ways. For example, they can be used to:

  • Create infinite sequences of values.
  • Generate values on demand, without having to store them all in memory at once.
  • Implement lazy evaluation.
  • Create pipelines of data processing operations.
Use Cases for Generators

Generators can be utilised in various programming requirements.

Handling Large Data Sets

Generators are ideal for processing large data files, such as logs or large datasets, without loading the entire file into memory.

def read_large_file(file_name):
    with open(file_name, 'r') as file:
        for line in file:
            yield line

This function reads a file line by line, yielding each line one at a time. This way, it only holds one line in memory at any time, regardless of the size of the file.

Infinite Sequences

Generators are perfect for generating infinite sequences since they can produce a stream of data indefinitely.

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

This generator function produces an infinite sequence of Fibonacci numbers, yielding one number at a time.

Data Pipelines

Generators can be used to create data pipelines, where a series of transformations are applied to data efficiently.

def transform_data(data):
    for item in data:
        yield process(item)

def filter_data(data):
    for item in data:
        if condition(item):
            yield item

# Use the pipeline
data = read_large_file("data.csv")
data = transform_data(data)
data = filter_data(data)

for item in data:

This example demonstrates a pipeline where data is read, transformed, and filtered using generators, keeping memory usage low and processing efficient.

Yielding a function call

You can yield the result of a function call within a generator function in Python. This allows you to create generators that utilize functions for calculations or data processing, and yield the results on demand. Consider these examples.

Example 1

def square(x):
  """Squares a number."""
  return x * x

def data_processor():
  """Generator that yields squares of elements in a list."""
  data = [1, 2, 3, 4]
  for item in data:
    # Yield the result of calling the square function with the current item
    yield square(item)

# Using the generator
for processed_item in data_processor():



Example 2

Conditional Yielding with Function Calls.

def is_even(x):
  """Checks if a number is even."""
  return x % 2 == 0

def data_filter(data):
  """Generator that yields even numbers from a list using a function call."""
  for item in data:
    if is_even(item):  # Call function to check for even
      yield item

# Using the generator
data = [1, 2, 3, 4, 5, 6]
for even_item in data_filter(data):



Stateful Co-routines

Generators can also be used to simulate co-routines which maintain state between executions.

def task_manager():
    while True:
        task = yield
        print(f"Handling task {task}")

manager = task_manager()
next(manager)  # Start the generator
manager.send("task 1")
manager.send("task 2")


Handling task task 1
Handling task task 2

f"..." syntax defines an f-string, a special type of string literal introduced in Python 3.6. It allows you to embed expressions directly within curly braces {} inside the string.
The while True loop in the task_manager function allows it to continuously listen for incoming tasks using the yield statement. This ensures that the function remains active and ready to handle tasks indefinitely until it is explicitly terminated. If you remove the while True loop, the function task_manager will execute only once and then stop.

This generator acts as a task manager, handling tasks sent to it one at a time and maintaining its state across calls. This behaviour otherwise would require object-oriented programming to maintain state across function calls. The key aspect of generators that you’d need to replicate is their ability to pause execution and maintain state between those pauses.

However, it is important to note that Generators in Python are inherently synchronous. They rely on a single thread of execution and process tasks one after another. When you send a task using .send(), the generator pauses at the yield statement and waits for it to be completed before moving on to the next task. This pausing happens within the same thread. The code waits for each yield to be processed before moving on. In general, Python generators rely on a single thread of execution and process elements sequentially.

Python generators are a powerful tool for creating efficient and clean code, especially in scenarios involving large data sets, streaming data, or when a sequence needs to be generated. Their ability to produce items lazily makes them incredibly useful for reducing memory overhead, creating data pipelines, and handling infinite sequences or stateful operations dynamically.

Leave a Reply

Your email address will not be published. Required fields are marked *