Nested list comprehension in Python - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a nested list comprehension in Python?

A nested list comprehension is a way to create a list inside another list comprehension, allowing you to build multi-dimensional lists or perform operations on nested loops in a single, concise expression.

beginner

How does the order of 'for' loops affect a nested list comprehension?

The order of 'for' loops in a nested list comprehension matches the order of nested loops in regular code. The first 'for' is the outer loop, and the second 'for' is the inner loop, which runs completely for each iteration of the outer loop.

beginner

Example: What does this nested list comprehension do? [[x * y for y in range(3)] for x in range(2)]

It creates a 2D list where each inner list contains the products of x and y. For x=0 and x=1, it multiplies by y=0,1,2, resulting in [[0, 0, 0], [0, 1, 2]].

intermediate

Can nested list comprehensions replace nested for loops?

Yes, nested list comprehensions can replace nested for loops to create lists in a shorter and more readable way, especially when building or transforming multi-dimensional lists.

intermediate

What is a common use case for nested list comprehensions?

They are commonly used to create matrices, flatten nested lists, or apply operations across multiple dimensions in a compact and readable way.

What does the outer 'for' loop represent in a nested list comprehension?

A The first loop that runs once per outer element

B The last loop that runs for each inner element

C A conditional filter

D A function call

The outer 'for' loop runs once per outer element, controlling how many inner lists are created.

What is the output of [[i + j for j in range(2)] for i in range(3)]?

A [[0, 1, 2], [0, 1, 2]]

B [[0, 1], [1, 2], [2, 3]]

C [[0, 1], [0, 1], [0, 1]]

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

For i=0, j=0,1 → [0,1]; i=1 → [1,2]; i=2 → [2,3].

Which of these is a valid nested list comprehension?

A [x*y for x in range(2) y in range(3)]

B [x for y in range(3) for x in range(2)]

C [x*y for x in range(2), y in range(3)]

D [[x*y for y in range(3)] for x in range(2)]

Option D correctly nests two 'for' loops inside the list comprehension.

How can nested list comprehensions improve code?

A By removing the need for variables

B By making code run slower

C By making nested loops shorter and more readable

D By avoiding all loops

Nested list comprehensions make nested loops shorter and often easier to read.

What does this nested list comprehension do? [[i for i in range(3)] for _ in range(2)]

A Creates two lists each with [0, 1, 2]

B Creates one list with [0, 1, 2, 0, 1, 2]

C Creates a list of numbers from 0 to 5

D Creates an empty list

It creates two inner lists, each containing [0, 1, 2].

Explain how nested list comprehensions work and how they relate to nested for loops.

Think about how loops inside loops work and how list comprehensions can replace them.

Describe a real-life example where you might use a nested list comprehension.

Imagine working with tables or grids of numbers.

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