Fixing Python’s skipped‑item bug when removing list elements
Timothy scratched his head, staring at the console output. "Margaret, I think Python is lazy."
Margaret looked up from her tea. "Python is many things, Timothy, but lazy isn't usually one of them. What makes you say that?"
"I have a list of tasks," Timothy explained. "I wrote a loop to remove all the 'done' tasks. But it keeps missing some! It cleans up most of them, but leaves a few behind. It's like it's doing a half-hearted job."
He showed her the code:
# Timothy's Cleanup Script
tasks = ["done", "todo", "done", "done", "todo"]
print(f"Start: {tasks}")
for item in tasks:
if item == "done":
tasks.remove(item)
print(f"End: {tasks}")
Timothy ran it to prove his point.
Output:
Start: ['done', 'todo', 'done', 'done', 'todo']
End: ['todo', 'done', 'todo']
"See?" Timothy pointed at the screen. "It left a 'done' right in the middle! Why did it skip that one?"
The Moving Floor
Margaret smiled knowingly. "It didn't skip it because it was lazy. It skipped it because you pulled the floor out from under its feet."
She walked to the whiteboard and drew a row of numbered boxes representing the list indexes.
"Imagine you are walking down a staircase," Margaret began. "You are on Step 0. You decide Step 0 is 'done', so you remove it."
"Okay," Timothy nodded.
"When you remove Step 0," Margaret continued, "all the steps below it shift up to fill the gap. The step that was Step 1 is now Step 0. The step that was Step 2 is now Step 1."
"But here is the catch," she warned. "Python's for loop doesn't re-check the list length each time. It just increments an internal index, assuming the staircase stayed still."
"The loop doesn't know the stairs moved," Timothy realized. "It just thinks, 'Okay, I finished Step 0. Time to move to Step 1.'"
"But the original Step 1 is currently sitting at Step 0! So the loop steps right over it?"
"Exactly," Margaret said. "You are moving forward, but the list is sliding backward. You inevitably skip items. It's like skipping stones across water—you only touch every other surface."
Why Not Go Backwards?
"Could I loop backwards instead?" Timothy asked. "So the shifting doesn't affect the unprocessed items?"
"That's an advanced technique," Margaret acknowledged. "Iterating backwards works because the indexes you haven't visited yet don't move. But for most situations, the copy approach is clearer and less error-prone."
The Snapshot Solution
"So I can't change the list while I'm looking at it?" Timothy asked.
"Never modify a container while you are iterating over it," Margaret recited the golden rule. "It creates chaos."
"So how do I fix it?"
"You work from a snapshot," Margaret explained. "You iterate over a stable copy of the list, but you delete items from the live original."
She modified the loop to use a slice copy [:].
# Margaret's Fix: Iterate over a copy
tasks = ["done", "todo", "done", "done", "todo"]
# [:] creates a temporary copy of the list
for item in tasks[:]:
if item == "done":
tasks.remove(item)
print(f"End: {tasks}")
Output:
End: ['todo', 'todo']
"Perfect!" Timothy cheered. "No more leftovers."
"The copy stays still," Margaret explained. "So the loop never gets lost. Meanwhile, you are free to modify the original list as much as you like."
She added one small clarification. "Just remember, .remove() only deletes the first occurrence it finds. That's why calling it inside a loop works—each iteration removes the next matching item."
The Professional Approach
"Is there an even shorter way?" Timothy asked, sensing there might be.
"There is," Margaret agreed. "Instead of removing the bad items, professional Pythonistas usually just build a new list keeping only the good items. We call this a List Comprehension."
# The "Keep What You Want" approach
tasks = [t for t in tasks if t != "done"]
"That is elegant," Timothy admitted. "It feels... cleaner."
"It is," Margaret smiled. "Sometimes the best way to clean a room isn't to throw out the trash one by one. It's to move the treasures to a new room and leave the trash behind."
She added a practical note. "List comprehensions are also faster than repeatedly calling .remove() in a loop. They scan the list once instead of shifting elements repeatedly. Less work for Python, fewer bugs for you."
Margaret's Cheat Sheet
Margaret opened her notebook to the "Loops" section and drew a clean hierarchy.
The Problem:
Modifying a list while looping over it causes skipped items.
Why It Happens:
Python's for loop increments an internal index while the list shifts beneath it.
Safe Patterns:
- ✅ Loop over a copy (
for item in my_list[:]) - ✅ Loop backwards (
for item in reversed(my_list))
Best Practice:
🏆 Use a List Comprehension to build a new list:
new_list = [x for x in old_list if keep_condition(x)]
Quick Comparison:
- ❌ Don't:
for item in my_list: my_list.remove(item)(chaos, skipped items) - ✅ Do:
for item in my_list[:]: my_list.remove(item)(safe, but O(n²)) - 🏆 Best:
my_list = [x for x in my_list if x != "done"](clean, fast, O(n))
Timothy looked at his clean output. "I'll stop pulling the floor out from under my loops."
"Your loops will appreciate the stability," Margaret promised. "And your future self will appreciate the clean code."
In the next episode, Margaret and Timothy will face "The Lying Truth"—where Timothy learns that sometimes "False" isn't actually False, and that words can lie while numbers tell the truth.
Aaron Rose is a software engineer and technology writer at tech-reader.blog and the author of Think Like a Genius.
SOCIAL SHARE CARD GENERATOR