Mutable vs. Immutable Objects in Python 🔄🔒

Mutable vs. Immutable Objects in Python 🔄🔒

In Python, mutability determines whether an object’s value can be changed after creation. This is crucial for understanding how variables behave. 🤔

---

Immutable Objects 🔒

• Cannot be modified once created. Any “change” creates a new object. 🆕
• Types: int, float, str, bool, tuple, frozenset, bytes, NoneType.

Example 1: Strings (Immutable) 💬

Python

s = "hello"
print(id(s))  # Original memory address: e.g., 140245678945600

s += " world"  # "Modification" creates a NEW string
print(id(s))  # New address: e.g., 140245678946880 (different!)

Example 2: Tuples (Immutable) 📦

Python

t = (1, 2, [3, 4])
print(t)       # (1, 2, [3, 4])
# t[0] = 99    # TypeError: tuple does not support item assignment
# But note: The inner list is mutable!
t[2].append(5)  # The tuple's structure hasn't changed (still holds same list)
print(t)        # (1, 2, [3, 4, 5])

---

Mutable Objects 📝

• Can be modified in-place without creating a new object. ✍️
• Types: list, dict, set, bytearray.

Example 1: Lists (Mutable) 📋

Python

colors = ["red", "green"]
print(id(colors))  # Original address: e.g., 140245678947392

colors.append("blue")  # Modified IN-PLACE
print(colors)          # ["red", "green", "blue"]
print(id(colors))      # Same address: 140245678947392

Example 2: Dictionaries (Mutable) 📚

Python

person = {"name": "Alice", "age": 30}
print(id(person))  # Original address: e.g., 140245678946112

person["age"] = 31  # Change value in-place
person["city"] = "Paris"  # Add new key-value pair
print(person)       # {'name': 'Alice', 'age': 31, 'city': 'Paris'}
print(id(person))   # Same address: 140245678946112

---

Key Implications: 🤔

Equality vs. Identity ⚖️🆔

• == checks if values are equal.
• is checks if they refer to the exact same object in memory.

Python

a = [1, 2]  # Mutable
b = [1, 2]  # Different object
print(a == b)  # True (same value)
print(a is b)  # False (different memory)

x = "abc"    # Immutable
y = "abc"    # Python may reuse same object (interning)
print(x is y) # Often True (due to interning for small, immutable objects)

Function Arguments 🔄

• Mutable objects passed to functions can be changed globally. 🌍
• Immutable objects behave like “copies” inside functions. 📄

Python

def update_list(lst):
    lst.append(99)  # Affects original list

def try_update_string(s):
    s += "!"        # Creates new string (no effect outside)

my_list = [1, 2]
my_str = "Hello"

update_list(my_list)
try_update_string(my_str)

print(my_list)  # [1, 2, 99] (changed)
print(my_str)   # "Hello" (unchanged)

---

Summary Table: 📊

Property	Mutable	Immutable
Can modify?	Yes (in-place)	No (new object on change)
Memory address	Same after modification	Changes after “modification”
Examples	list, dict, set	int, str, tuple
Use Case	Dynamic collections	Constants, safe data

Export to Sheets