Python Generators

Spread the love

Python generators are a powerful and unique construct, enabling developers to perform lazy evaluation and build more memory-efficient applications. At their core, generators are a type of iterable, like lists or tuples. However, they don’t store their values in memory but instead generate them on the fly. This article aims to explore the intricacies of Python generators, including their creation, usage, and underlying principles.

1. What are Generators in Python?

Generators, in the context of Python, are a simple way of creating iterators. Instead of using the traditional methods (__iter__() and __next__()), a generator provides a way to iterate over values using a function containing the yield keyword.

The main difference between a generator and a regular function is that, while a regular function runs and terminates, returning its result, a generator “yields” a value, suspending its state, and can be resumed from that state to produce more values.

2. How to Create a Generator in Python?

Generators are special kinds of iterators in Python. Unlike lists or tuples, where all the elements are stored in memory, generators generate values on the fly and serve them one at a time. This lazy evaluation ensures that only one value is generated and in memory at any given moment, leading to significant memory savings for large datasets.

The yield Keyword:

The foundation of a generator is the yield keyword. Unlike the return statement, which terminates a function entirely, yield pauses the function saving all its states and later continues from there on successive calls.

Basic Generator:

Here’s a simple generator that yields numbers from 1 to 3:

def simple_generator():
    yield 1
    yield 2
    yield 3

When you call simple_generator(), you get a generator object:

>>> gen = simple_generator()
>>> type(gen)
<class 'generator'>

But note that upon calling the function, the function’s body does not execute. The function only starts its execution when next() is called on the generator.

>>> print(next(gen))
>>> print(next(gen))
>>> print(next(gen))

After yielding all its values, a generator function raises a StopIteration exception, which signals that all values have been generated:

>>> print(next(gen))

State Preservation:

One of the magical aspects of generators is their ability to preserve state. Once a value is yielded, the function’s state (including variable values, instruction pointer, internal stack, and exception handling) is saved. On the next invocation, the function resumes execution right after the last yield statement.

Consider a slightly complex generator:

def count_up_to(limit):
    count = 1
    while count <= limit:
        yield count
        count += 1

Here, count_up_to yields numbers incrementally up to a given limit. After each yield, the function’s state, especially the value of count, is preserved. So, every time next() is called on the generator, it remembers where it left off.

Multiple yield Points:

A generator function can have multiple points where it yields values, and it can also contain conditional logic, loops, or even other function calls.

For example:

def complex_generator():
    yield "start"
    for i in range(3):
        yield i
    yield "end"

Return with yield :

Starting from Python 3.3, generator functions can have a return statement with a value, which indicates the generator is done and will raise a StopIteration exception with that value. However, this is more often used with advanced patterns, especially when combined with yield from.

Creating a generator in Python involves crafting a function with the yield keyword. This special construct allows functions to yield a series of values over time, rather than returning a single value and terminating. The ability of generators to pause and resume their execution makes them a powerful tool for producing sequences of data in a memory-efficient manner.

3. yield vs. return

return :

  • Purpose: It’s used in a function to immediately exit and send a value back to the caller.
  • Behavior: The function’s state (like variable values) is lost once it exits. You can’t “resume” a function where a return left off.
  • Usage: Great for getting a single, final result from a function.

yield :

  • Purpose: It’s used in a special function called a generator to give a value back to the caller but with the intent of continuing from where it left off.
  • Behavior: The generator’s state is preserved. This means you can “pause” a generator and later “resume” it. Each time you ask for a value from a generator, it runs up to the next yield and then pauses again.
  • Usage: Excellent for sequences of values where you don’t want to produce all of them at once (like big data streams).

Explanation Using Code:

Using return:

def add_numbers(a, b):
    result = a + b
    return result

sum_result = add_numbers(3, 4)
print(sum_result)  # Outputs: 7

# If you call add_numbers again, it starts fresh without remembering the last call.

Using yield :

def countdown(n):
    while n > 0:
        yield n
        n -= 1

sequence = countdown(3)

# The function pauses at each yield, letting us retrieve values one at a time.
print(next(sequence))  # Outputs: 3
print(next(sequence))  # Outputs: 2
print(next(sequence))  # Outputs: 1

# If we try to continue, we've exhausted the generator.
# print(next(sequence))  # Would raise StopIteration

In Summary:

  • return: “Here’s your answer, and I’m done.”
  • yield: “Here’s one answer, let me know when you want the next.”

4. Generator Expressions

Generator expressions are a compact way to create generator objects. If you’re familiar with list comprehensions in Python, generator expressions are syntactically very similar, but with some key differences in their behavior and use cases.

Basic Syntax:

While list comprehensions use square brackets ([]), generator expressions use parentheses (()):

List Comprehension:

squared_list = [x * x for x in range(5)]

Generator Expression:

squared_gen = (x * x for x in range(5))

In the example above, squared_list is a list containing the squares of the numbers from 0 to 4, whereas squared_gen is a generator object that can produce these squares on-the-fly when iterated over.

Lazy Evaluation:

One of the most significant advantages of generator expressions is their lazy nature. Unlike list comprehensions, which compute and store all their results in memory immediately, generator expressions generate results one at a time and only when requested.

This means that squared_gen from the example above doesn’t compute any square values immediately after its declaration. The values are computed one-by-one as you iterate over the generator:

for value in squared_gen:



Memory Efficiency:

Given their lazy nature, generator expressions are much more memory-efficient than list comprehensions for large data sets. They produce values one at a time and don’t hold the entire result set in memory. This makes them ideal for processing large streams of data or working with infinite sequences.

For example, consider processing a range of 10 million numbers. A list comprehension would attempt to store all 10 million results in memory, while a generator expression would handle them one at a time, using negligible memory.

Use Cases:

Generator expressions are particularly handy when:

You have a large dataset: As previously mentioned, because of the memory efficiency, generator expressions can handle very large datasets without consuming much memory.

Chaining operations: Since generators produce an iterator, they can be easily chained with other Python functions that accept iterables, like sum(), max(), min(), etc.


total = sum(x * x for x in range(1000000))

You only need to process elements once: If you only need to iterate through your data once, then a generator might be more appropriate than generating a list.


  1. Single-use: Once a generator expression has been exhausted (i.e., all its items have been iterated over), it cannot be restarted or reused.
  2. No indexing: Unlike lists, you can’t access the items of a generator by index. Generators are purely iterative.

Generator expressions provide a concise and memory-efficient way to produce iterators. They leverage the power of generators and the familiar syntax of list comprehensions to offer a potent tool for various programming scenarios. Whether dealing with large data streams, chaining transformations, or simply aiming for cleaner, more Pythonic code, generator expressions are a valuable asset in a developer’s toolbox.

5. Advanced Generator Patterns

a. Sending Values to Generators

While the yield statement is commonly used to produce values from a generator, it can also be used as an expression to receive values sent from outside the generator.

When yield is used as an expression, it still pauses the function and yields a value to the outer world, but when the generator’s send() method is called, the yield expression returns the value that is sent.

Here’s a basic example to illustrate this concept:

def simple_generator():
    received = yield "Ready to receive"
    print(f"Received: {received}")

When this generator is invoked, it yields the string “Ready to receive”. Afterwards, you can send a value back into the generator, which will be captured by the received variable.

Using the send( ) Method:

To send a value to a generator, you employ the send() method. But there’s a nuance: Before sending any value, you must initially start the generator. This is typically done by calling next() first.

Here’s how to use the above simple_generator:

gen = simple_generator()

# Start the generator
print(next(gen))  # Outputs: "Ready to receive"

# Now, send a value back into the generator
gen.send("Hello from the outside!")


Ready to receive
Received: Hello from the outside!

Handling the End:

Once a generator function completes its execution (i.e., runs to completion or encounters a return statement), any attempt to send a value to it will raise a StopIteration exception. It’s crucial to handle this scenario, especially in more complex generator functions or co-routines.

The ability to send values into generators makes them a versatile tool in Python, going beyond simple iteration. By utilizing the yield keyword as an expression and leveraging the send() method, developers can create sophisticated data processing routines, co-routines, and much more, extending the boundaries of what’s possible with Python generators.

b. Generator Pipelines

Just like in an assembly line where each station performs a specific task and passes the result to the next station, generators can be connected in a sequence where each generator takes input, processes it, and then yields output to the next generator in line.


Let’s consider a scenario where we have a sequence of numbers, and we want to:

  1. Square the numbers.
  2. Filter out even results.
  3. Double the remaining values.

We can create a pipeline of three generators to perform these tasks:

# Generate numbers up to a limit
def generate_numbers(limit):
    for i in range(limit):
        yield i

# Square numbers
def square_numbers(numbers):
    for n in numbers:
        yield n * n

# Filter out even numbers
def filter_odd(numbers):
    for n in numbers:
        if n % 2 != 0:
            yield n

# Double the numbers
def double_numbers(numbers):
    for n in numbers:
        yield n * 2

Now, you can chain these generators to form a pipeline:

numbers = generate_numbers(5)
squared = square_numbers(numbers)
odds = filter_odd(squared)
doubled = double_numbers(odds)

for value in doubled:



Chaining Using Generator Expressions:

Often, for simple operations, using generator expressions can be more concise and readable:

numbers = (i for i in range(5))
squared = (n * n for n in numbers)
odds = (n for n in squared if n % 2 != 0)
doubled = (n * 2 for n in odds)

for value in doubled:



This code produces the same output as the previous example but is more compact.

Generator pipelines are a powerful pattern for data processing in Python. By chaining together multiple generators, one can build efficient, modular, and clear data processing workflows. This approach is especially beneficial for large datasets where memory usage is a concern. The flexibility of Python’s generator semantics, combined with the expressiveness of generator expressions, allows developers to handle a wide array of data processing tasks with ease and elegance.

c. yield from

The Motivation:

Before the introduction of yield from, if one wanted to yield values from a sub-generator (or any iterable, for that matter), they would typically use a loop:

def generator():
    for item in sub_generator():
        yield item

While this works, it adds extra boilerplate and can become cumbersome if there are nested generators or more complex delegation behaviors.

Basic Usage:

The yield from syntax simplifies the above code to:

def generator():
    yield from sub_generator()

With yield from, the generator function will yield each item produced by sub_generator() as if they were directly part of generator itself.


Imagine we have two generators: one producing numbers and another producing letters. If we want a third generator that produces values from both, we can use yield from:

def produce_numbers():
    for i in range(3):
        yield i

def produce_letters():
    for letter in "AB":
        yield letter

def combined_generator():
    yield from produce_numbers()
    yield from produce_letters()

for item in combined_generator():



Advantages Beyond Simplicity:

While yield from initially appears to be just a syntax simplification, it offers more benefits, especially when dealing with nested generators and coroutines:

  1. Exception Handling: yield from simplifies error propagation. Exceptions thrown in the sub-generator can be caught and handled in the delegating generator.
  2. Result Propagation: If the sub-generator returns a value using the return statement (introduced for generators in Python 3.3), this value can be captured by the delegating generator. The expression result = yield from sub_generator() would assign the return value of sub_generator to the variable result.
  3. Nested Generators: For more complex generator structures where there are multiple levels of nested generators, yield from can significantly simplify the code by avoiding nested loops to yield values from the deepest generators.

The yield from expression in Python provides a more concise and expressive way to delegate part of a generator’s operations to another generator or iterable. Going beyond mere syntactic sugar, it aids in the design of more complex, nested generator structures and coroutines, streamlining error and result propagation. Whether for simple delegation or intricate generator hierarchies, yield from is a powerful tool in the Python developer’s toolkit.

6. Conclusion

Python generators are an essential tool in a developer’s toolkit, offering a range of benefits from memory efficiency to more maintainable code. By understanding how to create and leverage generators, developers can write more performant and elegant Python code suitable for a variety of data-intensive tasks. Whether you’re processing vast amounts of data, handling files, or just want a more Pythonic way to create iterators, generators are the way to go!

Leave a Reply