Mutable and Immutable Objects in Python

Python is a dynamically typed language which means variables can hold different types of data without explicitly declaring their data type. However, one important concept every Python programmer should understand is mutability.

In Python, every value is an “object” and objects are classified into two categories based on whether their values can be changed after creation:

• Mutable objects: Can be modified after creation.
• Immutable objects: Cannot be modified after creation.

In this article, we will learn about mutable and immutable objects, their differences, and best practices to write better Python code.

What Are Mutable and Immutable Objects?

Mutable Objects

Mutable objects are those whose values can be changed after creation. When you modify a mutable object, its memory address remains the same, but the content changes.

Examples of Mutable Objects:

• Lists (list)
• Dictionaries (dict)
• Sets (set)
• User-defined objects (if defined with modifiable attributes)

List: You can add, remove, or modify elements in a list.

my_list = [1, 2, 3]
my_list.append(4)  # Modifies the original list
my_list[0] = 10    # Modifies the original list
print(my_list)      # Output: [10, 2, 3, 4]

Dictionary: You can add, remove, or modify key-value pairs in a dictionary.

my_dict = {"a": 1, "b": 2}
my_dict["c"] = 3  # Modifies the original dictionary
del my_dict["a"]    # Modifies the original dictionary
print(my_dict)      # Output: {'b': 2, 'c': 3}

Set: You can add or remove elements from a set.

my_set = {1, 2, 3}
my_set.add(4)    # Modifies the original set
my_set.remove(1) # Modifies the original set
print(my_set)      # Output: {2, 3, 4}

Immutable Objects

Immutable objects cannot be modified after they are created. Any operation that seems to modify an immutable object actually creates a new object in memory with the updated value.

Examples of Immutable Objects:

• Integers (int)
• Floating-point numbers (float)
• Strings (str)
• Tuples (tuple)
• Booleans (bool)
• Frozen sets (frozenset)

Integer, Float, Complex: Numeric values cannot be changed in place.

x = 10
y = x       # y now refers to the same object as x
x = x + 5   # Creates a new object with the value 15; x now refers to this new object. y remains unchanged
print(x)    # Output: 15
print(y)    # Output: 10

String: Strings cannot be modified directly. Operations that appear to modify a string create a new string.

s = "hello"
t = s
s = s + " world"  # Creates a new string "hello world"; s now refers to this new string. t remains unchanged.
print(s)          # Output: hello world
print(t)          # Output: hello

Tuple: Tuples are ordered sequences of elements that cannot be changed after creation.

my_tuple = (1, 2, 3)
# my_tuple[0] = 10  # This would raise a TypeError: 'tuple' object does not support item assignment
new_tuple = my_tuple + (4, 5) # Creates a new tuple. my_tuple remains unchanged
print(my_tuple) # (1, 2, 3)
print(new_tuple) # (1, 2, 3, 4, 5)

Boolean: Boolean values (True and False) are immutable.

a = True
b = a
a = False # Creates a new boolean object
print(a) # False
print(b) # True

Frozen Set: Frozen sets are immutable versions of sets. You cannot add or remove elements.

my_frozenset = frozenset({1, 2, 3})
# my_frozenset.add(4) # This would raise an AttributeError

Function Arguments and Mutability

The mutability of objects plays an important role when we pass them as arguments to functions:

Mutable arguments: If we pass a mutable object to a function and the function modifies the object, the changes will be visible outside the function as well. This is sometimes referred to as “pass by object reference” or “pass by sharing”.

def modify_list(lst):
    lst.append(4)  # Modifies the list in place

my_list = [1, 2, 3]
modify_list(my_list)
print(my_list)  # Output: [1, 2, 3, 4]

Immutable arguments: If we pass an immutable object to a function and the function appears to modify the object, the function actually creates a new object. The original object remains unchanged.

def modify_string(s):
    s = s + " world"  # Creates a new string

my_string = "hello"
modify_string(my_string)
print(my_string)  # Output: hello (the original string is unchanged)

Common Mistakes and Best Practices

👉Be careful when you’re using mutable objects as default arguments in function definitions. The default value is created only once, when the function is defined. If the function modifies the mutable default argument, that modification persists across subsequent calls.

def my_function(my_list=[]):  # Avoid this!
    my_list.append(1)
    print(my_list)

my_function()  # Output: [1]
my_function()  # Output: [1, 1]  (Unexpected!)

To avoid this, use None as the default and create the mutable object inside the function:

def my_function(my_list=None):
    if my_list is None:
        my_list = []
    my_list.append(1)
    print(my_list)

my_function()  # Output: [1]
my_function()  # Output: [1]  (Correct behavior)

👉When you need to modify a mutable object without affecting the original, create a copy of it. You can use the copy() method (for lists, dictionaries, and sets) or the deepcopy() function from the copy module for more complex objects.

original_list = [1, 2, 3]
copied_list = original_list.copy()  # Create a shallow copy
copied_list.append(4)
print(original_list)  # Output: [1, 2, 3]
print(copied_list)    # Output: [1, 2, 3, 4]

Differences Between Mutable and Immutable Objects

Summary

• Mutable objects (like lists and dictionaries) can be modified after creation, while immutable objects (like strings and tuples) cannot be changed.
• Immutable objects are hashable and can be used as dictionary keys, while mutable objects cannot.

This concept will help you write better-optimized Python code.