Summary  
This chapter distinguishes between simple assignment (which creates references), shallow copy (which duplicates only the outer container), and deep copy (which recursively duplicates all nested objects), explaining their effects on mutability and memory usage.

General domain of usage  
Financial data management

Assigning an object to a new variable does not copy it – both variables point to the same object. Modifying the object through one variable affects the other. Understanding when Python copies and when it references is essential for avoiding unexpected mutations and unnecessary memory duplication.



Get a comprehensive visual overview of how assignment, shallow copy, and deep copy work in Python. See how references and copies affect memory usage, object independence, and data safety. Learn when to use assignment, `copy.copy()`, or `copy.deepcopy()` for different data structures and performance needs.
- video metadata (use this info when making a video) --
Cut all examples of code to a minimum. Show only the essential code. Show code no longer than 10 lines. Remove all possible pieces to demonstrate some code feature. You may show not full code that will not start, but still demonstrates some feature theoritacally.
If code is longer than 8 lines, move code output  blocks to second column.

## Assignment Creates References, Not Copies

import sys

# Assignment – both variables point to the same object
original_budget = {"q1": 50000, "q2": 75000, "q3": 90000}
budget_ref = original_budget  # No copy – same object

budget_ref["q1"] = 99999  # Modifying through budget_ref
print(original_budget)    # {'q1': 99999, 'q2': 75000, 'q3': 90000} – original changed

print(original_budget is budget_ref)  # True – same object
print(sys.getrefcount(original_budget))  # At least 3

## Shallow Copy

A shallow copy creates a new container object but does not copy the objects inside it – nested objects are still shared:

import copy

# Shallow copy – new dict, but nested lists are shared
portfolio = {
    "equities": [150000, 200000, 175000],
    "bonds": [80000, 95000],
}

portfolio_shallow = copy.copy(portfolio)

portfolio_shallow["equities"].append(250000)  # Modifies shared nested list

print(portfolio["equities"])          # [150000, 200000, 175000, 250000] – modified!
print(portfolio_shallow["equities"])  # [150000, 200000, 175000, 250000] – same object

print(portfolio is portfolio_shallow)           # False – different dicts
print(portfolio["equities"] is portfolio_shallow["equities"])  # True – shared list

For flat structures with no nested mutable objects, shallow copy is sufficient and cheaper.



## Deep Copy

`copy.deepcopy()` recursively copies all nested objects. The result is completely independent:

import copy

# Deep copy – fully independent copy of nested structure
portfolio = {
    "equities": [150000, 200000, 175000],
    "bonds": [80000, 95000],
}

portfolio_deep = copy.deepcopy(portfolio)

portfolio_deep["equities"].append(250000)  # Only modifies the copy

print(portfolio["equities"])       # [150000, 200000, 175000] – unchanged
print(portfolio_deep["equities"])  # [150000, 200000, 175000, 250000]

## Memory Cost of Deep Copy

Deep copy allocates memory for every nested object. For large structures, this can be expensive:

import copy
import sys
import tracemalloc

# Measuring memory cost of deep copy vs shallow copy
large_dataset = {
    f"region_{region_id}": list(range(1000))
    for region_id in range(100)
}

tracemalloc.start()

shallow = copy.copy(large_dataset)
_, shallow_peak = tracemalloc.get_traced_memory()
tracemalloc.clear_traces()

deep = copy.deepcopy(large_dataset)
_, deep_peak = tracemalloc.get_traced_memory()

tracemalloc.stop()

print(f"Shallow copy peak: {shallow_peak / 1024:.1f} KB")
print(f"Deep copy peak:    {deep_peak / 1024:.1f} KB")

Nested mutable objects, need full independence

What is the key difference between `copy.copy()` and `copy.deepcopy()`?

Master the skills needed to understand Python's memory management internals and performance optimization techniques. This course is designed for intermediate and advanced Python developers who want to understand how Python handles memory, write memory-efficient code, detect and fix memory leaks, and optimize performance in real-world applications.

Explore the essentials of Python's memory management, including reference counting, garbage collection, and memory allocation strategies.

Get hands-on experience with practical techniques for writing memory-efficient Python code, including specialized data structures and tools for controlling object lifecycle.

Master the skills needed to profile memory usage and detect memory leaks in Python applications.

Explore the essentials of advanced memory and performance optimization patterns, including object interning, memory inspection tools, and the GIL's impact on memory access.

Copy vs Reference – copy and deepcopy

Assignment Creates References, Not Copies

Shallow Copy

Deep Copy

Memory Cost of Deep Copy

Choosing the Right Approach