How Do Nested Comprehensions Work?

A nested comprehension is a comprehension whose expression or clauses contain another comprehension. The classic shape is a grid.

# A 3x3 grid built from two loops
grid = [[row * 3 + col for col in range(3)] for row in range(3)]
print(grid)
# [[0, 1, 2], [3, 4, 5], [6, 7, 8]]

# Flatten a grid back into one list
flat = [value for row in grid for value in row]
print(flat)
# [0, 1, 2, 3, 4, 5, 6, 7, 8]

# A dictionary keyed by row index
table = {row: [col for col in range(3)] for row in range(3)}
print(table)
# {0: [0, 1, 2], 1: [0, 1, 2], 2: [0, 1, 2]}

The grid comprehension has two for clauses, and the leftmost is the outermost loop — the same nesting order as nested for statements. The row clause runs three times, and for each row the column clause runs three times, producing nine values.

The flattening comprehension reads the same way: the outer clause walks the rows and the inner clause walks the values within each row, so the output is in row order.

The dictionary version shows that the nested comprehension can produce any container, not just a list — the outer braces make it a dict and the inner square brackets make the values lists.

Two things to watch. The order of the clauses determines the order of the output, so putting the column clause first would transpose the grid. And nesting more than two levels deep is legal but quickly unreadable, which is the point at which an explicit loop is the better choice.

Flattening an arbitrarily deep nested list is naturally recursive, and a generator keeps it lazy so that even a huge structure does not have to be materialised.

def flatten(nested):
    for item in nested:
        if isinstance(item, list):
            yield from flatten(item)
        else:
            yield item


data = [1, [2, 3], [4, [5, 6]], 7]
print(list(flatten(data)))     # [1, 2, 3, 4, 5, 6, 7]

# It stays lazy - take only what you need
stream = flatten(data)
print(next(stream))           # 1
print(next(stream))           # 2

The function walks the outer list, and whenever it meets a nested list it recurses into it, yielding from the recursive call so the inner values pass straight through to the caller. Any depth works, because the recursion follows the shape of the data.

Two details make this safe in practice. yield from delegates iteration to the sub-generator, so the values bubble up without the generator having to know how deep it is. And isinstance(item, list) is the test for a nested list — a more general version would also check for tuples and sets, since those are common in mixed structures.

One refinement worth mentioning: if you also want to flatten strings — treating a string as a sequence of characters rather than as a single value — you have to exclude them explicitly, because a string is iterable and the recursive branch would otherwise break a word into its letters.

The generator form is better than a list-returning version here, because it means you can start consuming the results before the whole structure has been walked, and you never hold a second copy of the data in memory.

Each for clause in a comprehension adds one level of nesting, and the leftmost clause is the outermost loop — exactly as it would be with nested for statements. So the comprehension [expr for a in outer for b in inner] is the equivalent of writing for a in outer: for b in inner: with expr evaluated inside.

That is why the order matters. Putting the clauses the other way round transposes a grid, because the outer loop then runs over the columns instead of the rows. It is also why flattening a list of lists is written as [value for row in rows for value in row] and not the other way round — a row is not something you can iterate over as a single unit.

The nesting can also appear in the expression rather than in the clauses. A dictionary comprehension whose value is itself a list comprehension is a common way to build a mapping of lists, and that is why the same idea appears in both halves of the syntax.

Two practical limits. Python's old limit of about twenty nested blocks was removed long ago, so there is no hard cap, but readability falls apart quickly past two or three levels. And a comprehension cannot contain statements, so there is no way to write a break or a try inside one.

For an interview, the summary is: one for clause per loop level, leftmost is outermost, and the expression is evaluated at the innermost point.