Copying a list using a[:] or copy() in python is shallow?

Question

Say I have a list a with some values, and I did a b = a[:]. Then modifying the contents of list b won't change list a as per what I've read. So, this means its a deep copy. But python documentation still refers to this as shallow copy. Can someone clear this for me?

Answer 1

To demonstrate what shallow copy means:

a = [ [1,2], [3,4,5] ]
b = a[:]  # make a shallow copy
a is b  # not the same object, because this is a copy
=> False
a == b  # same value, because this is a copy
=> True
a[0] is b[0]  # elements are the *same objects*, because this is a *shallow* copy
=> True

Changing the structure of a will not be reflected in b, because this is a copy:

a.pop()
len(a)
=> 1
len(b)
=> 2

To demonstrate the difference from a deep copy: changing an object contained in a (as opposed to a's structure) in-place, is reflected in b, because b references the same objects as a.

a[0][0] = 'XYZ'
b[0]
=> ['XYZ', 2]

Answer 2

From python docs

The difference between shallow and deep copying is only relevant for compound objects (objects that contain other objects, like lists or class instances):

A shallow copy constructs a new compound object and then (to the extent possible) inserts references into it to the objects found in the original. A deep copy constructs a new compound object and then, recursively, inserts copies into it of the objects found in the original.

Shallow copy creates a new object only for the top level/object, then copies by reference all sub-objects. Deep copy creates new object for the top object/level and for all sub-objects too.

Answer 3

Then modifying the contents of list "b" won't change list "a" as per what I've read.

As in, if you take out some of the contents or switch them out for other contents, it won't affect a. Mutations to the objects held in b will be visible through both lists, because both lists hold the same objects.

>>> class Mutable(object):
...     def __init__(self, x):
...         self.x = x
...     def __repr__(self):
...         return 'Mutable({})'.format(self.x)
...
>>> a = [Mutable(1), Mutable(2)]
>>> b = a[:]
>>> del b[1]  # Doesn't affect a
>>> a
[Mutable(1), Mutable(2)]
>>> b[0].x = 5  # Visible through a
>>> a
[Mutable(5), Mutable(2)]

Answer 4

Then modifying the contents of list "b" won't change list "a" as per what I've read. So, this means its a deep copy.

No, it does not. A shallow copy differs from a deep copy in whether contained values are copied or not.

In your case, the list is copied, but the two resulting lists will contain the same objects. Adding or removing a value in one list won't affect the other list, but changes to a contained object will be reflected.