Elements of the original list changes when a deep copy of changes

Question

I have a global list (of lists) variable. I send a shallow copy of the global list to another function as a parameter.

Surprisingly, the original list gets changed when I remove some elements from the parameter within the invoked function.

Can someone please tell me why it's happening and how to prevent this from happening?

Here is the simplified code example:

def saveCandidateRoutes(candidateRoutes):

        for route in candidateRoutes:
            if route:       # check if the list, 'route', is empty. 
                tweetId = route.pop(0)
                stanox = route.pop(-1)
                ....

def main():

        global allCandidatePaths

        copyOfAllCandidatePaths= list(allCandidatePaths) # making a deep copy 
        result = saveCandidateRoutes(copyOfAllCandidatePaths)

Answer 1

python uses references to object, it means that both allCandidatePaths and candidateRoutes point to the same list in memory, and you can use both of them to change the list.

To prevent this from happening, in the beginning of your function saveCandidateRoutes add this instruction candidateRoutes = list(candidateRoutes). The list() function will create another copy of your original list in memory and assign its reference to candidateRoutes.

So when you use candidateRoutes, you will not be working on your original list that is in the main function, but you will be working on another list.

Answer 2

I think you need a quick reminder on shallow and deep copies, and how to make a deep copy.

>>> a = [[1,2], [3,4]] # a list of mutable elements
>>> b = a[:]
>>> c = list(a)

Both b and c are shallow copies of a, you can check that a, b and c are different objects because they do not share the same id.

>>> id(a)
140714873892592
>>> id(b)
140714810215672
>>> id(c)
140714873954744

However, each element of a, b and c still is a reference to the lists [1,2] and [3,4] we created when defining a. That becomes clear when we mutate an item inside the lists:

>>> c[1][1] = 42
>>> a
[[1, 2], [3, 42]]
>>> b
[[1, 2], [3, 42]]
>>> c
[[1, 2], [3, 42]]

As you can see, the second element of the second list changed in a, b and c. Now, to make a deep copy of a, you have several options. One is a list comprehension where you copy each of the sublists:

>>> d = [sublist[:] for sublist in a]
>>> d
[[1, 2], [3, 42]]
>>> d[1][1] = 23
>>> d
[[1, 2], [3, 23]]
>>> a
[[1, 2], [3, 42]]

As you can see, the 42 in a did not change to 23, because the second list in a and d are different objects:

>>> id(a[1])
140714873800968
>>> id(d[1])
140714810230904

Another way to create a deep copy is with copy.deepcopy:

>>> from copy import deepcopy
>>> e = deepcopy(a)
>>> e
[[1, 2], [3, 42]]
>>> e[1][1] = 777
>>> e
[[1, 2], [3, 777]]
>>> a
[[1, 2], [3, 42]]

Answer 3

I think you are confused about the terms.

Shallow copy is the type of copy where the elements of the copied list are still bound to same memory value with the original list's elements.

What you are looking for is deepcopy Here is a good source to find out.

And also: Wikipedia

Answer 4

A shallow copy copies the object but not any of its attributes. For a list, that means that that its elements are assigned to the elements of the new list. If the elements are ints, you get a completely new list, because int is a primitive type*, so it doesn't need to be copied. If the elements are lists, as in your two-dimesional list, they get assigned to the copy, so you have two references to each element, one in each list. If you want to copy the elements of the inner lists, you'll need a deep copy, which recursively copies the attributes (elements, in this case) of each object.

*There isn't actually a distinction between types that are primitive and those that aren't, but this is equivalent to the way it works in the scope of this explanation.