🔄 Python Tutorial — Mutable vs Immutable Types

Introduction 🌟

In Python, every value is stored as an object. These objects fall under two important categories:

  • 🔹 Mutable → can be changed after creation
  • 🔹 Immutable → cannot be changed once created

Understanding mutability is crucial for writing bug-free, efficient Python code — especially when working with functions, loops, and data structures.

Note

💡 Immutable objects create new memory on modification
💡 Mutable objects change in place

1. Immutable Types 🧊

These objects cannot be changed after they're created.

  • ✔ int
  • ✔ float
  • ✔ bool
  • ✔ str
  • ✔ tuple
  • ✔ frozenset
  • ✔ bytes

Example: Immutable Integer

immutable_int.py

x = 10
print(id(x))

x += 1
print(id(x))   # Different ID → new object

✔ Changing an int creates a new object in memory.

Example: Immutable String

immutable_str.py

s = "hello"
print(id(s))

s += " world"
print(id(s))  # New object created

Note

⚠️ Strings cannot be modified — every change creates a new one.

2. Mutable Types 🔧

These objects can be modified in place without creating new objects.

  • ✔ list
  • ✔ dict
  • ✔ set
  • ✔ bytearray
  • ✔ custom class objects

Example: Mutable List

mutable_list.py

a = [1, 2, 3]
print(id(a))

a.append(4)
print(id(a))   # Same ID → modified in place

✔ List changed without creating a new object.

Example: Mutable Dictionary

mutable_dict.py

d = {"a": 1}
print(id(d))

d["b"] = 2
print(id(d))  # Same ID

3. Key Difference Visualization 📊

TypeChanges Allowed?Memory AllocationExamples
ImmutableNoCreates new objectint, float, str, tuple
MutableYesModifies existing objectlist, dict, set

4. Why Does Mutability Matter? 🧠

  • ✔ Helps avoid bugs caused by shared references
  • ✔ Affects performance & memory usage
  • ✔ Important when passing objects to functions
  • ✔ Crucial for understanding deep vs shallow copies

5. Mutability in Function Arguments 📥

Mutable objects can be modified inside a function, affecting the original value.

Mutable Example

func_mutable.py

def modify(lst):
    lst.append(100)

a = [1, 2, 3]
modify(a)
print(a)  # [1,2,3,100]

Immutable Example

func_immutable.py

def modify(x):
    x += 10

n = 5
modify(n)
print(n)  # Still 5

✔ Integers (immutable) cannot be changed inside the function.

6. Tuple vs List — Common Interview Question 🔎

tuple_vs_list.py

t = (1, 2, 3)
l = [1, 2, 3]

# t[0] = 10   # ❌ Error
l[0] = 10     # ✔ Works

✔ Tuples are immutable, lists are mutable.

7. Frozen Set — Immutable Version of Set ❄️

frozenset_example.py

s = frozenset([1, 2, 3])
# s.add(4)  # ❌ Error

8. Shared Reference Danger (Mutable) ⚠️

shared_reference.py

a = [1, 2, 3]
b = a   # both point to same object

b.append(99)
print(a)  # [1,2,3,99]

Note

⚠️ Assigning mutable objects doesn't copy them — both variables share the same object.

9. Best Practices 💡

  • ✔ Be careful when passing mutable objects to functions
  • ✔ Use immutable types for keys in dictionaries
  • ✔ Prefer immutable types when shared across threads
  • ✔ Use copy() or deepcopy() to avoid shared references

10. Cheat Sheet 📘

CategoryMutableImmutable
Numeric—int, float, complex
Sequencelisttuple, str
Set Typessetfrozenset
Mappingdict—
Binarybytearraybytes

Conclusion 🎉

>>“Mutable objects change themselves — immutable objects create new versions of themselves.” ✨

You now fully understand Mutable vs Immutable Types in Python! Want the next topic? Try Object Identity, Garbage Collection, Name Binding, or Memory Management. Just tell me! 😊