Switching to Mutable Built-in Data Types: Lists

00:00 Let’s now look at Python’s built-in mutable types. And we can start with the lists. So you can create a list of digits, 0, 1, 2, 3, 4, 5, 6, 7, 8, and 9.

00:13 A list is mutable, which means we can change its values as you’ve seen before. But first, let’s look at the identity of digits. So what is the identity of the object that the variable name digits is pointing to?

00:28 And CPython gives us a number, which is the memory location of this object, ends with 8688. We’re going to use this to see whether the object changes to a new object or stays the same.

00:42 Let’s pick a digit, for example, the last one, and we’d like to change it to 100 instead of 9. So digits is now 0, 1, 2, 3, 4, 5, 6, 7, 8, and 100.

00:55 But the question is, is this the same object or is it the new object? It is the same object. The identity is still the same number ending in 8688.

01:06 Therefore, the same object, the object that has the same identity that’s in the same location and memory can change. In this case, you change the last value from 9 to 100 and you can have a look at what happens with some of the list methods.

01:22 For example, let’s now append 200 to the list digits. So digits is now the same as before, but there’s an extra 200 at the end and the identity of digits has not changed.

01:34 It’s the same number ending in 8688. We can delete one of the numbers. For example, delete the first number from digits. So digits is now starts with 1, but the identity is still the same.

01:49 So a mutable object such as a list remains the same object. It has the same address and memory, same location, but its contents can change. That’s what makes it mutable.

02:02 And one final example, let’s use digits.sort. But since the list I’m showing you is already sorted, let’s use reverse=True.

02:14 And this reverses the list,

02:16 but it still remains the same object. So even though all the items have changed place because they’re reverse from the original version, it’s still the same object that has mutated, that has changed into this new form.

02:33 And how about if we use the += operator. In an earlier lesson, you used the += operator with a tuple. And you’ve seen that this creates a new object.

02:44 Let’s see whether the behavior is the same or different with lists. Let us add, we need to add a list to the list `digits, let’s go for 12, 13, 15

02:56 and digits is now the list, the reverse list we had 200, 100 all the way up to 1, and then 12, 13, and 15. And the question is, is this the same object as before?

03:07 And you can see that the identity of digits is still the number that ends with 8688. This means that += keeps the same object. It does not create a new object. Why?

03:21 Because a list is mutable. This is different, however, to the following: digits = digits + and let’s this time add 20, 21 and 22. So digits is the list as it was before, and 20, 21, 22 at the end.

03:42 But, look at the identity of digits. It’s now a different number. It ends with 6672. Why? This situation is different. On the right hand side of the =, you have the name digits, which is referring to the list, the object whose identity ends with 8688.

04:01 But then you are using a + to add another list to it so this creates a new list. `digits + [20, 21, 22] creates a new object, which is a list containing all the numbers.

04:14 This new object, you are then reassigning it to the same name digits. Therefore, at the end of this statement, the variable name digits is now pointing to a new object, the one you created from the old object plus the new list.

04:30 That’s why digits = digits + [20, 21, 22] is not the same as ‘+=` because one creates a new object, whereas ‘+=` mutates the existing object.