Which Objects in Python are Immutable?

Immutable objects cannot be modified after creation. Any operation that appears to change an immutable object actually creates a new object in memory. The following Python data types are immutable:

• bool – Boolean values (True, False)
• integer – Whole numbers
• float – Decimal numbers
• tuple – Ordered collections that cannot be changed
• string – Text sequences
• frozenset – Immutable version of sets

Which Objects in Python are Mutable?

Mutable objects can be modified in place without creating new objects in memory. This makes them more memory-efficient for operations that involve frequent changes. The primary mutable data types in Python include:

• list – Ordered collections that can be modified
• set – Unordered collections of unique elements
• dictionary – Key-value pairs that can be updated

These objects maintain their identity in memory even when their contents change, making them ideal for scenarios where you need to frequently add, remove, or modify elements.

How to Test Object Mutability

Python provides the id() function to determine whether an object is mutable or immutable. This function returns the unique memory address of an object, allowing you to track whether operations create new objects or modify existing ones.

Testing Immutable Objects (Strings)

Let’s examine how string operations demonstrate immutability:

string1 = "hello"
print(f"Initial ID: {id(string1)}")
print(f"Type: {type(string1)}")

string1 = "how are you?"
print(f"New ID: {id(string1)}")
print(f"Type: {type(string1)}")

When you run this code, you’ll notice that the id() values are different. This demonstrates that the variable string1 is actually a pointer to an object. When we assign a new string value, Python creates a new object and redirects the pointer, rather than modifying the original string object.

Testing Mutable Objects (Lists)

Now let’s observe how list operations demonstrate mutability:

list1 = ['orange', 'apple', 'pear']
print(f"Initial ID: {id(list1)}")
print(f"Type: {type(list1)}")

# Modify the list in place
list1.append('grape')
print(f"After append ID: {id(list1)}")
print(f"List contents: {list1}")

# Reassigning creates a new object
list1 = ['orange', 'apple', 'pear', 'strawberry']
print(f"After reassignment ID: {id(list1)}")

The key observation here is that the id() remains the same after using append(), proving that the list object itself was modified rather than replaced. However, reassigning the entire list creates a new object with a different ID.

Performance Impact and Memory Efficiency

Understanding mutability is crucial for writing efficient Python applications. The choice between mutable and immutable objects can significantly impact memory usage and execution speed, especially in applications that perform many data modifications.

String Concatenation: A Performance Anti-Pattern

Consider this common but inefficient approach to string building:

string1 = "hello"
print(f"Initial ID: {id(string1)}")

string1 = string1 + " how are you?"
print(f"After concatenation ID: {id(string1)}")
print(f"Final string: {string1}")

Each concatenation operation creates a new string object, copying all existing content plus the new content. In applications performing thousands of such operations, this becomes a significant performance bottleneck.

Efficient String Building with Lists

A more efficient approach uses mutable lists for collecting string components:

fruit = []
print(f"Initial list ID: {id(fruit)}")

fruit.append('apple')
print(f"After first append: {id(fruit)}")

fruit.append('pear')
print(f"After second append: {id(fruit)}")

fruit.append('orange')
print(f"After third append: {id(fruit)}")

# Convert to string only once
result_string = " ".join(fruit)
print(f"Final string: {result_string}")

This approach maintains the same list object throughout all append operations, only creating the final string when needed. This reduces memory allocations from O(n²) to O(n), resulting in significant performance improvements for large-scale operations.

Python’s Dynamic Typing vs Static Languages

Python’s approach to mutability differs significantly from statically typed languages like C++. Understanding these differences helps developers leverage Python’s flexibility while avoiding common pitfalls.

Static Typing Constraints

In C++, variables are strongly typed and immutable by design:

// C++ example - strongly typed
int myinteger = 5;

// This would cause a compilation error:
// string myinteger = "Hello!";  // Cannot redeclare with different type

Python’s Dynamic Flexibility

Python allows variable reassignment with different types:

myint = 5
print(f"Type: {type(myint)}")  # <class 'int'>

myint = "Hello!"
print(f"Type: {type(myint)}")  # <class 'str'>

Why Understanding Mutability Matters

Mastering the concepts of mutable and immutable objects enables you to make informed decisions about data structure selection, memory optimization, and algorithm design. This knowledge becomes particularly valuable when developing applications that handle large datasets or require high-performance processing.

By understanding which Python objects fit into each category and how they behave during operations, you can design applications that are both efficient and maintainable. This knowledge helps you avoid common performance pitfalls while taking advantage of Python’s flexibility and power.