Understanding Python Assignment, Shallow Copy, and Deep Copy

Understanding Python Assignment, Shallow Copy, and Deep Copy

In Python, assigning an object creates a reference to the same memory address, which can lead to unexpected behavior if not understood.

1. Object Assignment

The following code demonstrates simple assignment:

The output shows that both will and wilber refer to the same list object, so changes to one affect the other. Immutable types like str create a new object when modified.

2. Shallow Copy

Using copy.copy() creates a new container object but retains references to the original elements:

The result shows that the new list wilber is a different object from will, yet its mutable elements still reference the same objects, so modifications to those elements are reflected in both lists.

3. Deep Copy

Using copy.deepcopy() creates a completely independent copy of the container and all nested objects:

The output confirms that wilber is a distinct object and its elements are also new objects, so changes to will do not affect wilber.

4. Special Cases

Non‑container types such as numbers, strings, and other atomic objects are not copied; the identity check obj is copy.copy(obj) or obj is copy.deepcopy(obj) returns True. For tuples containing only atomic objects, deep copy is ineffective.

5. Summary

Python object assignment passes references (memory addresses).

Using copy.copy() performs a shallow copy: the container is new, but its elements remain references to the originals.

Using copy.deepcopy() creates a fully independent copy of the container and all nested objects.

Immutable or atomic types are not truly copied; they remain the same object.

If a tuple contains only atomic objects, deep copy has no effect.