Once an object is instantiated based on its class definition, what can we do wit

# ** Method 1: **
>>> list_b = [1, 2, 3]
>>> id(list_b)
140419576066824
>>> list_b += [4]
>>> list_b
[1, 2, 3, 4]

>>> id(list_b)
140419576066824
# the object ID does not change as expected

# ** Method 2: **
>>> list_b = list_b + [5]
>>> list_b
[1, 2, 3, 4, 5]

>>> id(list_b)
140419576066936
# the object ID changed! But this is not evidence that lists are
# immutable

h it? We can make changes to the object, but only if it is mutable.

Mutable objects

The definition of mutable means liable to change according to a quick Google search. In context of objects, mutable objects are objects that can change in place without having their IDs and type change. Let’s take a look at a list object:

>>> list_a= [1, 2, 3]
# list_a is a list type object with 3 elements

>>> id(list_a)
140423986856648
# this is the current ID of our list_a

>>> list_a.append(4)
# let's add a new element 4 to the list

>>> list_a
[1, 2, 3, 4]
# we see that 4 has been added

>>> id(list_a)
140423986856648
# the ID of list_a has not changed!

There are many other types that are mutable such as: bytearray, set, and dict. However a caveat: Depending on how you’re affecting change to these mutable types, a new object can be created, thus giving an impression the variable is immutable. For example:

The above example is a clear demonstration of changing a list in two different ways gives two different implications. The first way retains the ID, and thus shows the list is mutable. The second way does not retain the ID which confuses the matter. So is a list mutable or immutable? What we need to do is pay attention to how the expression is evaluated.

In Method 2, we changed the list using the list = list + element expression. This in fact creates a new object as shown, but it did not actually make changes to the object! It merely created a new object using the previous list plus the new element, and then assigned in back to the original pointer. The original object that contained [1, 2, 3, 4] is now sitting somewhere waiting to be garbage collected. The idea behind Method 2 is that even though on the surface it appears the list is not mutable, it actually is.

Another way to understand mutable objects is to use the value equality operator and the object ID comparison operator.

>>> a = [1, 2]
>>> b = [1, 2]
>>> a == b
True
>>> a is b
False
>>> id(a) == id(b)
False

From the above demonstration, both lists a and b have the same exact values, but their object IDs are different. This is the way of mutable objects to keep in mind.

Immutable objects

Immutable objects are objects that cannot change their contents. They are unchanging — aka immutable. Some examples of immutable objects are int, float, str, tuples, and frozenset.

Immutable objects are called immutable because once the object is allocated space in memory, it can no longer change. The ID of the object along with the contents of the object will not change. If we were to create an immutable object, and then we wanted to change it’s value, then what would happen is a new object is created in a new address space. Then the pointer would point to the new object. The first object will remain in memory until garbage collection gets rid of it. For example:

>>> a = "Hi"
>>> id(a)
140419576066824
# the string object contains the characters "Hi"
>>> a
Hi

>>> a += "t"
>>> id(a)
140419576066936
# as shown here, the ID has changed because strings are immutable
>>> a
Hit

>>> b = "Hi"
>>> id(b)
140419576066824
# the new pointer for object b resumes the previous a ID

Let’s try using the value equality operator and the object ID comparison operator.

>>> a = "Hi"
>>> b = "Hi
>>> a == b
True
>>> a is b
True
>>> id(a) == id(b)
True