copy vs deepcopy vs manual: Shallow Copy Lab

Intro — what this post promises

copy.copy vs copy.deepcopy vs a one-liner dict(obj) / list(obj): folklore says deepcopy is “slow” without saying how slow as nesting grows. This lab times all three on flat dicts, nested dicts/lists, and lists of dicts on Linux localhost.

Related links:

• set vs list membership localhost lab
• string concat vs join localhost lab
• sorted vs heapq vs bisect localhost lab
• dataclass vs slots vs dict localhost lab
• json vs orjson vs msgpack localhost lab
• pathlib vs os.path localhost lab
• python re vs str methods localhost lab
• tempfile NamedTemporaryFile localhost lab

Lab honesty (1 Oct 2026 IST): Python 3.13.5. Affiliates: 0. Manual arm is one-level (dict() / list()), not a hand-rolled recursive clone. No custom __deepcopy__.

Verdict up front: shallow copy stays in the millions of ops/s until the top container is large. deepcopy is the cliff: flat dict N=16 is already ~0.022× copy (175k vs 8.00M/s). List of 256 dicts: deepcopy ~1,588/s vs copy ~2.11M.

What each arm guarantees

If you only needed a new top dict so you can add a key, deepcopy is paying for isolation you did not use.

Lab topology

flat dict: N in {16, 128, 1024} string keys, int values
nested dict/list: width 4, depth 2/4/6
list of dicts: 32 or 256 rows x 6 int fields
Each timed call: 200 copies; ops/s from p50 wall

Script: lab-evidence/50-copy-vs-deepcopy/results/run_lab.py.

Lead table — copies/s (p50)

Shallow copy of a nested dict stays ~10M/s at depth 6 because it does not walk children. Deepcopy falls from ~122k/s (depth 2) to ~31.2k/s (depth 6). That is the whole lesson: depth is free for copy and expensive for deepcopy.

Reading the numbers

• Manual dict() / list() beat copy.copy on these builtins (~1.52× on the small flat dict; ~1.87× on a small nested list). copy.copy pays a dispatch layer; the result is still shallow.
• Flat dict N=1024: copy 253,991/s vs deepcopy 3,130/s (0.012×). Even scalar values are visited by deepcopy’s memo machinery.
• List of dicts N=256: deepcopy 1,588/s (~0.63 ms/copy). That is a request-path hazard if you clone a payload “just in case.”

Pitfalls

1. Shallow copy then mutate a nested list — you mutated the original. deepcopy is the correct tool; just budget it.
2. Using deepcopy to dodge a shared default argument — fix the default (None then a new dict inside) instead.
3. Assuming dict(d) deep-copies values — it does not.
4. Custom objects — this lab is dict/list only. Classes with __deepcopy__ can be faster or slower.

When to pick what

Reproduce

python3 lab-evidence/50-copy-vs-deepcopy/results/run_lab.py

Evidence: /workspace/lab-evidence/50-copy-vs-deepcopy/results/.

Closing

Shallow is cheap; deep walks the tree. On this box a 16-key dict is ~8.00M copy.copy/s vs ~175k deepcopy. Depth 6 nested dict: copy stays ~10.1M/s while deepcopy drops to ~31k. A 256-row list of dicts deepcopy is ~1,588/s. Use deepcopy when isolation is the requirement — not as a default clone.