Why does a comprehension inside a comprehension create nested lists?

Because the outer comprehension collects the result of its expression once for every row, and that expression is another comprehension: [cell for cell in row]. Each inner comprehension makes a list of that row’s cells. The outer comprehension then puts each of those row-lists into a new list. In other words, the outer list has one item per row, and each item is a list. This matches two nested loops: make a row-list for each row, then append that row-list to the result. [S1]

For example, assuming grid = [[1, 2], [3, 4]]:

nested = [[cell for cell in row] for row in grid]
# [[1, 2], [3, 4]]

The inner list is the key: if the expression before the outer for produces a list, the outer result will contain those lists.

Read the comprehension from left to right, matching each for to a loop. In [[cell for cell in row] for row in grid], the inner comprehension is evaluated for each row selected by the outer clause. Its result is collected before the outer loop moves to the next row. Python’s tutorial describes comprehension clauses as following the same order as equivalent nested loops. [S1]

Written out, the logic is:

result = []
for row in grid:
    row_result = []
    for cell in row:
        row_result.append(cell)
    result.append(row_result)

The explicit loops make the grouping visible: row_result is a list, and each one gets appended to result. Use this expanded version when a comprehension is confusing or when you need to add steps; it is the same basic grouping, just easier to inspect.

Put both loops in the same comprehension and make the expression produce a single cell, not a row-list:

flat = [cell for row in grid for cell in row]
# [1, 2, 3, 4]

Here, row is chosen first, then cell runs through that row; each cell is added directly to flat. The Python tutorial gives this same loop ordering for flattening rows into one list. [S1] This traverses the first row from left to right, then the next row, preserving that row-by-row sequence. It doesn’t preserve row boundaries, so use the nested result if you’ll need to know later which row a value came from.

Both the expression and the loop arrangement matter. Nesting comes from the expression returning a list that the outer comprehension collects; changing the order of for clauses alone does not automatically flatten a list-producing expression. With a flat expression, changing clause order can change which combinations are visited first and therefore the result order. In the documented transpose example, a comprehension builds a list for each column index, so it produces a list of lists with the grid’s rows and columns reorganized. [S1]

A useful way to choose is to ask: “What should one item in my final list be?” If the answer is “a whole row,” use a list-producing inner expression. If it is “one cell,” use one cell as the expression and put the row and cell loops in the same comprehension. For a flat result, the comprehension visits cells row by row; it does not retain the row boundaries.