Shallow vs. Deep Copying
When analyzing a shallow or deep copy, the key question remains whether the objects that matter are shared or independent.
Try it: Shallow vs Deep Copies of Nested Lists
Why b = a copies nothing, why a[:], list(a) and a.copy() copy only the outer list (the inner lists stay shared, so a[0] is b[0]), and how copy.deepcopy copies every level — checked with is and ==.
How it works
- b = a binds a second name to the same list object: a is b.
- a[:], list(a) and a.copy() make one new outer list whose slots copy the references: a is not b, but a[0] is b[0].
- copy.deepcopy copies every list recursively (a memo keeps a list that appears twice as one copy); ints are immutable and simply shared.
- Mutating a list reachable from both names (append, item assignment) is seen through both; rebinding a name changes only that name.
- is compares identity; == compares values item by item.
Default run (9 steps): The program builds a nested list, copies it one way, then changes one of the two names. … Done. a = [[1, 2, 9], [3, 4]] | b = [[1, 2, 9], 7] | a is b False | a == b False | a[0] is b[0] True
Simplified: Small nested lists of ints; the list numbers L1, L2… stand in for identities (not real id() values). Equal small ints are one cached object in CPython, so a[0] is b[0] can be True for ints.
Loading the simulation…
The Backup That Was Not Independent
Imagine creating a backup of a list and then changing the original. Whether the backup changes too depends on one question: did you create a separate object, or did both variables become names for the same object? This is the foundation for understanding copying in Python. The same visible data can belong to one shared object or to multiple separate objects.
Two Ways Objects Can Match
Identity and equivalence describe different relationships. Identity asks whether two variables refer to the exact same object in memory. Python checks this relationship with the is operator. Equivalence asks whether two objects contain the same value or data. Python checks this relationship with the == operator.
Same data, different identity
Consider two separately created lists that each contain the values 1, 2, and 3.
- 1Compare their values
The lists contain the same elements, so they are equivalent. The == comparison is True.
- 2Compare their identity
They are two separate list objects, so they are not identical. The is comparison is False.
- 3Interpret the result
Matching contents do not prove that two variables refer to the same object.
The lists are equivalent without being identical.
Identity and Equivalence
Identity means that two variables refer to the same object. Equivalence means that the objects referred to by two variables have the same value or data.
If two variables refer to one object, that object has one identity and one value, so identity implies equivalence. However, two separate objects can contain the same data, so equivalence does not imply identity.
Aliasing Versus a New List
Assigning one variable to another does not create a new list. It creates an alias: both variable names refer to the same existing object. By contrast, creating a new list literal creates a separate list object, even when the elements match those of another list.
| Situation | Object relationship | Identity result | Mutation consequence |
|---|---|---|---|
| One variable assigned to another | Both variables refer to the same object | is returns True | A change through one variable is visible through the other |
| A separate list is created with the same elements | Variables refer to different list objects | is returns False | The lists are not automatically the same object |
The source of the reference determines whether two variables are aliases or refer to separate objects.
Nested Copying Caution
When analyzing a shallow or deep copy, the key question remains whether the objects that matter are shared or independent. The supplied material establishes the general rule for aliases and separate objects, but it does not specify a particular copying function or give a complete rule for nested structures. Therefore, do not assume that the word copy alone proves independence. Check the identity relationship of the objects involved.
Strings and Lists
Strings and lists illustrate why identity behavior must be understood together with mutability. Strings are immutable, meaning they cannot be changed after creation. Python can therefore reuse string objects when possible; this behavior is called string interning. Lists are mutable, meaning their contents can be changed. Python creates separate list objects when two lists are created with the same elements, rather than treating matching list contents as proof of shared identity.
| Type | Mutability | Identity behavior described in the source | Why it matters |
|---|---|---|---|
| String | Immutable | Python can reuse string objects when possible | Reusing an object is safe because its contents cannot be changed |
| List | Mutable | Two lists with the same elements are separate objects when separately created | Changing a shared list can affect every variable referring to it |
Mutability affects whether sharing an object can produce visible changes through multiple variables.
Mistakes That Cause Mutation Bugs
Common mistake Assuming equal-looking lists are the same object.
What it looks likeTwo separately created lists contain the same elements.
Why it failsLists can be separate objects while still being equivalent.
Do this insteadUse == to compare data and is to test whether the object itself is shared.Common mistake Treating assignment as a copy.
What it looks likeOne variable is assigned to another variable that already refers to a list.
Why it failsThe assignment creates an alias, so both variables refer to the same list.
Do this insteadDecide explicitly whether shared data or an independent object is intended.
Common mistake Expecting a backup to protect data without checking identity.
What it looks likeA list is modified through one variable, and the change appears through another variable.
Why it failsBoth variables may refer to the same mutable list.
Do this insteadCheck the identity relationship before relying on the backup.
Common mistake Assuming string behavior applies unchanged to lists.
What it looks likeA learner expects two matching lists to be reused like matching strings.
Why it failsStrings are immutable, while lists are mutable, so Python handles them differently.
Do this insteadConsider the object's mutability when reasoning about identity and sharing.
Practice the Identity Test
A variable named scores refers to a list. A second variable named backup is then assigned from scores. Predict the result of comparing scores and backup with is. Next, imagine that another list is created separately with the same elements as scores. Predict whether the separate list is equivalent to scores and whether it is identical to scores.
Hints
- Ask whether the second variable was made by aliasing an existing object or by creating a new list.
- Use == for matching data and is for shared identity.
- Remember that modifying a shared mutable list is visible through both aliases.
Reading the two comparisons
Compare an alias of a list with a separately created list containing the same data.
- 1Alias comparison
The alias and the original refer to one list object, so they are identical and therefore equivalent.
- 2Separate-list comparison
The separately created list has the same elements, so it is equivalent to the original, but it is not the same object.
- 3Choose the operator
Use is when the question concerns one shared object. Use == when the question concerns matching data.
Identity and equivalence must be checked with different operators because they answer different questions.
Working Rule
- 1Use is to ask whether two variables refer to the same object.
- 2Use == to ask whether two objects contain the same value or data.
- 3Identity always implies equivalence, but equivalent objects can still be separate.
- 4Assignment can create an alias rather than an independent copy.
- 5Mutability matters: changes to a shared list are visible through every alias, while strings cannot be changed after creation.
Key Takeaways
- Identity describes whether variables refer to the same object; equivalence describes whether objects contain the same data.
- The is operator tests identity, while the == operator tests value equivalence.
- An alias gives multiple variables access to one object, so mutation through one alias is visible through the others.
- Separately created lists can be equivalent without being identical.
- Immutable strings and mutable lists behave differently because their contents have different mutability rules.