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

Why Python treats mutable and immutable objects differently

The million dollar question regarding mutable and immutable objects in Python: Why are there two types? Is there some grand overall design decision why some objects are allowed to have their contents changed, while others are simply replaced all together?

According to Sean Conroy’s article, Mutable vs Immutable objects in Python, the primary reason for having mutable and immutable objects is that this allows for efficient handling of changing content.

For example, we can place multiple immutable strings into a mutable object like a list. Then using the list, we can then manipulate the different strings and concatenate them together without using additional space. If we were to perform concatenation on a group of strings without using a mutable object, then at each sub-stage during concatenation, additional memory space would be needed to hold the new string. This would be a colossal waste of resources.

---

How arguments are passed to functions and what does that imply for mutable and immutable objects

Every argument in Python is passed to functions in a process called Call-by-Object. What this means is that how the function handles the argument is entirely based on the type of object. In context of Python, the object being mutable or immutable is the determining factor.

For example, if we pass an integer into a function, then the function will treat the integer argument as “pass-by-value” because an integer is immutable. If a list was passed into a function, then the function will treat it like a “pass-by-reference” and can make changes to the contents of the list that will actually affect the caller’s list.

Understanding this subtle difference will help make working with objects in Python easier. Please consult the below sources for further reading and reference.

---

Sources

9. Lists – How to Think Like a Computer Scientist: Learning with Python 2nd Edition documentation
A list is an ordered set of values, where each value is identified by an index. The values that make up a list are…www.openbookproject.net

Immutable vs Mutable types
I’m confused on what an immutable type is. I know the float object is considered to be immutable, with this type of…stackoverflow.com

2.4 Mutable Data
One powerful technique for creating modular programs is to incorporate data that may change state over time. In this…composingprograms.com

Python tuples: immutable but potentially changing
Python tuples have a surprising trait: they are immutable, but their values may change. This may happen when a tuple…radar.oreilly.com

Mutable vs Immutable objects in Python – I Don’t Know, Read The Manual
There are two types of objects in Python, Mutable and immutable objects. Mutable objects are more flexible in that…www.idkrtm.com

Python2 Tutorial: Passing Arguments
The passing of parameters and arguments in Python. Difference in Python to call by value and call by name.www.python-course.eu