Debugging Unintended Side Effects

When One Change Appears Twice

A list can change in a place you did not expect. One common cause is assigning one list variable to another and assuming that a second list has been created. In Python, assignment creates a reference to the existing list, not a copy. If two variables refer to the same list, modifying the list through either variable changes what the other variable sees.

Tracing Shared References

original = [1, 2, 3] alias = original alias[0] = 99

original
[99, 2, 3]

alias
[99, 2, 3]

The important debugging question is not only “Which variable did I change?” Ask instead, “Which list object does this variable refer to?” With assignment, original and alias are two names for one object. A mutation made through alias changes the object itself, so original observes the same change.

Making an Independent List

When the original list must remain unchanged, create a separate list before modifying it. The source identifies two ways to make a shallow copy: slice notation [:] and the list() constructor. Both create a new list with the same elements. A later modification to the copied list does not affect the original list.

original = [10, 20, 30]
copy = original[:]
copy[1] = 200

original
[10, 20, 30]

copy
[10, 200, 30]

Replacing a Slice

t = ['a', 'b', 'c', 'd', 'e', 'f'] t[1:3] = ['x', 'y']

Predicting Length Changes

To predict the result of slice assignment, compare two counts: the number of elements selected by the slice and the number of elements in the replacement sequence. Equal sizes preserve the list's length. A shorter replacement makes the list shrink. A longer replacement makes the list grow.

Debugging Checklist

• Treating assignment as if it copied the list

  Both variables refer to the same list object, so a modification through alias changes what original sees.

  Fix: Use original[:] or list(original) when an independent list is needed.

• Checking only the variable used for the mutation

  Another variable may refer to the same list and may therefore show the same change.

  Fix: Trace every variable that refers to the list before deciding whether the mutation is unexpected.

• Assuming slice assignment preserves list length

  The replacement sequence is longer than the selected slice, so the list grows.

  Fix: Count the selected elements and the replacement elements before applying the assignment.

• Copying when the program intentionally needs to update the original

  A copy prevents the original list from changing, which may not match the program's intended logic.

  Fix: Choose copying or in-place modification explicitly and document the reason for an intentional in-place change.

1. Find every assignment involving the list.
2. Mark which variables refer to the same list and which were made with a copy.
3. Locate each mutation, including element assignment and slice assignment.
4. For slice assignment, identify the selected elements and count the replacement elements.
5. Decide whether the observed change is an intended in-place update or an unintended shared-reference mutation.

Try the Trace

Key Takeaways

1. Assignment between list variables creates another reference to the same list; it does not create a copy.
2. Use [:] or the list() constructor when you need a separate list with the same elements.
3. Slice assignment replaces multiple selected elements and can change list length.
4. A shorter replacement shrinks the list, an equal-sized replacement preserves its length, and a longer replacement grows it.
5. When debugging a surprising mutation, trace shared references, the selected slice, and the size of the replacement sequence.