Mutability & Memory Management

Expert Answer & Key Takeaways

Mastering Mutability & Memory Management is essential for high-fidelity technical performance and advanced exam competency in 2026.

Mutability & Memory Management: Object Identity, Hashing & Copying Strategies (2026)

Understanding the lifecycle of Python objects—how they are identified, hashed, and duplicated—is critical for writing thread-safe and memory-efficient production code.

1. The Proof Code (Shallow vs. Deep Copy)

import copy
from typing import Any

# Original nested structure
original: list[Any] = [[1, 2], [3, 4]]

# 1. Assignment (Alias)
alias = original

# 2. Shallow Copy
shallow = copy.copy(original)

# 3. Deep Copy
deep = copy.deepcopy(original)

# Modification
original[0].append(99)

def check_integrity() -> None:
    print(f"Alias modified: {alias}")   # Reflects change
    print(f"Shallow modified: {shallow}") # Reflects change (nested shared!)
    print(f"Deep modified: {deep}")       # Independent

if __name__ == "__main__":
    check_integrity()

# Output:
# Alias modified: [[1, 2, 99], [3, 4]]
# Shallow modified: [[1, 2, 99], [3, 4]]
# Deep modified: [[1, 2], [3, 4]]

2. Execution Breakdown

Assignment (=): Does not copy anything. It simply creates a new name bound to the existing object. Both names are aliases.
Shallow Copy (copy.copy): Creates a new container, but the elements inside the container are still references to the same objects as the original. This is efficient but dangerous for nested mutable data.
Deep Copy (copy.deepcopy): Recursively copies every object within the container, creating a completely independent duplicate. This has a high CPU and memory cost.
Object ID (id()): Returns the memory address of the object. If id(a) == id(b), then a is b is True.
Hash Value (hash()): A numeric value used for dictionary lookups. Only Immutable objects are hashable.

3. Detailed Theory

The interplay between mutability and hashing defines how Python structures like Dictionaries and Sets behave.

The Immutability of Hashing

For an object to be used as a key in a dictionary, it must be Hashable. Python requires that if two objects compare as equal (==), they must have the same hash value. If an object were mutable, its value (and thus its hash) could change after being placed in a dictionary, making it unreachable.

Identity vs. Value Integrity

id(): Constant for the lifetime of the object. It is the address of the PyObject C-struct.
hash(): Constant only for immutable objects. Mutable objects (like lists) raise a TypeError when passed to hash().

Performance Trade-offs of Deep Copying

Senior engineers avoid deepcopy in performance-critical loops. Because it must handle circular references and maintain a 'memo' dictionary of already copied objects, it is significantly slower than shallow copying or manual object construction.

[!TIP] Senior Secret: When designing custom classes, you can control how they are copied by implementing the __copy__ and __deepcopy__ dunder methods. This allows you to exclude certain attributes (like open database connections or large caches) from being duplicated, optimizing memory usage.

Mutability & Memory Management

Expert Answer & Key Takeaways