List comprehension vs loop in Python - Visual Side-by-Side Comparison

Concept Flow - List comprehension vs loop

Start with empty list

↓

For each item in input

↓

Apply expression to item

↓

Add result to list

↓

Repeat for all items

↓

Return final list

Both list comprehension and loop build a new list by processing each item one by one and adding the result.

Execution Sample

Python

numbers = [1, 2, 3, 4]
squares_loop = []
for n in numbers:
    squares_loop.append(n*n)
squares_comp = [n*n for n in numbers]

This code creates a list of squares of numbers using a loop and a list comprehension.

Execution Table

Step	Variable	Value	Action	Output List
1	n	1	Append 1*1=1	[1]
2	n	2	Append 2*2=4	[1, 4]
3	n	3	Append 3*3=9	[1, 4, 9]
4	n	4	Append 4*4=16	[1, 4, 9, 16]
5	squares_comp	[1, 4, 9, 16]	List comprehension creates list	[1, 4, 9, 16]
6	-	-	End of processing	[1, 4, 9, 16]

💡 All numbers processed, both methods produce the same list of squares.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	Final
n	-	1	2	3	4	-
squares_loop	[]	[1]	[1, 4]	[1, 4, 9]	[1, 4, 9, 16]	[1, 4, 9, 16]
squares_comp	-	-	-	-	-	[1, 4, 9, 16]

Key Moments - 3 Insights

Why does the list comprehension create the whole list at once?

Because list comprehension runs the expression for each item internally and collects results before assigning to the variable, unlike the loop which appends step-by-step (see execution_table row 5).

Is the output list the same for both methods?

Yes, both methods produce the same final list of squares as shown in execution_table rows 4 and 5.

Can list comprehension replace any loop that builds a list?

Yes, if the loop only appends transformed items, list comprehension is a shorter and clearer way to write it (see code in execution_sample).

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of squares_loop after step 3?

A [1, 4, 9, 16]

B [1, 4]

C [1, 4, 9]

D []

💡 Hint

Check the Output List column at step 3 in execution_table.

At which step does the list comprehension create the full list?

A Step 5

B Step 4

C Step 6

D Step 3

💡 Hint

Look for the row where squares_comp is assigned in execution_table.

If we change the expression to n+1, how would the output list change?

A [1, 4, 9, 16]

B [2, 3, 4, 5]

C [1, 2, 3, 4]

D [0, 1, 2, 3]

💡 Hint

Think about applying n+1 to each number in variable_tracker for n.

Concept Snapshot

List comprehension is a concise way to create lists.
Syntax: [expression for item in iterable]
Equivalent to a loop that appends each expression result.
Runs faster and looks cleaner for simple transformations.
Use loops for complex logic or multiple statements.

Full Transcript

This visual shows how list comprehension and loops both create lists by processing each item. The loop appends each squared number step-by-step, updating the list after each iteration. The list comprehension runs internally and creates the full list at once. Both methods produce the same final list of squares. Beginners often wonder why list comprehension looks shorter and how it works internally. The execution table and variable tracker clarify these steps clearly.

Practice

1. What is the main advantage of using list comprehension over a traditional for loop in Python?

easy

A. It runs slower than a loop

B. It creates lists in fewer lines and is more readable

C. It cannot be used to create lists

D. It requires more code to write

Solution

1. Step 1: Understand list comprehension purpose

   List comprehension is designed to create lists in a concise and readable way.

2. Step 2: Compare with traditional loops

   Traditional loops require more lines and are less compact than list comprehensions.

3. Final Answer:

   It creates lists in fewer lines and is more readable -> Option B

4. Quick Check:

   List comprehension = concise and readable [OK]

Hint: List comprehension is shorter and clearer than loops [OK]

Common Mistakes:

• Thinking list comprehension is slower
• Believing list comprehension can't create lists
• Confusing loops as always simpler

2. Which of the following is the correct syntax for a list comprehension that creates a list of squares of numbers from 0 to 4?

easy

A. [x**2 for x in range(5)]

B. [for x in range(5) x**2]

C. [x^2 in range(5)]

D. for x in range(5): x**2

Solution

1. Step 1: Recall list comprehension syntax

   The correct syntax is: [expression for variable in iterable].

2. Step 2: Check each option

   [x**2 for x in range(5)] matches the correct syntax. Others have syntax errors or missing parts.

3. Final Answer:

   [x**2 for x in range(5)] -> Option A

4. Quick Check:

   Correct list comprehension syntax = [x**2 for x in range(5)] [OK]

Hint: Remember: [expression for variable in iterable] [OK]

Common Mistakes:

• Placing 'for' after expression
• Using ^ instead of ** for power
• Writing loop without brackets

3. What is the output of the following code?

nums = [1, 2, 3]
squares = []
for n in nums:
    squares.append(n**2)
print(squares)

medium

A. [1, 2, 3]

B. [2, 4, 6]

C. [1, 4, 9]

D. Error

Solution

1. Step 1: Understand the loop operation

   The loop goes through each number in nums and appends its square to squares.

2. Step 2: Calculate squares for each element

   1 squared is 1, 2 squared is 4, 3 squared is 9, so squares = [1, 4, 9].

3. Final Answer:

   [1, 4, 9] -> Option C

4. Quick Check:

   Squares of [1,2,3] = [1,4,9] [OK]

Hint: Loop appends squares, so output is squared list [OK]

Common Mistakes:

• Confusing append with extend
• Expecting original list instead of squares
• Syntax errors in loop

4. Identify the error in this list comprehension:

result = [x*2 for x in range(5)
print(result)

medium

A. print statement is incorrect

B. Using wrong operator * instead of **

C. range(5) should be range[5]

D. Missing closing bracket "]" in list comprehension

Solution

1. Step 1: Check list comprehension syntax

   The list comprehension is missing the closing square bracket "]" at the end.

2. Step 2: Verify other parts

   Operator * is correct for multiplication, range(5) is correct, and print syntax is valid.

3. Final Answer:

   Missing closing bracket "]" in list comprehension -> Option D

4. Quick Check:

   Syntax error due to missing bracket [OK]

Hint: Always close brackets in comprehensions [OK]

Common Mistakes:

• Forgetting closing bracket
• Confusing parentheses and brackets
• Misusing range syntax

5. You want to create a list of even numbers from 0 to 10 using list comprehension. Which code correctly does this?

hard

A. [x for x in range(11) if x % 2 == 0]

B. [x*2 for x in range(5)]

C. [x for x in range(10) if x % 2]

D. [x for x in range(11) if x / 2 == 0]

Solution

1. Step 1: Understand the requirement

   We want even numbers from 0 to 10 inclusive, so numbers divisible by 2.

2. Step 2: Analyze each option

   [x for x in range(11) if x % 2 == 0] uses correct range and condition (x % 2 == 0). [x*2 for x in range(5)] doubles numbers 0-4, giving [0,2,4,6,8]. [x for x in range(10) if x % 2] filters odd numbers (x % 2 is true for odd). [x for x in range(11) if x / 2 == 0] uses division instead of modulo, which is incorrect.

3. Final Answer:

   [x for x in range(11) if x % 2 == 0] -> Option A

4. Quick Check:

   Filter even numbers with modulo == 0 [OK]

Hint: Use modulo % 2 == 0 to filter even numbers [OK]

Common Mistakes:

• Using multiplication instead of filtering
• Using wrong condition for even check
• Confusing division with modulo