Mutability and references

Two names, one list

Predict what this prints.

a = [1, 2]
b = a
b.append(3)
print(a)

[1, 2, 3]

If you said [1, 2], you pictured b = a making a second list. Step through what really happens: each arrow shows which value a name refers to.

Python calls each value an objectobjectA value in Python's memory: a number, a string, a list. Names refer to objects, and several names can refer to the same object.. After line 2 there is one list object with two names on it. So the rule is: assignment never copies. b = a means "b now refers to the object a refers to". The two names aren't tied together; they just share one object. Now a subtle one:

Changing an object and moving a name are different things. y.append(2) or y[0] = 2 would change the list, and x would see it. y = [2] only moves the name y.

The same object, or equal?

== asks "same value?". is (from lesson 2.4) asks "same object?". Here c is a separate list with the same numbers:

a = [1, 2, 3]
b = a
c = [1, 2, 3]
print(a == c)
print(a is b)
print(a is c)

Two equal lists are == but not is. Compare values with ==; keep is for None, or for when you really mean "the same object".

Why numbers and strings never surprise you

Now the same shape of program with a string. Predict:

s = "ab"
t = s
t += "c"
print(s)

ab

Strings and numbers can't change, so sharing one never surprises you: t += "c" and n += 1 make new objects.

A list can change. Predict this one:

a = [1, 2]
b = a
b += [3]
print(a)

[1, 2, 3]

So b += [3] and b = b + [3] are not the same for lists: + builds a new list and moves b to it. Run this, then change line 3 to b = b + [3] and run it again: a stays [1, 2].

a = [1, 2]
b = a
b += [3]
print(a)

The grid bug

You want a 3 by 3 grid of zeros, then set the top-left square to 1. Predict.

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

[[1, 0, 0], [1, 0, 0], [1, 0, 0]]

[row] * 3 doesn't copy the row. It makes a list whose three slots all refer to the same row:

[0] * 3 repeats the number 0 the same way, but numbers can't change: grid[0][0] = 1 moves the row's slot 0 to a new number. The shared row is what changed.

The fix is a comprehension (lesson 4.7), which runs [0] * 3 again for every row. The name _ is a convention for "a name I won't use":

grid = [[0] * 3 for _ in range(3)]
grid[0][0] = 1
print(grid)

It's as if you wrote [0] * 3 three times. Step through and watch three separate rows appear:

Making a real copy

When you do want a second list, ask for one: .copy() or list(...) both make a new list with the same items.

a = [1, 2]
b = a.copy()
b.append(3)
print(a)
print(b)

But what if the items are lists themselves? Predict:

data = [[1, 2], 3]
backup = data.copy()
data[0].append(9)
print(backup)

[[1, 2, 9], 3]

.copy() copies only the outer list: a shallow copyshallow copyA copy of the outer list only. Its slots refer to the same objects as the original's, so inner lists are shared.. For a copy all the way down, use deepcopy from Python's copy module (imported like random in lesson 3.5):

backup's slot 0 refers to the same inner list as data's. safe has its own inner list, so the 9 never reaches it. (The 3 can't change, so sharing it is harmless.) Forget the import and Python says what's missing:

The rule

One sentence covers all of it: assignment never copies; names refer to objects, and changing an object is seen through every name that refers to it. An object that can change is mutablemutableCan be changed after it's made. Lists, dicts, and sets are mutable; numbers, strings, and tuples are immutable.: lists, dicts, and sets. Numbers, strings, and tuples are immutable. This rule comes back in Module 5, where a list used as a function's default value surprises people.