Create a Shallow Copy of a List

00:00 But how can you create a copy? Let’s reset the matrix list to the initial values

00:07 and then I’ll show you how you can create a shallow copy in Python. You can use a similar syntax to the one that didn’t work for what we’re intending to do, but instead of saying just the_matrix = matrix, at the end of the original list, you’re going to use slice notation.

00:25 So open square brackets, close them and put a colon in between. Now, if you remember how slicing works, this shortcut says take everything that’s inside of the list, like from the beginning to the end.

00:38 By leaving out the two index numbers on the left and the right side of the colon, you just take the whole list.

00:44 So this syntax creates a shallow copy of the list, which means that the ID of the_matrix is now different to the ID of matrix.

00:57 You can see that they point to different numbers because now the_matrix and matrix are two different objects in memory, two separate lists.

01:07 So now you can do what you tried to do before, and it’ll work out. So if I now go ahead and say the_matrix[1] and change the element on index one to the names of the two movie characters, and then I can look at the_matrix, and it does what you expect it to do.

01:24 But matrix didn’t change in that case because like I said, the_matrix and matrix are now two separate objects in memory.

01:32 So this is how you can create a shallow copy in Python. You can use the [:] slice notation, and that’ll create a separate list object in memory.

01:47 Okay, but the trickiness with copying lists doesn’t end here because a shallow copy doesn’t actually copy everything that’s inside the list. It just copies the references inside.

01:59 You can see that the two lists that you’re working with here, the_matrix and matrix, they contain other lists. And these list objects don’t actually contain the objects.

02:07 They just contain references to those objects, which means that the same issue that you’ve dealt with earlier still applies on a shallow copy if you step one level lower.

02:19 Let’s try that out. I’ll start again with resetting. No, I don’t need to reset anything because matrix still looks the same. Okay, if you now went ahead and you wanted to change inside of the_matrix, you want to change also something in the first list that’s contained by the_matrix.

02:38 So you access the first element in the_matrix, which is this list of two integers, 1 and 2, and now you want to change the first element of that list.

02:47 So I’m going to say the_matrix[0][0], and that should point to the integer 1 in here. And now I want to change this one to also be the name of a character.

02:58 So let’s change that to "Morpheus".

03:03 Okay. the_matrix changed as you expect it to. Now it contains still two lists, but the first list now also has one name of a movie character, and one is still the integer from before.

03:14 However, if you now look at matrix, then you’ll see that "Morpheus" also appears in here. And why is that? Because like I said before, the two separate list objects, the_matrix and matrix only contain references to the other list objects in there.

03:31 So they don’t actually contain a list [1, 2] but they contain a reference that points to another list object that sits somewhere in memory and contains the values 1 and 2.

03:42 And if you create a shallow copy like you did before using the slice notation, you don’t create separate objects from the containing lists. So if you look at id(the_matrix[0]), so the first element in the_matrix, which is this list, or well now it looks like that it contains now "Morpheus" and 2.

04:06 So that’s the big number of its memory location. And if you do the same thing on matrix,

04:12 get the first element in matrix again, you can see that these big numbers point to the same object.

04:23 So the takeaway here is that shallow copies contain copied references. They don’t copy the objects inside of it, but they just contain a copied reference, which means that if you do a change to a mutable object in there, again, you’ll have the same issue that you’re changing the object.

04:39 And that will be reflected in any other object that has a reference to that changed object.