Howdy Coder,

Mutable objects are one of the trickiest things to understand as a Python beginner.

If you don't understand mutations, you don't understand why certain variables' values change, without you touching them. Eg,

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

prints [1, 2, 3, 4], which is surprising if you don't know what is happening.

Sometimes, though, you want to isolate your variables in such a way that modifying one doesn't change the other.

For example, you might want b to be initialized to a, but remain separate from a.

One way to do is by using the .copy method of lists:

a = [1, 2, 3]
b = a.copy()  # <--- .copy applied before assignment
a.append(4)
print(b)

Here a change in a didn't cause a change in b.

Is it always safe, though?

Let's try a more involved example:

a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
b = a.copy()  # <--- .copy applied before assignment
a.append(10)
a[-1].append(0)
print(b)

What do you expect the output to be?

[[1, 2, 3], [4, 5, 6], [7, 8, 9, 0], 10], or
[[1, 2, 3], [4, 5, 6], [7, 8, 9]], or
something else?

Turns out that it is [[1, 2, 3], [4, 5, 6], [7, 8, 9, 0]].

How did that happen?

The trick is in the .copy.

.copy copies only the outermost container.

a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
b = a.copy()  # <--- .copy applied before assignment

print(a is b)  # This is False because a & b are distinct containers

# But all these are True, because the contents are shared

print(a[0] is b[0])
print(a[1] is b[1])
print(a[2] is b[2])

So, although a and b are made separate containers, they still share their contents.

Such a copy is called a shallow copy, where only the container is distinct, but contents are shared.

So, a mutation made to the content of a, like a[-1].append(0), will cause a change to b.

That means, a simple .copy is not enough to create an isolated copy of a nested list.

That is where the copy module of the standard library comes in handy.

Let's import deepcopy from it using

import copy import deepcopy

deepcopy performs a deep copy, rather than a shallow copy.

It copies the container as well all the contents.

a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
b = deepcopy(a) # <--- deepcopy applied before assignment
print(a is b)  # This is False because a & b are distinct containers

# Now all these are False, because the contents are also distinct copies

print(a[0] is b[0])
print(a[1] is b[1])
print(a[2] is b[2])

So, now we finally have distinct copies of objects, no matter how deeply nested they are.

This is useful to create isolated but equal copies of objects.

That's all for this time, see you in the next one!

Co3

0 comments

What Nobody said: When you can't get the right output, at least...

What Nobody said: When you can't get the right output, at least...

Pickling - Save any Python object to a file

Pickling - Save any Python object to a file

Reading and Writing CSVs as Dictionaries

See all posts from Coding Computing Coach