tricky question_3

[Temple-Daemon]

You have a list of even numbers, and you want to delete every even number from it. You write a loop that removes each one it finds. The list should end up empty.

python
nums = [2, 4, 6, 8]
for n in nums:
if n % 2 == 0:
nums.remove(n)
print(nums)

a) Predict: Is the final list empty? Write down what you think it contains.
b) Explain: Trace the loop by hand. Write down the list and the current index at the start of each pass. Which values does the loop never look at, and why?
c) Fix: Solve it two different ways: (1) loop over a copy of the list, and (2) build a new list using a list comprehension. Which one would you pick for real code, and why?

[mgkvibez]

a) Predicted output

[4, 8]

No, the list is not empty. Half the values survive.

b) Trace by hand

A for loop over a list uses a hidden index that goes up by 1 each pass. When you remove an item, the remaining items shift left, but the index still moves forward.

Pass	Index	List at start	n	Action	List after
1	0	[2, 4, 6, 8]	2	remove 2	[4, 6, 8]
2	1	[4, 6, 8]	6	remove 6	[4, 8]
3	2	[4, 8]	none	index 2 is past the end, loop stops	[4, 8]

The loop never looks at 4 or 8.

• After 2 is removed, 4 slides into index 0, but the loop has already moved on to index 1, so it skips 4 and lands on 6.
• After 6 is removed, 8 slides into index 1, but the loop moves to index 2, which no longer exists, so it ends before ever seeing 8.

The core problem is mutating a list while iterating over it.

c) Two fixes

1) Loop over a copy

nums = [2, 4, 6, 8]
for n in nums[:]:        # nums[:] is a shallow copy
    if n % 2 == 0:
        nums.remove(n)
print(nums)  # []

The loop walks the copy, which never changes, while remove edits the original.

2) Build a new list with a comprehension

nums = [2, 4, 6, 8]
nums = [n for n in nums if n % 2 != 0]
print(nums)  # []

This keeps only the odd numbers, so every even number is dropped.

Which I'd pick for real code: the comprehension.

• It's clearer. You state what you want to keep, instead of a remove-while-looping mechanism.
• It's faster. remove searches the list from the start each time and shifts elements, making the copy approach O(n²) in the worst case, while the comprehension is a single O(n) pass.
• It's safer. There's no mutation during iteration, so the bug can't come back.
• If other code holds a reference to the original list and needs to see the change, use slice assignment: nums[:] = [n for n in nums if n % 2 != 0].