Spot Silent Bugs: Mutable and Immutable in Python You Must Know

In Python, the terms mutable and immutable refer to an object's ability to change its state or contents after creation. Mutable objects, such as lists and dictionaries, allow modifications, while immutable objects, like strings and tuples, cannot be altered once defined.cannot be altered once defined.

This blog explores what mutable and immutable in Python, their associated data types, examples of each, and the key differences between them.

What is Mutable and Immutable in Python? Exploring its Core Principles

In Python, mutability and immutability are fundamental concepts that define how objects behave in memory. Mutable objects can be modified after creation, while immutable objects cannot. These properties directly impact memory allocation and program performance. A clear understanding of what is mutable and immutable in Python is essential for writing efficient and bug-free code.

Ready to apply your Python knowledge in data science? Check out these courses that will enhance your skills and help you enhance your career:

• Data Science PG Diploma - IIITB
• Master's in AI & Data Science - Jindal Global University
• Generative AI for Business Leaders - IIIT Bangalore

Let’s understand mutable and immutable in Python with a quick breakdown:

Let's learn in detail how mutable and immutable objects in Python affect the way variables work.

What are Mutable Objects?

Mutable objects are data types you can change after they're created. These are useful when your program needs to update, remove, or grow its contents dynamically. In Python, lists, sets, and dictionaries are among the most commonly used mutable data types. Understanding the behavior of mutable and immutable in Python helps you avoid unexpected bugs when handling data.

1. List

A list in Python is an ordered, mutable collection used to store multiple items, which can be of different data types. You can modify, add, or remove elements from a list using methods like append(), pop(), or direct indexing.

Sample Code:

myList = ["One", 1, False, 'c']  
myList.pop()  
print(myList)  
myList.append(True)  
print(myList)  
myList[0] = 2  
print(myList)

Code Explanation: Here, you first remove the last item using pop(), then add a new one with append(), and finally modify the first element directly by assigning a new value. All these changes happen in place because a list is mutable.
Output:

 ['One', 1, False]

 ['One', 1, False, True]

 [2, 1, False, True]

Ready to level up your Python skills? upGrad’s Free Certificate Python Libraries Course is the perfect next step after learning about mutable and immutable in Python. Learn to use essential libraries like NumPy, Matplotlib, and Pandas to analyze, manipulate, and visualize data effectively. 

2. Dictionary

A dictionary in Python is an unordered, mutable collection that stores data in key-value pairs. You can add, update, or delete items using methods like update(), pop(), or by assigning values to keys directly.

Sample Code:

myDict = { "India": "Delhi", "isAisan": True }  
myDict.update({"States": 29})  
print(myDict)  
myDict["India"] = "New Delhi"  
print(myDict)

Code Explanation: You first add a new key-value pair using update() and then change an existing value directly. These edits reflect the mutable nature of dictionaries. They're essential when you need flexible, key-based data storage.
Output:

 {'India': 'Delhi', 'isAisan': True, 'States': 29}

 {'India': 'New Delhi', 'isAisan': True, 'States': 29}

3. Set

A set in Python is an unordered, mutable collection that stores unique elements without duplicates. You can add or remove items using methods like add(), remove(), or discard().

Sample Code:

mySet = set(('India', 'U.S.A', False, 1, False))  
mySet.add(False)  
print(mySet)

Code Explanation: You create a set with mixed types and then attempt to add a duplicate. Since sets don't allow duplicates and are mutable, no error occurs, but the content stays unique. This makes sets ideal for storing non-redundant data.
Output:
{False, 1, 'U.S.A', 'India'}

What are Immutable Objects?

Immutable objects can’t be changed after creation. If you try to modify them, Python throws an error or creates a new object. Strings, tuples, and frozensets are typical examples. Understanding how mutable and immutable objects behave in Python is crucial when working with constants, caching, or function arguments.

1. Tuple

A tuple in Python is an ordered, immutable collection used to store multiple items, typically of different data types. Once created, you cannot modify, add to, or remove elements from a tuple.

Sample Code:

mytuple = ('a', 1, 2, 'b')  
print(mytuple[0])  
mytuple[0] = 'b'

Code Explanation: You can access tuple elements using indices, but you can’t change them. When you attempt to assign a new value, Python raises an error. Tuples are great for storing fixed, ordered data where immutability is a benefit.
 Output:

TypeError: 'tuple' object does not support item assignment

Also Read: Learn About Python Tuples Function [With Examples]

2. String

A string in Python is an immutable sequence of characters used to represent text. You can access characters by index, but you cannot modify the string after it is created.

Sample Code:

myString = "myName"  
print(myString[2])  
myString[2] = 'n'

Code Explanation: You can read individual characters in a string, but any attempt to change them directly results in an error. Strings are immutable, which makes them safe and efficient for reuse across your code.
 Output:

 TypeError: 'str' object does not support item assignment

But how does Python manage mutable and immutable objects behind the scenes? Let’s explore the mechanics of Python’s memory management.

How Does Python Handle Mutable and Immutable Objects?

Python’s memory management system is a cornerstone of its handling of mutable and immutable objects. This system includes object identity, reference counting, and garbage collection mechanisms to optimize memory allocation and ensure predictable behavior. 

Expanding on these concepts provides a deeper understanding of how Python efficiently manages memory.

Python’s Memory Management

Python uses a combination of techniques to handle mutable and immutable objects efficiently. These mechanisms ensure proper memory allocation and prevent memory leaks.

Key Concepts in Python’s Memory Management:

• Object Identity:
  Every object in Python has a unique identity, which you can view using theid(). Objects with shared references (e.g.,a=b) point to the same memory location. This is why mutable objects, like lists, share changes when referenced by multiple variables.

a = [1, 2, 3]
b = a
print(id(a), id(b))  # Same ID for both variables (shared reference)

• Reference Counting:

Python tracks the number of references to each object. When the reference count drops to zero (no variable points to the object), the memory is freed.

import sys
c = [10, 20, 30]
print(sys.getrefcount(c))  # Reference count for the object

• Reference Cycles and Garbage Collection in Depth:

A reference cycle occurs when objects refer to each other, preventing their reference counts from reaching zero. For instance:

class Node:
    def __init__(self, value):
        self.value = value
        self.ref = None

a = Node(1)
b = Node(2)
a.ref = b
b.ref = a

Here, a and b form a cycle. The garbage collector identifies and resolves such cycles during its collection phase.

• Garbage Collection:

The garbage collector in CPython handles objects that cannot be freed by reference counting alone, such as objects in reference cycles (e.g., two objects referencing each other). It periodically scans for unreachable objects to reclaim memory.

CPython organizes objects into generations based on their lifespan. Newly created objects are in Generation 0, and long-lived objects move to older generations. Frequent garbage collection occurs in Generation 0, while older generations are collected less frequently.

Python’s handling of objects in function calls differs based on whether the objects are mutable or immutable. Let’s explore how this distinction affects your code.

Behavior of Objects in Function Calls

The behavior of mutable and immutable objects in function calls can be surprising, as Python uses a pass-by-object-reference model. Understanding how Python handles object references helps clarify why changes to mutable objects persist outside the function, while immutable objects remain unaffected.

Key Differences in Function Calls:

• Mutable Objects:
  For mutable objects, Python passes a reference to the original object. Changes made inside the function affect the original object, as both the function parameter and the original variable refer to the same memory location.

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

Explanation:

Here, lst and my_list point to the same list object in memory. Any modifications to lst inside the function, such as appending 4, directly alter the original object.

• Immutable Objects:
  For immutable objects, Python also passes a reference, but any modification creates a new object. The original object remains unchanged.

def modify_number(num):
    num += 5
my_num = 10
modify_number(my_num)
print(my_num)  # Output: 10

Explanation:
Although num initially points to the same object as my_num, the operation num +=5 creates a new integer object. The reference inside the function is updated to point to this new object, leaving the original object (my_num) unchanged.

• Practical Insight:
  When using mutable objects in function calls, be cautious of unintended modifications. Use immutable objects when you need data integrity.

When working with mutable objects, copying is often necessary. But the type of copy you choose—shallow or deep—can significantly impact your program’s behavior.

Deep Copy vs. Shallow Copy

Understanding the difference between deep and shallow copies is crucial when working with mutable objects. Copying impacts how objects share memory and references.

Key Differences:

Shallow Copy:
Creates a new object but references the original elements. Changes to mutable elements affect both objects.

# Creating a shallow copy
shallow = original[:]

# Modifying the shallow copy
shallow[0][0] = 99

# Outputs
print("Original after shallow copy modification:", original)  # Output: [[99, 2], [3, 4]]
print("Shallow Copy:", shallow)                               # Output: [[99, 2], [3, 4]]

• Explanation:

A shallow copy only replicates the top-level structure of an object. The nested elements are still references to the original. Thus, modifying shallow[0][0] also changes the original list, as they share the same reference for nested elements.

• Why It Doesn't Work for Nested Objects:

Since nested elements are not independently copied, any modification to these elements affects both the original and the shallow copy. This behavior can cause bugs if the original data is expected to remain unchanged.

• Deep Copy:
  Creates a completely independent copy, including nested elements. Changes do not affect the original object.

import copy

# Original nested list
original = [[1, 2], [3, 4]]

# Creating a deep copy
deep = copy.deepcopy(original)

# Modifying the deep copy
deep[0][0] = 77

# Outputs
print("Original:", original)  # Output: [[1, 2], [3, 4]] (Unchanged)
print("Deep Copy:", deep)     # Output: [[77, 2], [3, 4]] (Modified)

Explanation:
A deep copy duplicates all levels of the object. In this example, the modification made to the deep copy (deep[0][0]=77) does not affect the original list, ensuring they remain completely independent.

When to Use:

• Use shallow copies for simple structures where nested elements don’t need independent handling.
• Use deep copies when working with complex, nested data structures requiring separate modifications.

Now that you know how Python handles mutable and immutable objects, the next step is understanding when to use each in practical scenarios.

Also Read: Python Classes and Objects [With Examples]

Now that you understand how Python handles mutable and immutable objects, it's also key to learn about common pitfalls and best practices for writing error-free, reliable code.

Common Mistakes and Best Practices in Python Programming

Working with mutable and immutable objects in Python can lead to subtle bugs if not handled carefully. Developers often overlook potential issues with default arguments or nested structures, resulting in unpredictable behavior. 

This section explores common mistakes and provides actionable advice to help you write efficient, error-free code.

Pitfalls with Mutable Default Arguments

Using mutable objects as default arguments in functions is a common mistake. Python evaluates default arguments only once, meaning the same mutable object is shared across multiple function calls. This can lead to unexpected behavior.

Problem Example:

def add_item(item, items=[]):
    items.append(item)
    return items

print(add_item(1))  # Output: [1]
print(add_item(2))  # Output: [1, 2] (Unexpected: list is shared!)

Best Practice: Use None as a Default:
To avoid this issue, use None as a safer alternative and initialize the mutable object inside the function.

def add_item_safe(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

print(add_item_safe(1))  # Output: [1]
print(add_item_safe(2))  # Output: [2] (Each call gets a new list)

Why It Works:
Using None ensures that a new list is created for each function call, preventing unintended data sharing.

What about the challenges of working with nested mutable objects? Let’s explore how to handle them safely.

Handling Nested Mutable Objects

Nested mutable objects, such as lists within lists, can introduce complexities. Modifying one element can inadvertently affect others due to shared references.

Problem Example:

nested_list = [[1, 2], [3, 4]]
copy_list = nested_list[:]
copy_list[0][0] = 99
print(nested_list)  # Output: [[99, 2], [3, 4]] (Unexpected: nested elements shared)

Best Practice: Use Deep Copies for Nested Structures:
A deep copy creates a completely independent copy of the object, including all nested elements.

import copy

nested_list = [[1, 2], [3, 4]]
deep_copy_list = copy.deepcopy(nested_list)
deep_copy_list[0][0] = 99
print(nested_list)  # Output: [[1, 2], [3, 4]] (Original remains unchanged)

Why It Works:
Deep copying ensures that changes to nested elements don’t affect the original object.

Also Read: Top 4 Python Challenges for Beginners [How to Solve Those?]

You’ve seen the common mistakes and best practices, it’s time to explore the practical implications of using mutable objects in Python and how they impact real-world programming.

How Can upGrad Help You Learn Python Programming?

Knowing how mutable and immutable in Python work directly affects how your code behaves, especially when you're working with functions, memory management, or debugging. Recognizing which data types can change and which can't helps you avoid common pitfalls and write cleaner, more predictable code.

With so many Python concepts to learn, it’s easy to get overwhelmed about what to learn next. To help bridge this gap, upGrad’s personalized career guidance can help you explore the right learning path based on your goals. 

Here are some additional courses you can consider:

• Data Structures & Algorithms
• JavaScript Basics from Scratch
• Java Object-oriented Programming
• Learn Python Libraries: NumPy, Matplotlib & Pandas Free Course
• Executive Diploma in Machine Learning and AI

Tired of unexpected bugs caused by Python lists and dictionaries changing on their own? upGrad’s personalized career guidance can help you explore the right learning path based on your goals. You can also visit your nearest upGrad center and start hands-on training today! 

Unlock the power of data with our popular Data Science courses, designed to make you proficient in analytics, machine learning, and big data!

Explore our Popular Data Science Courses

Elevate your career by learning essential Data Science skills such as statistical modeling, big data processing, predictive analytics, and SQL!

Top Data Science Skills to Learn

Stay informed and inspired  with our popular Data Science articles, offering expert insights, trends, and practical tips for aspiring data professionals!

Read our popular Data Science Articles

References:
https://www.x-cmd.com/blog/250518