Copying: assignment copies nothing, copy copies one level, deepcopy copies the whole graph

Base: three operations in four lines

The whole lesson grows out of four lines of code. They are worth writing out in full and looking at once.

import copy
 
a = [[1, 2], [3]]         # a list with other lists inside it
b = a                     # assignment
c = copy.copy(a)          # a shallow copy
d = copy.deepcopy(a)      # a deep copy

As long as nothing has been changed, all four names show the same contents, and == between any two of them is True. The difference appears at exactly one moment — when you change a nested object rather than the top one:

a[0].append(99)           # change the list that sits INSIDE
 
b[0]                      # [1, 2, 99] — b is a; no second object was ever made
c[0]                      # [1, 2, 99] — the top list is new, the nested one is not
d[0]                      # [1, 2]     — the deep copy has a nested list of its own

Three different answers to one change. Read them like this:

• b = a creates no object at all: it is a second name for the same list;
• c is a new top-level list whose nested lists are the very ones a has;
• d is a new top-level list whose nested lists are new as well.

And here is the question this lesson is about: on a flat list these three operations are indistinguishable — so how deep does each of them actually reach? The answer at base level: assignment reaches nowhere, a shallow copy reaches the first level, a deep copy goes past it.

That is already enough to answer the basic interview question. Everything below is about where "past it" ends: what a deep copy does with an object it meets twice, what happens to a structure that refers to itself, what neither operation copies at all, and why the constructor is not called even once.

Mechanism 1: assignment does not copy

This is the first place the confusion starts, and also the simplest. b = a creates no new object at all — there is now a second name for the same one.

One line proves it:

a = [1, 2, 3]
b = a
b.append(4)
print(a)        # [1, 2, 3, 4]
print(b is a)   # True

This gives the rule everything else reduces to: "copy or not a copy" is always a question about is, never about ==. Equality distinguishes nothing here: the original, the shallow copy and the deep copy all compare == as True.

Mechanism 2: one level — and what that means

The two definitions in the documentation differ by exactly one word, and that word should be read literally.

References versus copies. Everything else follows.

Switch the picture to "a shared object": in the deep copy inner turns out to be one object for two cells. Then to "a cycle": the shallow copy's single cell points at the original rather than at itself.

There are four ways to make a shallow copy, and all four are the same thing:

b = a[:]
b = list(a)
b = a.copy()
b = copy.copy(a)

They differ by under seven percent on the same list of a thousand records — that is, they do not differ. The fifth way, often written out of habit, costs 5.8 times more than the other four:

b = [x for x in a]      # 13.7 µs against 2.3–2.5 µs for the other four

The reason is not the copying: a comprehension runs a separate loop step per element, while a[:] and list(a) copy the array of pointers in one go.

The classic trap comes from the same place — list repetition:

grid = [[0] * 3] * 3
grid[0][0] = 1
print(grid)     # [[1, 0, 0], [1, 0, 0], [1, 0, 0]]

The outer * 3 did not create three rows. It created three references to one row — exactly what a shallow copy does, just written shorter.

Mechanism 3: a deep copy builds a copy of the graph, not one reference at a time

This is the point where most explanations get it wrong. "A deep copy copies the whole tree", "a deep copy copies everything" — wrong, and wrong twice over: first, the structure need not have the shape of a tree at all; second, not every reference it meets gets copied. More precisely: a deep copy builds a copy of the object graph, asking each object it meets how to copy it and remembering what it has already copied. The first half is the copying protocol: every type has a way of being copied, and an object may intercept that itself. The second half is a table deepcopy consults for every object.

Two properties follow straight from that wording, and follow from "copies the whole tree" not at all: a shared object stays shared in the copy, and a cycle does not send the copying into infinity.

The fix is named on the same page — "keeping a memo dictionary of objects already copied during the current copying pass".

What follows from it in practice:

shared = {"config": 1}
orig = {"a": shared, "b": shared}
deep = copy.deepcopy(orig)
 
print(orig["a"] is orig["b"])       # True — one object under two keys
print(deep["a"] is deep["b"])       # True — and in the copy it is ONE too
print(deep["a"] is orig["a"])       # False — but a different one

The structure is reproduced, not multiplied. Two separate deep copies share nothing with each other: the table lives for one pass and is created afresh on the next call.

That same table can be filled in advance — which is how you forbid copying a particular object:

memo = {id(shared): shared}
kept = copy.deepcopy(orig, memo)
print(kept["a"] is shared)          # True

This is the way to say "copy everything except this one" without touching the classes: the second parameter of deepcopy is open for exactly that. The other way is a __deepcopy__ hook, covered below.

And the same memo is why a cycle survives copying:

a = []
a.append(a)
 
s = copy.copy(a)
d = copy.deepcopy(a)
 
print(s[0] is a, s[0] is s)     # True  False
print(d[0] is a, d[0] is d)     # False True

The shallow copy of a list that contained itself does not contain itself: its single cell points at the original. The cyclic structure is gone, even though it was the very thing being copied. The deep copy preserved the cycle.

Mechanism 4: what neither of them copies

The list is spelled out in the documentation.

And here is the divergence that looks like an interpreter bug every time:

Immutability has nothing to do with it. Lib/copy.py holds two different sets of atomic types: copy's contains tuple, frozenset, slice and super, deepcopy's does not. frozenset and slice therefore take the long road through __reduce_ex__, and deepcopy builds a new object. A tuple is a separate case, covered right below. The result is identical on 3.11, 3.12, 3.13 and 3.14.7.

A tuple of immutables is a separate case, and not one about the sets of types: _deepcopy_tuple copies the elements, compares each with the original and, if none of them changed, returns the original tuple.

Mechanism 5: __init__ is not called

This is the consequence people learn about late and expensively.

class Connection:
    def __init__(self, dsn):
        self.dsn = dsn
        self.socket = open_socket(dsn)
 
c1 = Connection("postgres://…")
c2 = copy.copy(c1)
c3 = copy.deepcopy(c1)

Neither copy calls __init__ — zero calls for two copies, verified with a counter. Both go through __reduce_ex__ and restore __dict__ directly. Which means:

• argument checks that live in the constructor do not run;
• resources the constructor opens are not opened — they are copied like any other field. The shallow copy gets the very same socket. The deep one makes no exception for it: it tries to copy the socket as an ordinary field, and on a real socket that usually ends in an error. This is exactly why the documentation lists such types separately.

If an object holds something that must not be copied, the hook is written by hand:

class Connection:
    def __deepcopy__(self, memo):
        new = Connection.__new__(Connection)
        memo[id(self)] = new                       # BEFORE walking the fields
        new.dsn = copy.deepcopy(self.dsn, memo)    # memo is passed along
        new.socket = open_socket(new.dsn)
        return new

Two lines here are non-obvious, and both are documented. Writing into memo before walking the fields — otherwise an object referring to itself recurses forever. And passing memo as the second argument: "If the __deepcopy__ implementation needs to make a deep copy of a component, it should call the deepcopy() function with the component as first argument and the memo dictionary as second argument." Without that second argument, the very thing the table exists for falls apart.

Copying is not restoring an invariant

Hence a practical rule worth saying in full: a copy is a snapshot of fields, not an object built afresh. Everything the constructor was responsible for — validating the dsn, the open socket, the registered handler — is in the copy either missing or shared with the original.

Which is why deepcopy has neighbours that often turn out to be what you actually wanted. They are not replacements — they solve different problems, and the choice is made by the problem, not by the price:

deepcopy stays where what you need is exactly a snapshot of the graph with all its internal links — and there it has no substitute.

Deeper: what it costs

What follows from the picture is not "use pickle" but two rules.

A record in the measurement is {"id": i, "tags": ["a", "b"], "meta": {"x": i}}: three levels and four objects per record, that is, four thousand objects for a thousand records. That is where the ×1809 comes from — which makes it a multiplier for that shape of data, not a property of deep copying as such: on another shape it will be another number. What travels is not the multiplier but the dependency it came from.

First: the cost of a deep copy grows with the number of objects, not the volume of data. Ten thousand numbers in a list copy in 2.3 ms; ten thousand one-element lists take 10 ms. The same count of numbers, nearly the same volume; the second case adds ten thousand lists that have to be walked and built anew. The ints themselves are not copied at all — they are atomic and come back as they are.

Second: a deep copy is recursive. At a nesting depth of 498 with the default sys.getrecursionlimit() == 1000 it fails with RecursionError — that is, it burns two stack frames per level. A five-hundred-level tree cannot be copied, and you find out in production.

A word on the fast substitutes. A pickle round trip is 5.8 times faster than the deep copy — a different comparison from "comprehension against slice" above; the ratio merely coincides. It preserves both object sharing and cycles, but requires the object to be picklable, and a socket, a file or a closure is not. json is 2.7 times faster and changes types silently: {1: (2, 3)} comes back as {'1': [2, 3]}, and on a cycle it raises ValueError. Copying by hand along a known shape is 14.2 times faster precisely because the shape is written into it by hand — and it holds until the first new field.

How to answer in an interview

Short answer: assignment copies nothing — it is a second name for the same object; copy.copy builds a new top-level object and leaves the nested ones shared; copy.deepcopy reaches the nested ones too. The difference shows only when you change something nested: after a shallow copy the change is visible from both sides, after a deep one it is not.

That is enough for a correct answer. What follows is what you add when the interviewer digs.

If the interviewer digs deeper

The precise wording for a deep copy is not "it copies the whole tree" but "it builds a copy of the object graph through the copying protocol, remembering what it has already copied". Two properties follow, and they are the reason for being precise: a cycle does not send the copying into infinity, and an object that sat under two keys is still one object in the copy — deep["a"] is deep["b"] is True.

And three things that are rarely named yet cost the most: __init__ is not called even once; deepcopy is recursive and bounded by the stack limit; the cost is counted in objects, not bytes.

Next they ask

Common misconceptions

Version history

Practice

Two exercises. Answer first, then check against the real output: in both, the right answer comes from a recorded run rather than from an editor.

import copy

inner = {"n": 1}
outer = {"a": inner, "b": inner}
deep = copy.deepcopy(outer)
shallow = copy.copy(outer)

print(deep["a"] is deep["b"])
print(deep["a"] is inner)
print(shallow["a"] is inner)

True
False
True

False
False
True

True
True
True

False
False
False

Check yourself

What measured this

The numbers in this article come from these scripts. Each one opens from here, together with the record of the run: what it was measured on, what came out, and with what spread.

• bench/copy/cost.py
• bench/copy/graph.py