Understanding Mutable and Immutable Objects in Python.

Introduction

Python classifies its data types into mutable and immutable categories. This classification determines whether an object’s value can be changed after creation. Understanding this concept is crucial for writing efficient and bug-free Python code. This article will explore mutable and immutable objects in detail, with behind-the-scenes explanations and memory behavior analysis.

---

Mutable Objects

Definition

Mutable objects can be changed after their creation. Modifications affect the original object without changing its memory address.

Examples of Mutable Objects

• Lists (list)

• Dictionaries (dict)

• Sets (set)

• Byte Arrays (bytearray)

Example with a List

# Creating a mutable list
my_list = [1, 2, 3]
print("Before modification:", my_list, "| Memory Address:", id(my_list))

# Modifying the list
my_list.append(4)
print("After modification:", my_list, "| Memory Address:", id(my_list))

Explanation

• The list.append(4) method modifies the list in place.

• The memory address remains unchanged, proving that lists are mutable.

---

Immutable Objects

Definition

Immutable objects cannot be modified after creation. Any operation that appears to modify them creates a new object.

Examples of Immutable Objects

• Integers (int)

• Floating-point numbers (float)

• Strings (str)

• Tuples (tuple)

• Frozen sets (frozenset)

Example with a String

# Creating an immutable string
my_string = "Hello"
print("Before modification:", my_string, "| Memory Address:", id(my_string))

# Trying to modify the string (creates a new object)
my_string += " World"
print("After modification:", my_string, "| Memory Address:", id(my_string))

Explanation

• The += operator creates a new string object instead of modifying the existing one.

• The memory address changes, proving that strings are immutable.

---

Behind the Scenes: Memory Behavior

Checking Memory Allocation with id()

To confirm mutability and immutability, we can use id() to check memory addresses.

# Mutable list
my_list = [1, 2, 3]
print("List ID before:", id(my_list))
my_list.append(4)
print("List ID after:", id(my_list))  # Same ID (Mutable)

# Immutable tuple
my_tuple = (1, 2, 3)
print("Tuple ID before:", id(my_tuple))
my_tuple += (4,)
print("Tuple ID after:", id(my_tuple))  # Different ID (Immutable)

Using sys.getrefcount() to Check Memory Optimization

Python optimizes memory usage by reusing immutable objects when possible. We can test this with sys.getrefcount():

import sys

num = 100  # Immutable integer
print("Reference count of num:", sys.getrefcount(num))

my_list = [1, 2, 3]  # Mutable list
print("Reference count of my_list:", sys.getrefcount(my_list))

Key Observations

• Immutable objects are reused (interned) in Python to optimize memory usage.

• Mutable objects are not reused because modifying one instance should not affect another.

---

Python Interning: Reusing Immutable Objects

Python automatically reuses small integers and short strings to save memory. This is called interning.

Example: Integer Interning (-5 to 256)

a = 10
b = 10

print(id(a), id(b))  # Both IDs are the same
print(a is b)  # True (Same memory location)

• Why? Python caches integers from -5 to 256 for performance optimization.

• Any variable assigned within this range refers to the same object in memory.

Example: String Interning

s1 = "hello"
s2 = "hello"

print(id(s1), id(s2))  # Same ID
print(s1 is s2)  # True

• Python interns short strings to avoid creating duplicate objects.

• However, long strings may not always be interned:

s3 = "hello world!"
s4 = "hello world!"

print(s3 is s4)  # May be False

• Longer strings may be stored separately due to memory trade-offs.

Mutable Objects Are NOT Interned

list1 = [1, 2, 3]
list2 = [1, 2, 3]

print(id(list1), id(list2))  # Different IDs
print(list1 is list2)  # False

• Why? Lists are mutable, so Python ensures that modifying one list doesn’t affect another.

---

Key Differences Between Mutable and Immutable Objects

---

Conclusion

Understanding mutable vs. immutable objects is essential for writing efficient Python programs.

• Use mutable objects when modifications are required (e.g., lists, dictionaries).

• Use immutable objects when you need safe, unchangeable data (e.g., strings, tuples).

• Python optimizes memory by reusing immutable objects where possible, making the language more efficient.

By leveraging this knowledge, you can write better-optimized and memory-efficient Python programs! 🚀