What is the difference between a shallow and a deep copy?

A shallow copy makes a new container that holds references to the same inner objects. A deep copy recursively copies the inner objects as well.

Does list(a) or a[:] make a deep copy?

No. Both behave like copy.copy, so nested lists are still shared between the original and the copy.

When does a shallow copy cause bugs?

When the elements are mutable and you modify one through either container. The change shows up in both, because they point at the same inner object.

Is a shallow copy fine if the elements are immutable?

Yes. Integers, strings and tuples of those cannot be changed in place, so sharing them is safe.

How does copy.deepcopy handle cycles?

It keeps a memo of objects already copied and reuses them. A structure that refers to itself therefore copies without infinite recursion.

Does deep copy always work?

No. Objects that cannot be copied, such as open files or locks, raise an error. It is also slower and uses more memory than a shallow copy.

vizlearn

Shallow copy vs deep copy

Interview QuestionsBy Ashish JangraUpdated 25 October 2026

A shallow copy builds a new container holding the same objects. A deep copy rebuilds the objects too, recursively. Slicing, list(), dict.copy() and copy.copy() are all shallow — so mutating a nested value through one name is visible through the other.

Python semanticsConceptualMedium

Step through it

Speed

What to watch

Both copies are new outer objects — that part is not the difference.
The shallow copy shares the inner lists, which is where the mutation leaks.
original[:] and list(original) behave exactly like copy.copy.

Say this out loud

"A shallow copy copies the outer container and shares the contents, so nested mutation leaks between them. copy.deepcopy rebuilds the whole tree. Slicing and list() are shallow, which is fine for flat data and a bug for nested data."

Overview

A shallow copy creates a new outer container but keeps references to nested objects. A deep copy recursively duplicates nested objects; choose it only when independent nested state is required.

Run it

The divergence at the inner level, the leak demonstrated by one append. And the cycle deepcopy survives.

Where the two diverge, and the one append that proves it.

1Python

import copy

original = [[1, 2], [3, 4]]
shallow = copy.copy(original)
deep = copy.deepcopy(original)

print("outer objects all differ:")
print("  shallow is original:", shallow is original)
print("  deep is original   :", deep is original)
print()
print("but the inner lists are shared by the shallow copy:")
print("  original[0] is shallow[0]:", original[0] is shallow[0])
print("  original[0] is deep[0]   :", original[0] is deep[0])

original[0].append(99)
print()
print("after original[0].append(99):")
print("  original:", original)
print("  shallow :", shallow, "<- changed too")
print("  deep    :", deep, "<- untouched")

Output

Every other spelling of copy is the shallow one, for dicts as well as lists.

2Python

import copy

original = [[1, 2], [3, 4]]
for label, made in (("original[:]", original[:]),
                    ("list(original)", list(original)),
                    ("original.copy()", original.copy()),
                    ("[*original]", [*original]),
                    ("copy.copy(...)", copy.copy(original))):
    print(f"  {label:<18} shares inner:", made[0] is original[0])

d = {"a": [1]}
print()
print("dictionaries too:")
print("  dict(d)   shares:", dict(d)["a"] is d["a"])
print("  d.copy()  shares:", d.copy()["a"] is d["a"])
print("  {**d}     shares:", {**d}["a"] is d["a"])

Output

And the two things a naive recursive copy would get wrong.

3Python

import copy

cyclic = [1, 2]
cyclic.append(cyclic)              # a list containing itself
clone = copy.deepcopy(cyclic)
print("deepcopy of a cyclic list terminated:", clone[2] is clone)

shared = [0]
twice = [shared, shared]
dcopy = copy.deepcopy(twice)
print("sharing preserved, not duplicated:", dcopy[0] is dcopy[1])
print("and it is not the original:       ", dcopy[0] is shared)

t = ([1, 2], 3)
t[0].append(99)
print()
print("a tuple is only as immutable as its contents:", t)

Output

What "shallow" means exactly

A shallow copy allocates a new container and fills it with the same references the first holds. So the outer objects are free — appending to the copy does not lengthen the first — and every element is shared.

For flat data that distinction never appears. A list of integers or strings copies shallowly and behaves exactly as you would want because the shared elements are immutable and nobody can change them. The bug needs two ingredients: nesting, and mutation.

Everything is shallow unless you asked

These are all the same operation: b = a[:], b = list(a), b = a.copy(), b = copy.copy(a), b = [*a], and dict(d) for dictionaries. One level.

copy.deepcopy is the only one in that list that recurses. It also handles the two things a naive recursion would get wrong: cycles, via a memo of objects already copied. So a list containing itself does not hang; and identity sharing. So if the same object appears twice in the source it appears twice as the same object in the result rather than being duplicated.

What deepcopy costs, and when to avoid it

It walks the entire object graph and rebuilds it, so it is proportional to the total size rather than the top-level length. And it is slow enough to notice in a loop. It also copies things you may not want copied: a nested object holding a database connection, an open file or a lock either fails or produces a duplicate that is meaningless.

Classes control this. __deepcopy__ and __copy__ let a type define what copying means, and copy.deepcopy falls back to the pickle protocol (__reduce_ex__) — which is why objects that cannot be pickled often cannot be deep-copied either, for the same reason.

The cheapest fix is often neither: restructure so the nested mutable is not shared in the first place, or use immutable values so copying is unneeded.

The follow-up: the nested-list multiplication bug

"What does [[0] * 3] * 3 give you?" A list of three references to one inner list. So setting grid[0][0] sets the first cell of every row. It is the same fact as this page — the outer sequence was copied and the inner one was shared — arriving through multiplication rather than through a copy call. The fix is a comprehension, which evaluates [0] * 3 once per row.

Edge cases to raise

Volunteering these is most of what separates a correct answer from a good one.

Tuples are only as immutable as their contents. ([1, 2], 3) cannot be reassigned and its inner list can still be appended to. So a tuple is not a defence against the problem on this page.

A dict comprehension over a dict is shallow too, as is {**d}. Every spelling of "make me a new dict from this one" shares the values.

copy.deepcopy on a large structure can be slower than recomputing it. Worth saying out loud because it shows you are costing the fix rather than reaching for the safest-sounding call.

Sources and next steps

Source: Python documentation, copy module
Continue with the nested list multiplication bug, which builds on this idea.

How the code works

The divergence at the inner level, the leak demonstrated by one append, and the cycle deepcopy survives.

How the code works

copy.copy(original)A new outer list holding the same two inner lists. The outer independence is real and is not what the question is about.
original[0].append(99)One mutation, visible through two names. Nothing was assigned to shallow — it changed because it was never a separate object at that level.
made[0] is original[0]True for slicing, list() and .copy() alike. There is one shallow copy operation with several spellings.
clone[2] is clonedeepcopy kept a memo of what it had already copied, so the self-reference became a reference to the copy rather than an infinite descent.

Change one thing

Make the inner values immutable — [(1, 2), (3, 4)] — and try to reproduce the leak. You cannot, which is the argument for immutable values over defensive copying.
Put an open file in the structure and call deepcopy. The failure is the same one pickle gives, because deepcopy falls back to the same protocol.

Where this runs

Real CPython, compiled to WebAssembly and running on your own machine — nothing is uploaded. The first run takes a few seconds while the interpreter downloads; after that it is immediate. Need more room, or want to paste your own attempt? Use the Python compiler.

Check yourself

0 of 4

Answer without scrolling back up.

A shallow copy of [[1,2],[3,4]] gives you:
Which of these is NOT shallow?
Why does deepcopy not hang on a list that contains itself?
When is a shallow copy perfectly safe?

Cheat sheet