Mutability, rebinding and copying

After this page, you should be able to:

• Predict mutation, rebinding and parameter effects by following shared references.

• Choose shallow/deep copying and fresh defaults using explicit sharing contracts.

Builds on: Names, slots, attributes, identity and equality.

Code languages: Python defines the explanations, figures and self-checks. Use the language guide for native conventions and dependencies. Complete runnable topic examples: Python · JavaScript · Julia.

These are language comparisons: Python-specific identity, type-hint and default-argument explanations remain about Python. JavaScript arrays use identity equality; the comparison example checks contents explicitly. Julia uses mutable structs and function-style methods; its default expressions, like JavaScript’s, are evaluated per call.

When a program seems to change two variables at once, the underlying cause is often shared access to one mutable object. Trace the objects and references before deciding what changed.

Mutable and immutable objects¶

An object is mutable if its state can change after creation. Lists, dictionaries and sets are familiar mutable types. Integers, floats, Booleans, strings and tuples are immutable types.

Immutability concerns the object itself. A tuple’s sequence of references cannot be replaced or extended, but an object referenced from that tuple may still be mutable:

record = ("KR", [12, 15])
record[1].append(18)
print(record)  # ('KR', [12, 15, 18])

// Freeze the outer record, not the array it refers to.
const record = Object.freeze(["KR", [12, 15]]);
record[1].push(18);
console.log(record); // ["KR", [12, 15, 18]]

record = ("KR", [12, 15])
push!(record[2], 18)
println(record) # ("KR", [12, 15, 18])

The tuple still refers to the same string and list. The list’s state changed. Assigning a different list to record[1] would raise TypeError.

Mutation changes an object; rebinding changes a name¶

route_a = ["KR", "MUS"]
route_b = route_a
route_b.append("UTN")
print(route_a)  # ['KR', 'MUS', 'UTN']

route_b = ["CLM"]
print(route_a)  # ['KR', 'MUS', 'UTN']
print(route_b)  # ['CLM']

let route_a = ["KR", "MUS"];
let route_b = route_a;
route_b.push("UTN");
console.log(route_a); // ["KR", "MUS", "UTN"]
route_b = ["CLM"];
console.log(route_a); // ["KR", "MUS", "UTN"]
console.log(route_b); // ["CLM"]

route_a = ["KR", "MUS"]
route_b = route_a
push!(route_b, "UTN")
println(route_a)
route_b = ["CLM"]
println(route_a)
println(route_b)

append mutates the shared list, so both names initially observe its effect. The assignment of ["CLM"] creates a new list and rebinds route_b. It does not redirect route_a, which still refers to the earlier list.

For an immutable integer, count += 1 binds count to an integer representing the new result. The previous integer is not edited. Be careful generalising this to collections: list += can mutate a list, whereas list + creates a new list. The effect depends on the operation and type.

Function parameters can share the caller’s object¶

def replace_route(route):
    route = ["Botanic Gardens"]

def extend_route(route):
    route.append("Botanic Gardens")

stops = ["Kent Ridge"]
replace_route(stops)
print(stops)  # ['Kent Ridge']
extend_route(stops)
print(stops)  # ['Kent Ridge', 'Botanic Gardens']

function replace_route(route) { route = ["Botanic Gardens"]; }
function extend_route(route) { route.push("Botanic Gardens"); }
let stops = ["Kent Ridge"];
replace_route(stops);
console.log(stops); // ["Kent Ridge"]
extend_route(stops);
console.log(stops); // ["Kent Ridge", "Botanic Gardens"]

function replace_route(route)
    route = ["Botanic Gardens"]
    return nothing
end
function extend_route(route)
    push!(route, "Botanic Gardens")
    return nothing
end
stops = ["Kent Ridge"]
replace_route(stops)
println(stops)
extend_route(stops)
println(stops)

On each call, the local parameter route initially refers to the object supplied as the argument. replace_route changes only that local binding. extend_route mutates the shared list. Python does not automatically copy an argument when entering a function, and assigning to the parameter does not assign to the caller’s variable.

Both functions return None because neither returns a value explicitly. In particular, stops = extend_route(stops) would mutate the list and then bind stops to None. Similarly, list.append itself returns None; do not replace the list with its return value.

A shallow copy creates a new outer container¶

routes = [["KR", "MUS"], ["KR", "UTN"]]
backup = routes.copy()
print(backup is routes)        # False
print(backup[0] is routes[0])  # True
backup[0].append("CLM")
print(routes[0])              # ['KR', 'MUS', 'CLM']

let routes = [["KR", "MUS"], ["KR", "UTN"]];
let backup = routes.slice();
console.log(backup === routes); // false
console.log(backup[0] === routes[0]); // true
backup[0].push("CLM");
console.log(routes[0]); // ["KR", "MUS", "CLM"]

routes = [["KR", "MUS"], ["KR", "UTN"]]
backup = copy(routes)
println(backup === routes)       # false
println(backup[1] === routes[1]) # true
push!(backup[1], "CLM")
println(routes[1])

copy() duplicates the outer list, keeping references to the same inner objects. Appending to the shared first inner list affects what both outer lists expose. Appending an entirely new inner list to backup, however, would change only that outer list.

This also explains why [[]] * 3 produces three references to one inner list. Use [[] for _ in range(3)] when three independent lists are required. Chained hash tables rely on this distinction.

A deep copy follows nested structure¶

from copy import deepcopy

original = [["KR", "MUS"], ["KR", "UTN"]]
independent = deepcopy(original)
independent[0].append("CLM")
print(original[0])     # ['KR', 'MUS']
print(independent[0])  # ['KR', 'MUS', 'CLM']

let original = [["KR", "MUS"], ["KR", "UTN"]];
// structuredClone supports these plain nested arrays, not arbitrary class instances.
let independent = structuredClone(original);
independent[0].push("CLM");
console.log(original[0]);
console.log(independent[0]);

original = [["KR", "MUS"], ["KR", "UTN"]]
independent = deepcopy(original)
push!(independent[1], "CLM")
println(original[1])
println(independent[1])

For this nested-list example, deepcopy creates independent inner lists. It is not a rule that every reachable object becomes a unique copy: immutable objects may be reused, and deep copying preserves repeated sharing within the copied structure using a memo. Custom objects can also define copying behaviour. Choose the sharing policy you actually need; copying everything may be expensive or inappropriate.

Mutable default arguments persist across calls¶

Default argument expressions are evaluated when the function is defined, rather than freshly for every call. A default such as route=[] can therefore retain state from earlier calls.

def add_stop(stop, route=None):
    if route is None:
        route = []
    route.append(stop)
    return route

first = add_stop("KR")
second = add_stop("MUS")
print(first, second)  # ['KR'] ['MUS']
print(first is second)  # False

// Unlike Python, JavaScript evaluates this default at each call.
function add_stop(stop, route = []) {
    route.push(stop);
    return route;
}
let first = add_stop("KR"), second = add_stop("MUS");
console.log(first, second); // ["KR"] ["MUS"]
console.log(first === second); // false

# Julia also evaluates a default expression at each call.
function add_stop(stop, route=String[])
    push!(route, stop)
    return route
end
first_route = add_stop("KR")
second_route = add_stop("MUS")
println(first_route, " ", second_route)
println(first_route === second_route) # false

Here a missing argument selects None, and the function creates a fresh list inside the call. If the caller explicitly supplies a list, the function appends to that list. The interface deliberately distinguishes those two cases.

Read returns and sharing together¶

The route parameters are assumed to be lists when list operations are performed. These helpers do not validate arbitrary collection types. None is the missing-route convention for add_stop, not a ban on storing None as the stop value. A mutator can return None, a result or the mutated object; read the contract rather than inferring returns from the word “mutation.”

A shallow copy separates slots, not their referents. Replacing backup[0] changes only that new outer slot, while backup[0].append(...) edits a shared inner list. With deep copying, if two original slots referred to the same inner list, their copied slots normally refer to one shared copied inner list; deep copying does not turn every incoming arrow into an independent object.

Questions to revisit¶

Does the operation redirect a reference or change an object? Which references still reach that object? If a copy was made, which levels remain shared? These questions explain the result more reliably than saying “Python copies variables”.

Choose the sharing policy before counting copies¶

Use aliases when shared updates are intended, a shallow copy when outer-container independence is sufficient, and a deeper copying policy when nested mutable state must be separated. A tuple can hold a mutable list even though its own slots are fixed. Such a tuple is also unhashable in Python: immutable outer structure alone does not guarantee a valid dictionary key. Hashability develops that separate requirement.

A shallow copy of n list slots takes work and new outer storage growing with n. Deep-copy cost depends on the reachable structure and any custom copying behaviour, not merely the outer list length. Assignment to a local name does not perform either traversal. The analysis topic formalises these costs and distinguishes copied reference slots from deeply copied objects.

Check your understanding¶

Predict the result or draw the references before opening the explanation.

1. After backup=routes.copy(), backup[0] is replaced with a new list. Does this replace routes[0] too?

2. Two calls to add_stop omit the route argument. Do their returned lists share identity? What if both calls supply the same list?

Next: Collections, classes and invariants.

Browse: Foundations · Concept index