Generators

Introduction

In the previous lesson, you built an iterator by hand using a class with __iter__() and __next__(). It worked, but it took quite a bit of boilerplate code. Generators give you the exact same behavior — an object that produces values one at a time — with a fraction of the code.

Generators are one of Python's most elegant features. They let you describe a sequence of values using ordinary-looking function code, while Python automatically handles pausing, resuming, and remembering state for you.

What is a Generator?

A generator is a special kind of iterator that you create using a function containing the yield keyword instead of return. Calling a generator function does not run its code immediately — instead, it returns a generator object that follows the iterator protocol from the previous lesson.

Generator Functions and yield

A generator function looks just like a normal function, except it uses yield to produce a value instead of return. Each time yield runs, it hands a value back to whoever is consuming the generator, and the function's execution freezes right there.

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


counter = count_up_to(3)
print(type(counter))

print(next(counter))
print(next(counter))
print(next(counter))

<class 'generator'>
1
2
3

Notice that calling count_up_to(3) does not print anything by itself — it just creates a generator object. The code inside the function only runs as values are pulled out, one yield at a time, using next().

for number in count_up_to(5):
    print(number)

1
2
3
4
5

How a Generator Pauses and Resumes

The key superpower of yield is that it remembers everything: local variables, the current position in the loop, and the point of execution. When next() is called again, the function continues right after the yield statement, as if it had never stopped.

def demo():
    print("Starting")
    yield 1
    print("Resumed after first yield")
    yield 2
    print("Resumed after second yield")
    yield 3


gen = demo()
print(next(gen))
print(next(gen))
print(next(gen))

Starting
1
Resumed after first yield
2
Resumed after second yield
3

This is very different from a regular function, which runs completely from top to bottom every single time it is called and forgets everything the moment it returns.

Why Generators Are Memory-Efficient

A regular function that builds and returns a full list must construct every single value in memory before handing anything back. A generator produces exactly one value at a time, uses a small constant amount of memory, and never needs to store the whole sequence.

def squares_list(n):
    result = []
    for i in range(n):
        result.append(i * i)
    return result  # builds the ENTIRE list in memory


def squares_generator(n):
    for i in range(n):
        yield i * i  # produces ONE value at a time


import sys
list_version = squares_list(1000000)
gen_version = squares_generator(1000000)

print(sys.getsizeof(list_version), "bytes")
print(sys.getsizeof(gen_version), "bytes")

8448728 bytes
112 bytes

Generator Expressions

Just like list comprehensions have a compact syntax, generators have their own compact form called a generator expression. It looks almost identical to a list comprehension, but uses parentheses () instead of square brackets [].

list_comprehension = [x * x for x in range(5)]
generator_expression = (x * x for x in range(5))

print(list_comprehension)
print(generator_expression)

print(list(generator_expression))

[0, 1, 4, 9, 16]
<generator object <genexpr> at 0x000001A2B3C4D5E0>
[0, 1, 4, 9, 16]

The list comprehension immediately builds and stores all five values. The generator expression builds nothing yet — it only creates a generator object that will compute each value on demand, the same way a generator function does.

A Practical Example: An Infinite Sequence

Because generators produce values lazily, they can represent sequences that are extremely large — or even infinite — without ever running out of memory. This would be impossible with a regular list.

def infinite_counter(start=1):
    number = start
    while True:
        yield number
        number += 1


counter = infinite_counter()

for _ in range(5):
    print(next(counter))

1
2
3
4
5

The while True loop never actually finishes — but that is fine, because the generator only computes the next number when it is asked for one. You control how many values you take, using a for loop with a limit, itertools.islice, or simply calling next() as many times as you need.

Converting a Generator to a List

Sometimes you genuinely need all the values at once — for example, to sort them, index into them, or loop over them multiple times. In that case, you can pass a (finite!) generator into list() to collect every value into a real list.

def even_numbers(limit):
    for n in range(limit):
        if n % 2 == 0:
            yield n


evens = list(even_numbers(10))
print(evens)
print(len(evens))

[0, 2, 4, 6, 8]
5

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Generators let you write code that produces sequences of values lazily, using the same simple function syntax you already know, plus the yield keyword. They avoid the memory cost of building huge lists, and they can even represent infinite sequences safely.

In this lesson, you learned how generator functions work, how they pause and resume, how generator expressions compare to list comprehensions, and when to convert a generator into a list. Next, you will learn about decorators, which let you modify the behavior of functions without changing their code.