Nested list comprehension in Python - Step-by-Step Execution

Concept Flow - Nested list comprehension

Start outer loop

↓

Take one item from outer iterable

↓

Start inner loop

↓

Take one item from inner iterable

↓

Apply expression using outer and inner items

↓

Add result to inner list

↓

Inner loop ends?

No→Repeat inner loop

Yes↓

Add inner list to outer list

↓

Outer loop ends?

No→Repeat outer loop

Yes↓

Return full nested list

Nested list comprehension runs an inner loop inside an outer loop, building a list of lists by applying an expression to each pair of outer and inner items.

Execution Sample

Python

matrix = [[i * j for j in range(3)] for i in range(4)]
print(matrix)

Creates a 4x3 matrix where each element is the product of its row and column indices.

Execution Table

Step	Outer i	Inner j	Expression i*j	Inner list so far	Outer list so far
1	0	0	0*0=0	[0]	[]
2	0	1	0*1=0	[0, 0]	[]
3	0	2	0*2=0	[0, 0, 0]	[]
4	0 inner loop ends			[0, 0, 0]	[[0, 0, 0]]
5	1	0	1*0=0	[0]	[[0, 0, 0]]
6	1	1	1*1=1	[0, 1]	[[0, 0, 0]]
7	1	2	1*2=2	[0, 1, 2]	[[0, 0, 0]]
8	1 inner loop ends			[0, 1, 2]	[[0, 0, 0], [0, 1, 2]]
9	2	0	2*0=0	[0]	[[0, 0, 0], [0, 1, 2]]
10	2	1	2*1=2	[0, 2]	[[0, 0, 0], [0, 1, 2]]
11	2	2	2*2=4	[0, 2, 4]	[[0, 0, 0], [0, 1, 2]]
12	2 inner loop ends			[0, 2, 4]	[[0, 0, 0], [0, 1, 2], [0, 2, 4]]
13	3	0	3*0=0	[0]	[[0, 0, 0], [0, 1, 2], [0, 2, 4]]
14	3	1	3*1=3	[0, 3]	[[0, 0, 0], [0, 1, 2], [0, 2, 4]]
15	3	2	3*2=6	[0, 3, 6]	[[0, 0, 0], [0, 1, 2], [0, 2, 4]]
16	3 inner loop ends			[0, 3, 6]	[[0, 0, 0], [0, 1, 2], [0, 2, 4], [0, 3, 6]]
17	Outer loop ends				[[0, 0, 0], [0, 1, 2], [0, 2, 4], [0, 3, 6]]

💡 Outer loop i reaches 4, condition i in range(4) is False, so comprehension ends.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	Final
i	None	0	1	2	3	End
j	None	0	1	2	End	End
Inner list	[]	[0, 0, 0]	[0, 1, 2]	[0, 2, 4]	[0, 3, 6]	Final inner list cleared after each outer iteration
Outer list	[]	[[0, 0, 0]]	[[0, 0, 0], [0, 1, 2]]	[[0, 0, 0], [0, 1, 2], [0, 2, 4]]	[[0, 0, 0], [0, 1, 2], [0, 2, 4], [0, 3, 6]]	Final nested list

Key Moments - 3 Insights

Why does the inner list get reset for each outer loop iteration?

Because the inner list comprehension runs fresh for each outer i, building a new list before adding it to the outer list. See execution_table rows 4, 8, 12, and 16 where inner loop ends and inner list is added.

What does the expression i*j represent in this nested comprehension?

It calculates the product of the current outer loop value i and inner loop value j, producing each element in the inner list. See execution_table column 'Expression i*j' for each step.

Why is the final result a list of lists?

Because the outer list comprehension collects each inner list (from the inner comprehension) into one big list, creating a nested list structure. See execution_table column 'Outer list so far' growing after each inner loop ends.

Visual Quiz - 3 Questions

Look at the execution table, what is the inner list after step 7?

A [0, 2, 4]

B [0, 0, 0]

C [0, 1, 2]

D [0, 3, 6]

💡 Hint

Check the 'Inner list so far' column at step 7 in the execution_table.

At which step does the outer list first contain two inner lists?

A Step 4

B Step 8

C Step 12

D Step 16

💡 Hint

Look at the 'Outer list so far' column and find when it has two inner lists.

If the inner range changed from range(3) to range(2), how would the inner list length change?

A It would have 2 elements

B It would have 3 elements

C It would have 4 elements

D It would be empty

💡 Hint

The inner loop runs for each j in range(3) originally; changing to range(2) reduces inner iterations to 2.

Concept Snapshot

Nested list comprehension syntax:
[[expression for inner_var in inner_iterable] for outer_var in outer_iterable]

Runs inner loop fully for each outer loop item.
Builds a list of lists.
Useful for creating matrices or grids.
Each inner list is independent and rebuilt each outer iteration.

Full Transcript

Nested list comprehension in Python means putting one list comprehension inside another. The outer loop picks each item, then the inner loop runs fully for that item, creating a list. This inner list is added to the outer list. The example multiplies outer and inner indices to build a 4 by 3 matrix. Step by step, the inner list builds up, then is added to the outer list. This repeats until the outer loop finishes. The final result is a list of lists, like a grid or matrix. Beginners often wonder why the inner list resets each time; it's because the inner comprehension runs fresh for each outer item. The expression uses both loop variables to create each element. Changing the inner loop range changes the size of each inner list. This concept is useful for creating tables, grids, or any nested data structure in a compact way.

Practice

1. What does the following nested list comprehension do?
[[x * 2 for x in range(3)] for _ in range(2)]

easy

A. Creates a list of two lists, each with numbers from 0 to 3

B. Creates a flat list of numbers doubled from 0 to 5

C. Creates a list of three lists, each with numbers doubled from 0 to 1

D. Creates a list of two lists, each with numbers doubled from 0 to 2

Solution

1. Step 1: Understand inner list comprehension

   The inner part [x * 2 for x in range(3)] creates a list by doubling numbers 0, 1, 2 resulting in [0, 2, 4].

2. Step 2: Understand outer list comprehension

   The outer loop runs twice (for _ in range(2)), repeating the inner list twice, making [[0, 2, 4], [0, 2, 4]].

3. Final Answer:

   Creates a list of two lists, each with numbers doubled from 0 to 2 -> Option D

4. Quick Check:

   Nested loops create repeated doubled lists [OK]

Hint: Inner loop builds list, outer repeats it [OK]

Common Mistakes:

• Confusing outer and inner loops
• Thinking it creates a flat list
• Miscounting range values

2. Which of the following is the correct syntax for a nested list comprehension that creates a 3x3 matrix of zeros?

easy

A. [[0] * 3] * 3

B. [0 for _ in range(3) for _ in range(3)]

C. [[0 for _ in range(3)] for _ in range(3)]

D. [0] * 3 for _ in range(3)

Solution

1. Step 1: Identify correct nested comprehension syntax

   [[0 for _ in range(3)] for _ in range(3)] uses two for loops inside list brackets correctly: outer and inner loops create rows and columns.

2. Step 2: Check other options for syntax errors

   [0 for _ in range(3) for _ in range(3)] is flat comprehension, not nested. [[0] * 3] * 3 uses list multiplication but not comprehension. [0] * 3 for _ in range(3) is invalid syntax.

3. Final Answer:

   [[0 for _ in range(3)] for _ in range(3)] -> Option C

4. Quick Check:

   Nested loops inside brackets = correct syntax [OK]

Hint: Nested loops inside brackets create nested lists [OK]

Common Mistakes:

• Using flat comprehension instead of nested
• Incorrect list multiplication for nested lists
• Syntax errors with missing brackets

3. What is the output of this code?

matrix = [[i + j for j in range(3)] for i in range(2)]
print(matrix)

medium

A. [[0, 1, 2], [1, 2, 3]]

B. [[0, 1, 2], [0, 1, 2]]

C. [[0, 1], [1, 2], [2, 3]]

D. [[0, 1, 2, 3], [1, 2, 3, 4]]

Solution

1. Step 1: Understand inner loop values

   For each i, inner loop adds j (0,1,2) to i. For i=0: [0+0, 0+1, 0+2] = [0,1,2]. For i=1: [1+0, 1+1, 1+2] = [1,2,3].

2. Step 2: Combine results into outer list

   The outer loop runs for i in range(2), so final list is [[0,1,2], [1,2,3]].

3. Final Answer:

   [[0, 1, 2], [1, 2, 3]] -> Option A

4. Quick Check:

   Sum of i and j in nested loops = output [OK]

Hint: Add outer and inner loop vars for each element [OK]

Common Mistakes:

• Mixing i and j values
• Confusing list dimensions
• Incorrect range usage

4. Find the error in this nested list comprehension:

result = [[x * y for x in range(3)] for y in range(3)]
print(result)

medium

A. No error, code runs correctly

B. Inner loop variable x is undefined

C. Outer loop variable y is used before definition

D. Syntax error due to missing brackets

Solution

1. Step 1: Check variable definitions

   Both x and y are defined in their respective loops: x in inner, y in outer.

2. Step 2: Verify syntax and logic

   Syntax is correct with proper brackets. The code multiplies x and y for each pair in ranges 0 to 2.

3. Final Answer:

   No error, code runs correctly -> Option A

4. Quick Check:

   Variables defined in loops, syntax correct [OK]

Hint: Check variable scopes in nested loops [OK]

Common Mistakes:

• Thinking variables are undefined
• Confusing loop order
• Assuming syntax error without checking

5. Using nested list comprehension, how can you transform this nested list:

data = [[1, 0, 3], [0, 5, 0], [7, 0, 9]]

to replace all zeros with the string 'zero'?

hard

A. [['zero' if row == 0 else x for x in row] for row in data]

B. [['zero' if x == 0 else x for x in row] for row in data]

C. [['zero' if x == 0 else x for row in data] for x in row]

D. [['zero' if x == 0 else x for x in data] for row in data]

Solution

1. Step 1: Use nested loops to access each element

   Outer loop goes through each row, inner loop through each element x in that row.

2. Step 2: Replace zeros with 'zero' using conditional expression

   Use 'zero' if x == 0 else x inside inner loop to transform elements.

3. Step 3: Combine into nested list comprehension

   Putting it together: [[ 'zero' if x == 0 else x for x in row ] for row in data].

4. Final Answer:

   [['zero' if x == 0 else x for x in row] for row in data] -> Option B

5. Quick Check:

   Conditional inside nested comprehension replaces zeros [OK]

Hint: Use if-else inside inner loop for element replacement [OK]

Common Mistakes:

• Mixing loop variables
• Placing condition on wrong variable
• Incorrect loop order or syntax