Why does a list not raise like a dict?

Lists have no version counter; iteration is a plain index. Dicts and sets track modifications because rehashing could otherwise corrupt the traversal.

Is nums[:] a deep copy?

No, shallow — the new list holds the same element references. Fine for filtering, not for mutating the elements themselves.

What about for k, v in d.items() and then del?

Same error. Wrap in list(d.items()).

Is iterating backwards a hack?

No — it is correct and O(n), and it is the right choice when removing by index in place.

A comprehension, usually — one pass, one allocation, and the loop runs in C.

Does this apply to generators?

A generator over a mutating source gives undefined results; materialise it first if the source will change.

What happens if you modify a collection while looping over it?

Interview QuestionsBy Ashish JangraUpdated 30 August 2026

A dict raises RuntimeError: dictionary changed size during iteration. A list does something worse: it silently skips elements, because removing one shifts everything left while the index keeps advancing. Iterate over a copy, or build a new collection.

Overview

What goes wrong

Removing items from a list while looping over it silently skips elements. It does not raise, which is what makes it dangerous.

1Python

nums = [1, 2, 3, 4, 5, 6]
for n in nums:
    if n % 2 == 0:
        nums.remove(n)

print(nums)        # [1, 3, 5] -- looks correct

nums = [1, 2, 2, 3]
for n in nums:
    if n == 2:
        nums.remove(n)
print(nums)        # [1, 2, 3] -- one 2 SURVIVED

Output

The mechanism: list iteration is driven by an internal index. Removing element 1 shifts everything down one slot, and the index still advances — so the element that moved into the vacated position is never examined.

Step	Index	List	Sees	Action
1	0	`[1, 2, 2, 3]`	1	keep
2	1	`[1, 2, 2, 3]`	2	remove → `[1, 2, 3]`
3	2	`[1, 2, 3]`	3	keep — the second 2 was skipped

The list is now [1, 2, 3] and the loop is finished.

Dictionaries and sets behave differently — they raise:

2Python

d = {"a": 1, "b": 2}
try:
    for k in d:
        if d[k] == 1:
            del d[k]
except RuntimeError as e:
    print(type(e).__name__ + ":", e)
print("dict is still:", d)

Output

Which is far better, because the failure is loud. Dicts and sets track a version counter and detect the change. Lists do not, so they fail quietly instead.

Collection	Mutating during iteration
`list`	Silently skips elements
`dict`	`RuntimeError` on size change
`set`	`RuntimeError` on size change
`deque`	`RuntimeError`
Generator	Depends on the source

Note the dict wording: size change. Reassigning an existing key's value is allowed and safe; adding or deleting keys is not.

Dicts, sets & hashingConceptualEasy

Step through it

What to watch

The dict records its size and checks it on every step.
The error names the real cause — a size change.
Rebuilding rather than mutating avoids the question entirely.

Say this out loud

"Dicts raise RuntimeError. Lists don't - they silently skip elements, because deleting shifts the rest left while the index moves right. I iterate over list(d) or a slice copy, or better, build a new collection with a comprehension."

# Mutating while iterating: one raises, the other lies. # --- the dict: a loud failure ------------------------------------------ d = {"a": 1, "b": 2, "c": 3, "d": 4} try: for key in d: if d[key] % 2 == 0: del d[key] except RuntimeError as e: print("dict ->", e) # Assigning to an EXISTING key is fine - only the size is checked. d = {"a": 1, "b": 2} for key in d: d[key] = 0 print("assigning to existing keys is fine:", d) # --- the list: a silent one -------------------------------------------- items = [1, 2, 4, 6, 7, 8, 9] broken = list(items) for x in broken: if x % 2 == 0: broken.remove(x) print() print("input :", items) print("removing evens :", broken, " <- 6 survived, and no error was raised") print("expected :", [x for x in items if x % 2]) # 6 is skipped because removing 4 shifted it into the index just visited. # --- the three fixes --------------------------------------------------- print() rebuilt = [x for x in items if x % 2] # 1. build a new list print("comprehension :", rebuilt) snapshot = list(items) for x in snapshot[:]: # 2. iterate a copy if x % 2 == 0: snapshot.remove(x) print("iterate a copy :", snapshot) backwards = list(items) for i in range(len(backwards) - 1, -1, -1): # 3. walk backwards if backwards[i] % 2 == 0: del backwards[i] print("backwards :", backwards) print() counts = {"a": 0, "b": 3, "c": 0} cleaned = {k: v for k, v in counts.items() if v} # the dict equivalent print("dict rebuilt :", cleaned) # A change to a VALUE is not a change to the dict. nested = {"x": [1], "y": [2]} for key in nested: nested[key].append(0) print("mutating values is legal:", nested)

nums = [1, 2, 3, 4, 5, 6] d = {"a": 1, "b": 2} for n in nums[:]: # a shallow copy if n % 2 == 0: nums.remove(n) for k in list(d): # snapshot of the keys if d[k] == 1: del d[k] print("nums:", nums) print("d :", d)

from collections import deque nums = [1, 2, 3, 4, 5, 6] items = [1, 2, 3] initial = [1, 2, 3] for i in range(len(nums) - 1, -1, -1): if nums[i] % 2 == 0: del nums[i] print("removed backwards:", nums)

Situation	Approach
Filtering, no aliasing concerns	Comprehension — `nums = [...]`
Must keep the same object	Slice assignment — `nums[:] = [...]`
Removing by index	Iterate backwards
Dictionary keys	`for k in list(d)`
Very large collection, memory-bound	In-place two-pointer compaction
Adding while iterating	Collect additions, extend after the loop

Situation

Approach

Filtering, no aliasing concerns

Comprehension — nums = [...]

Must keep the same object

Slice assignment — nums[:] = [...]

Removing by index

Iterate backwards

Dictionary keys

for k in list(d)

Very large collection, memory-bound

In-place two-pointer compaction

Adding while iterating

Collect additions, extend after the loop

a = [1,2,3,4] b = [1,2,3,4] def remove_evens_wrong(nums): nums = [n for n in nums if n % 2] # rebinds the LOCAL name only a = [1,2,3,4] remove_evens_wrong(a) print("removing while iterating:", a, "<- 4 survived")

a = [1,2,3,4] b = [1,2,3,4] def remove_evens_right(nums): nums[:] = [n for n in nums if n % 2] # mutates the caller's list b = [1,2,3,4] remove_evens_right(b) print("rebinding a slice :", b)

from collections import deque nums = [1, 2, 3, 4, 5, 6] items = [1, 2, 3] initial = [1, 2, 3] write = 0 for read in range(len(nums)): if nums[read] % 2: nums[write] = nums[read] write += 1 del nums[write:] print("compacted:", nums[:write])

from collections import deque nums = [1, 2, 3, 4, 5, 6] items = [1, 2, 3] initial = [1, 2, 3] additions = [] for x in items: if x < 5: additions.append(x + 1) print(items.extend(additions)) print("additions:", additions)

from collections import deque initial = [1, 2] def discover(item): return [item * 10] if item < 10 else [] work = deque(initial) seen = [] while work: item = work.popleft() seen.append(item) work.extend(discover(item)) # safe: not iterating a snapshot print("processed:", seen)

What happens if you modify a collection while looping over it?

A dict raises RuntimeError: dictionary changed size during iteration. A list does something worse: it silently skips elements, because removing one shifts everything left while the index keeps advancing. Iterate over a copy, or build a new collection.

INTERVIEW · vizlearn.in/interview/modifying-a-collection-while-iterating.html

About the author

Ashish Jangra builds and maintains VizLearn. Every module here is written and the visualisation behind it hand-built, so the numbers in a readout come from the same code that draws the picture. Corrections are genuinely welcome and get priority over everything else — if a page states something wrong, or an animation misrepresents what the algorithm does, get in touch.

What happens if you modify a collection while looping over it?

Overview

What goes wrong

Step through it

What to watch

Say this out loud