When learning Python, understanding data types is only the first step. Another important concept is knowing whether an object’s contents can be changed after it is created. This property is known as mutability.
Some Python objects can be modified after creation, while others cannot. Understanding this difference helps you choose the right data type and explains how Python manages objects during program execution.
This guide explains Mutability vs Immutability in Python, including their differences, behavior, and when to use mutable and immutable objects in real-world programs.
Use the links below to jump directly to any section of this guide.
Quick Navigation: Mutability vs Immutability in Python
- What is Mutability in Python?
- What is Immutability in Python?
- Difference Between Mutable and Immutable Objects
- Python Mutable Data Types
- Python Immutable Data Types
- How Python Handles Mutable and Immutable Objects
- Examples of Mutable and Immutable Objects in Python
- Use Cases: Mutable and Immutable Objects
- Common Mistakes Beginners Make: Mutable and Immutable Objects
- Best Practices for Mutable and Immutable Objects
- Key Takeaways: Mutability vs Immutability
What is Mutability in Python?
Definition
Mutability is the property of an object that allows its contents to be modified after it has been created. A mutable object can be updated without creating a new object in memory.
Explanation
When a mutable object is modified, Python usually updates the existing object instead of creating a new one. As a result, its object identity typically remains the same even though its contents change.
Common mutable data types in Python include list, dict, set, and bytearray. They are commonly used when data needs to be added, updated, or removed.
Real-World Analogy
Imagine writing notes on a whiteboard. You can erase, add, or rearrange information without replacing the whiteboard itself.
Mutable objects work the same way. The object remains the same, but its contents can be modified whenever needed.
What is Immutability in Python?
Definition
Immutability is the property of an object that prevents its contents from being changed after it has been created. If a modification is required, Python creates a new object instead of modifying the existing one.
Explanation
When an immutable object is assigned a different value, Python creates a new object instead of modifying the existing one. As a result, the original object’s identity remains unchanged, while the variable begins referring to the new object.
Common immutable data types in Python include int, float, bool, complex, str, tuple, bytes, frozenset, and range. They are commonly used for values that should remain unchanged.
Real-World Analogy
Think of a printed book. Once it has been published, its contents cannot be changed. If changes are needed, a new edition must be created.
Immutable objects work the same way. They cannot be modified after creation, so Python creates a new object whenever a different value is assigned.
Mutability vs Immutability in Python: Difference Between Mutable and Immutable Objects
The main difference between mutable and immutable objects is whether their contents can be changed after creation. Understanding this distinction helps you choose the appropriate data type and understand how Python manages objects in memory.
The following table compares the key differences between mutable and immutable objects.
| Feature | Mutable Objects | Immutable Objects |
|---|---|---|
| Meaning | Contents can be modified after the object is created. | Contents cannot be modified after the object is created. |
| Object Creation | The same object is updated when changes are made. | A new object is created when a different value is required. |
| Memory Behavior | Usually retains the same memory location after modification. | Usually receives a new memory location after modification. |
| Can Be Updated? | Yes | No |
| Performance | Efficient for data that changes frequently. | Suitable for fixed or constant data. |
| Common Use Cases | Managing collections, updating records, storing changing data. | Storing text, numbers, fixed values, and constants. |
| Examples | list, dict, set, bytearray |
int, float, bool, complex, str, tuple, bytes, frozenset, range |
Python Mutable Data Types
Python provides several built-in mutable data types whose contents can be modified after they are created. Each data type is designed for a specific purpose depending on the kind of data you need to store and manage.
| Data Type | Description |
|---|---|
list |
An ordered collection that allows duplicate values and supports adding, removing, and modifying elements. |
dict |
A collection of key-value pairs that allows values to be added, updated, or removed after creation. |
set |
An unordered collection of unique elements that supports adding and removing items. |
bytearray |
A mutable sequence of bytes used for working with binary data. Individual bytes can be modified after creation. |
Follow the links above to learn the syntax, methods, practical examples, and common use cases of each mutable data type.
Python Immutable Data Types
Python provides several built-in immutable data types that are designed to represent fixed values and collections. Each serves a specific purpose depending on the kind of data you need to store.
| Data Type | Description |
|---|---|
int |
Represents whole numbers, such as 10, -25, and 1000. |
float |
Represents decimal or floating-point numbers, such as 3.14 and -0.5. |
bool |
Represents Boolean values, which can be either True or False. |
complex |
Represents complex numbers containing both real and imaginary parts, such as 2 + 3j. |
str |
Represents text data as an immutable sequence of Unicode characters. |
tuple |
Represents an ordered collection of items whose elements cannot be added, removed, or modified after creation. |
bytes |
Represents an immutable sequence of bytes, commonly used for working with binary data. |
frozenset |
Represents an immutable version of a set whose elements cannot be changed after creation. |
range |
Represents an immutable sequence of numbers, commonly used for iteration in loops and generating ranges of values. |
Follow the links above to learn the syntax, methods, practical examples, and common use cases of each immutable data type.
How Python Handles Mutable and Immutable Objects
Understanding mutable and immutable objects becomes easier when you know how Python manages objects internally. Variables store references to objects, and whether an object is mutable or immutable determines what happens when you try to modify it.
When you modify an object, Python handles the change differently depending on whether the object is mutable or immutable. The following concepts explain this behavior in more detail.
1. Memory Behavior
When you modify a mutable object, Python usually updates the existing object without creating a new one. As a result, the object’s identity typically remains the same.
Immutable objects behave differently. Since they cannot be modified, Python creates a new object whenever a different value is assigned. The original object remains unchanged and the variable begins referring to the new object.
2. Object Identity
Every object in Python has a unique identity, which can be viewed using the id() function.
When a mutable object is modified, its object identity usually remains unchanged because Python updates the existing object. In contrast, modifying an immutable object typically creates a new object with a different identity, which is why the value returned by id() often changes.
3. Reference Sharing
Variables in Python store references to objects rather than the objects themselves. As a result, multiple variables can refer to the same object. If the object is mutable, changes made through one variable are visible through the others.
For immutable objects, assigning a new value creates a new object. The original object remains unchanged, and the variable begins referring to the new object.
Examples of Mutable and Immutable Objects in Python
The following examples demonstrate how Python handles mutable and immutable objects when their values are modified.
They cover key concepts such as object identity, memory behavior, and reference sharing.
Note: The values returned by id() are system-dependent and may differ on different computers and Python versions.
Example 1: Modifying a Mutable Object (List)
Lists are mutable objects. You can modify their contents after they have been created without creating a new object.
# Creating a list
numbers = [10, 20, 30]
# Display the object's identity before modification
print("Before:", id(numbers))
# Modify the list
numbers.append(40)
# Display the object's identity after modification
print("After :", id(numbers))
# Display the updated list
print(numbers)
#Output:
Before: 123456789
After : 123456789
[10, 20, 30, 40]
Explanation: The list is modified in place, so its object identity remains the same even though its contents have changed.
Example 2: Modifying an Immutable Object (String)
Strings are immutable. Any operation that changes a string creates a new string object instead of modifying the existing one.
# Creating a string
text = "Python"
# Display the object's identity before modification
print("Before:", id(text))
# Create a new string
text = text + " Programming"
# Display the object's identity after modification
print("After :", id(text))
# Display the updated string
print(text)
# Output:
Before: 123456789
After : 987654321
Python Programming
Explanation: Since strings are immutable, Python creates a new object instead of modifying the existing string. This is why the object’s identity changes.
Example 3: Reference Sharing with Mutable Objects
Multiple variables can reference the same mutable object. A change made through one variable is reflected in the other.
# Creating a list
list1 = [1, 2, 3]
# Both variables reference the same object
list2 = list1
# Modify the list
list2.append(4)
print("list1:", list1)
print("list2:", list2)
# Output:
list1: [1, 2, 3, 4]
list2: [1, 2, 3, 4]
Explanation: Both variables point to the same list, so modifying the list through one reference affects the other.
Example 4: Reassigning an Immutable Object
When an immutable object is assigned a new value, Python creates a separate object instead of modifying the original one.
# Creating an integer
x = 100
# Another variable references the same value
y = x
# Assign a new value
x = 200
print("x =", x)
print("y =", y)
# Output:
x = 200
y = 100
Explanation: Assigning a new value to x creates a new integer object. The original object remains unchanged, and y continues to reference it.
Example 5: Checking Object Identity Using id()
The id() function returns the unique identity of an object. It is commonly used to observe whether Python updates an existing object or creates a new one.
# Creating a mutable object
numbers = [10, 20]
# Display the object's identity
print("Before:", id(numbers))
# Modify the list
numbers.append(30)
# Display the object's identity again
print("After :", id(numbers))
# Output:
Before: 123456789
After : 123456789
Explanation: The identical values returned by id() show that Python modified the existing list instead of creating a new object.
Use Cases: Mutable and Immutable Objects
Choosing between mutable and immutable objects depends on whether the data in your program needs to change after it is created. Understanding when to use each type helps you write cleaner, more reliable, and efficient Python programs.
Use Cases: Mutable Objects
Mutable objects are suitable when your program needs to add, remove, or update data after an object has been created.
- Managing collections whose contents change over time.
- Adding, removing, or updating elements.
- Maintaining dynamic records and configurations.
- Tracking data that changes during program execution.
- Manipulating binary data using
bytearray.
Use Cases: Immutable Objects
Immutable objects are suitable when data should remain unchanged after creation. They help maintain data consistency and prevent unintended modifications.
- Representing fixed or constant values.
- Storing text and numeric data.
- Creating read-only collections with
tupleandfrozenset. - Using objects as dictionary keys or set elements.
- Preventing unintended modifications.
Common Mistakes Beginners Make: Mutable and Immutable Objects
When learning mutability and immutability, beginners often make a few common mistakes. Understanding them early can help you avoid unexpected behavior in your programs.
-
Trying to modify immutable objects
For example, changing a character in a string (text[0] = "P") raises an error because strings are immutable. -
Confusing assignment with copying
Writinglist2 = list1does not create a new list. Both variables refer to the same list. -
Unexpected changes to shared objects
Modifyinglist2.append(10)also changeslist1if both variables reference the same list. -
Assuming every value change modifies the same object
Reassigningx = x + 1creates a new integer object because integers are immutable. -
Assuming tuples are always completely immutable
A tuple cannot be modified, but if it contains a mutable object such as a list, that list can still be changed.
Best Practices for Mutable and Immutable Objects
Choosing between mutable and immutable objects depends on how your program manages data. Using the appropriate data type improves code readability, reduces bugs, and makes programs easier to maintain.
- Use mutable objects only when data needs to change after creation.
- Use immutable objects for values that should remain constant.
- Avoid modifying shared mutable objects unless the changes are intentional.
- Create copies of mutable objects when independent modifications are needed.
- Use the
id()function to understand object identity while learning or debugging. - Choose the data type that best matches your data and programming requirements.
Key Takeaways: Mutability vs Immutability
Here are the main points to remember about mutable and immutable objects in Python.
- Mutable objects can be modified after creation, while immutable objects cannot.
- Modifying a mutable object usually updates the existing object.
- Changing an immutable object creates a new object.
list,dict,set, andbytearrayare mutable data types.int,float,bool,complex,str,tuple,bytes,frozenset, andrangeare immutable data types.- Variables store references to objects, not the objects themselves.
- Choose mutable or immutable objects based on whether the data needs to change.