What is Mutability?

In programming terminology, a mutable object is one whose state can be changed after its creation. Conversely, an immutable object is defined such that its state cannot be altered once established. In Python, integers, floats, strings, and tuples are examples of immutable objects. Conversely, lists and dictionaries are the most common mutable objects you will encounter.

To illustrate the difference between mutability and immutability, let’s consider the following example involving a list of songs:

my_songs = ["All Too Well", "No Tears Left to Cry", "Cruel Summer"]

my_songs[1] = "Champagne Problems"

print(my_songs) # Output: ['All Too Well', 'Champagne Problems', 'Cruel Summer']

In this case, replacing a song in the list is straightforward due to the list’s mutable nature. On the other hand, if I define a string and accidentally misspell it, attempting to modify it results in an error:

my_song = "All Too Wall"

my_song[9] = 'e' # Raises a TypeError

Once defined, the content of a string cannot be modified. To correct the spelling, I must create a new string.

It’s important to recognize that functions like append, extend, and update exploit the mutability of lists and dictionaries, making them valuable for managing data and executing programming tasks. However, if a programmer is unaware of how mutability functions behind the scenes, it can lead to bugs and unexpected behavior.

A Detailed Example of Why This Matters

To illustrate the significance of understanding mutability, I will define two functions—one that operates on an integer and another that operates on a list. This will help clarify the implications of working with mutable objects.

# Add 6 to a number

def add_6_to_number(num):

num = num + 6

# Append 6 to the end of a list

def append_6_to_list(lst):

lst.append(6)

Let’s examine the effects of these functions on an integer and a list:

num = 10

add_6_to_number(num)

print(num) # Output: 10

list_num = [10]

append_6_to_list(list_num)

print(list_num) # Output: [10, 6]

The integer remains unchanged, while the list is modified. This difference arises from how Python handles mutable objects when they are passed into functions.

To visualize this, I’ve included images from Python Tutor that illustrate what happens during the execution of the add_6_to_number function.

The key takeaway is that when add_6_to_number is invoked, a copy of the variable num is created, and this copy is modified inside the function. The original variable remains unchanged. This behavior applies to all immutable objects, which are copied when passed into functions.

Now, let’s look at the corresponding diagrams for the list:

Notice the critical difference? Because lists are mutable, Python passes a reference to the existing list into the append_6_to_list function. Consequently, any changes made inside the function are reflected outside as well.

Final Thoughts

The foundation of data science is deeply rooted in statistics, often leading educational programs to neglect essential concepts in computer science, which can result in subpar code that is challenging to maintain. Lists and dictionaries are fundamental data structures in Python, extensively utilized in the data science library, Pandas. Thus, understanding how Python manages these objects is crucial for effective coding.

I hope the insights shared in this article prove beneficial for your programming journey.

Until next time!

The first video, Immutable vs Mutable Objects in Python, provides a clear explanation of these concepts and their significance in programming.

The second video, Easy Syntax in Python: Mutable vs Immutable Data Types, simplifies the topic further, making it accessible for all learners.