Shallow copies, deep copies, and call by sharing

Lesson 1 showed that assignment never copies: b = a gives one object two names. Copying is a deliberate act, and it comes in two depths.

Shallow and deep

A shallow copy builds a new outer container and fills it with the same inner objects. list(x), x[:], x.copy(), dict(d), {**d} and copy.copy(x) are all shallow. For a flat list of numbers or strings that is all you need; for a list of lists, or a dict of lists, the inner containers are still shared, and mutating one through the copy changes the original.

A deep copy, copy.deepcopy(x), copies recursively, so nothing mutable is shared with the original. It keeps a memo of what it has already copied: two references to one inner list become two references to one new list in the copy, and a structure that contains itself does not send it into an endless loop.

1import copy2 3 4def run():5    config = {"name": "api", "ports": [80, 443]}6    shallow = config.copy()7    deep = copy.deepcopy(config)8 9    shallow["name"] = "worker"   # rebinding a key: only the copy changes10    shallow["ports"].append(8080)  # mutating a shared list: both change11    deep["ports"].append(9090)12 13    row = [1, 2]14    pair = [row, row]15    pair_copy = copy.deepcopy(pair)16    return {17        "config": config,18        "shallow": shallow,19        "deep": deep,20        "copy_rows_shared_with_each_other": pair_copy[0] is pair_copy[1],21        "copy_rows_shared_with_original": pair_copy[0] is row,22    }

The grid trap, and += on a list

[0] * 3 is fine: it repeats references to an immutable 0. But [[0] * 3] * 3 repeats a reference to one row list three times, so writing one cell writes a column. Build each row separately: [[0] * 3 for _ in range(3)].

+= on a list is extend: it mutates the list in place, so every other name for it sees the change. x = x + [4] instead builds a new list and rebinds only x. The same in-place step explains a famous puzzle: t[0] += [2] on a tuple holding a list raises TypeError — and the list has grown anyway, because the extend succeeded before the tuple refused the assignment back into its slot.

1def run():2    bad = [[0] * 3] * 33    bad[0][0] = 14    good = [[0] * 3 for _ in range(3)]5    good[0][0] = 16 7    a = [1, 2]8    alias = a9    a += [3]          # in place: alias sees it10    b = [1, 2]11    b_alias = b12    b = b + [3]       # new list: b_alias does not13 14    t = ([1],)15    try:16        t[0] += [2]17        outcome = "no error"18    except TypeError as e:19        outcome = f"TypeError: {e}"20    return {"bad": bad, "good": good, "alias_after_iadd": alias,21            "alias_after_plus": b_alias, "tuple_error": outcome,22            "tuple_now": t}

How arguments are passed

Python passes a reference to the object, by value — often called call by sharing. Inside the function the parameter is a new name for the caller's object. Mutating that object (items.append(...)) is visible to the caller. Rebinding the parameter (items = [...]) only changes what the local name points at, and the caller never sees it. Neither "by value" nor "by reference" in the C++ sense describes it.

1def add_item(items):2    items.append("added")3 4 5def replace_items(items):6    items = ["replaced"]7    return items8 9 10def run():11    mine = ["start"]12    add_item(mine)13    returned = replace_items(mine)14    return {"mine": mine, "returned": returned}

Common mistakes

• Taking list(config) or config.copy() of nested data and then editing a nested part "in the copy". The original changes too.
• Building a grid or a list of lists with *, so every row is the same object.
• Expecting a function to replace the caller's list by assigning to its parameter. Mutate it, or return the new one.

What interviewers ask

• What is the difference between copy.copy and copy.deepcopy? New outer object with shared contents against a full recursive copy; deepcopy's memo preserves shared references and handles cycles.
• Is Python pass-by-value or pass-by-reference? Neither exactly: object references are passed by value, so mutation is shared and rebinding is not.
• What does [[0] * 3] * 3 produce? Three references to the same inner list; use a comprehension.