Python Generators: Efficient Iteration with Yield

By Alessandro D.P.3 min readFebruary 15, 2026

Understanding Generators

Generators are defined using functions but yield values instead of returning them. When a generator function is called, it returns a generator object without starting execution immediately. The function's code runs only when the generator's __next__() method is invoked, either explicitly or implicitly (e.g., in a loop).

Basic Example of a Generator

Here’s a simple example of a generator that produces a sequence of numbers:

def number_generator(n):
    for i in range(n):
        yield i

# Using the generator
gen = number_generator(5)
for number in gen:
    print(number)

Output:

In this example, number_generator yields numbers from 0 to n-1. Each call to next(gen) retrieves the next number, and the generator retains its state between calls.

Advantages of Generators

Generators offer several advantages over traditional lists and iterators:

Memory Efficiency: Generators yield one item at a time and do not store the entire sequence in memory, making them suitable for large datasets.
Lazy Evaluation: Values are computed only when needed, which can lead to performance improvements in certain scenarios.
Simplified Code: Generators can simplify the code structure, especially for complex iterations.

Practical Use Cases for Generators

1. Reading Large Files

Generators are particularly useful for reading large files line by line without loading the entire file into memory.

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

# Using the generator to read a file
for line in read_large_file('large_file.txt'):
    print(line)

2. Infinite Sequences

Generators can be used to create infinite sequences, such as Fibonacci numbers, which can be computed on-the-fly.

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

# Using the Fibonacci generator
fib_gen = fibonacci()
for _ in range(10):
    print(next(fib_gen))

Output:

Best Practices for Using Generators

Use Generators for Large Data: When working with large datasets, prefer generators to avoid memory overload.
Avoid Side Effects: Generators should not modify global state or rely on external variables. Keep them self-contained.
Handle Exceptions: Use try-except blocks within generators to manage exceptions gracefully.

Comparison: Generators vs. Lists

Feature	Generators	Lists
Memory Usage	Low (one value at a time)	High (stores all values)
Performance	Faster for large data	Slower for large data
Syntax	`yield`	`[]`
Reusability	Single-use	Can be reused

Conclusion

Generators are a powerful feature in Python that enhance the efficiency of your code, particularly when dealing with large data sets or infinite sequences. By leveraging the yield statement, you can create simple yet effective iterators that conserve memory and improve performance.