Python Nested List Comprehensions Explained (Python Docs 5.1.4) | Matrix Transposition, zip() & Beginner Guide

This page explains Python Nested List Comprehensions (Python Docs 5.1.4) in simple language. A nested list comprehension is a list comprehension that has another list comprehension as its expression — it's the most concise way to work with 2D data like matrices in Python.

The docs use matrix transposition as the main example. By the end of this guide you'll understand what nested comprehensions actually do under the hood, how they compare to equivalent nested loops, and when to use zip() instead.

What is a Python Nested List Comprehension?

A regular list comprehension creates a flat list. A nested list comprehension has another list comprehension as its expression — so it creates a list of lists. This is exactly what you need for 2D structures like matrices, grids, or tables.

The syntax looks like this:

# Structure of a nested list comprehension
[[inner_expression for item in inner_iterable] for item in outer_iterable]
#  ↑ inner comprehension ↑                       ↑ outer for loop ↑

# The outer for loop runs first, producing one row per iteration.
# For each row, the inner comprehension builds a list.

The Matrix Example — From the Python Docs

The Python docs use a 3×4 matrix to demonstrate nested comprehensions. A 3×4 matrix has 3 rows and 4 columns:

matrix = [
    [1,  2,  3,  4],   # row 0
    [5,  6,  7,  8],   # row 1
    [9, 10, 11, 12],   # row 2
]

Transposing means flipping rows and columns — row 0 becomes column 0, row 1 becomes column 1, and so on. Watch the highlighted numbers: the first row of the original matrix becomes the first column of the transposed matrix.

# Transpose with a nested list comprehension
[[row[i] for row in matrix] for i in range(4)]
# [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

Three Equivalent Ways to Transpose — All from the Python Docs

The docs show the same operation three ways, from the most verbose to the most concise. Understanding all three is key to really getting nested comprehensions:

[[row[i] for row in matrix] for i in range(4)]
# [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

transposed = []
for i in range(4):
    transposed.append([row[i] for row in matrix])

transposed
# [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

transposed = []
for i in range(4):
    transposed_row = []
    for row in matrix:
        transposed_row.append(row[i])
    transposed.append(transposed_row)

transposed
# [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

All three give identical results. Version 1 is the most Pythonic, but Version 3 is the easiest to trace through step by step if you're learning.

How the Inner Comprehension Evaluates — Step by Step

This is the part that confuses most beginners. The inner comprehension doesn't run independently — it's evaluated in the context of the outer for loop.

matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]

# Trace what happens at each step of the outer loop:
# i = 0 → [row[0] for row in matrix] → [1,  5,  9]
# i = 1 → [row[1] for row in matrix] → [2,  6, 10]
# i = 2 → [row[2] for row in matrix] → [3,  7, 11]
# i = 3 → [row[3] for row in matrix] → [4,  8, 12]

# All four collected:
result = [[row[i] for row in matrix] for i in range(4)]
print(result)
# [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

zip() — The Pythonic Shortcut

The docs make an important point here: for matrix transposition specifically, zip() is cleaner and faster. Understanding when to use a built-in instead of a comprehension is a key Python skill.

matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]

# zip(*matrix) — one line, same result
list(zip(*matrix))
# [(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]

# Note: zip gives tuples, not lists.
# If you need lists, wrap with a list comprehension:
[list(row) for row in zip(*matrix)]
# [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

How the * (asterisk) works here

The * in zip(*matrix) is the unpacking operator. It expands the list of rows into separate arguments, as if you'd written zip([1,2,3,4], [5,6,7,8], [9,10,11,12]). zip() then pairs up the first elements, second elements, and so on — which is exactly transposition.

# These two are identical:
list(zip(*matrix))
list(zip([1,2,3,4], [5,6,7,8], [9,10,11,12]))

# zip() pairs up by position:
# (row0[0], row1[0], row2[0]) → (1, 5, 9)
# (row0[1], row1[1], row2[1]) → (2, 6, 10)
# ... and so on

Real-World Uses of Nested List Comprehensions

Creating a multiplication table

# 5x5 multiplication table
table = [[row * col for col in range(1, 6)] for row in range(1, 6)]

for row in table:
    print(row)
# [1,  2,  3,  4,  5]
# [2,  4,  6,  8, 10]
# [3,  6,  9, 12, 15]
# [4,  8, 12, 16, 20]
# [5, 10, 15, 20, 25]

Flattening a 2D list

# Turn a list of lists into a flat list
nested = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [num for row in nested for num in row]
print(flat)   # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Note: this is a single comprehension with two for clauses,
# not a nested comprehension — but it's closely related

Filtering a 2D grid

# Keep only even numbers from each row
matrix = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
evens = [[x for x in row if x % 2 == 0] for row in matrix]
print(evens)
# [[2, 4], [6, 8], [10, 12]]

# Replace negatives with 0 across a grid
grid = [[-1, 2, -3], [4, -5, 6], [-7, 8, 9]]
cleaned = [[max(0, x) for x in row] for row in grid]
print(cleaned)
# [[0, 2, 0], [4, 0, 6], [0, 8, 9]]

Common Nested List Comprehension Mistakes

Python Nested List Comprehension Interview Questions

Python Nested List Comprehensions FAQ