mutable vs immutable objects

[sudoUgando]

What are mutable vs immutable objects?

[codeperfectplus]

Mutable and immutable objects basically differ in whether their value can change after creation.

Mutable objects

These can be modified in place — meaning you don’t create a new object when you change them.

Examples in Python:

• list
• dict
• set

a = [1, 2, 3]
a.append(4)

print(a)  # [1, 2, 3, 4]

Here, the same object a is updated — no new object is created.

---

Immutable objects

These cannot be changed once created. Any operation that seems like a modification actually creates a new object.

Examples:

• int
• float
• str
• tuple

a = 10
a = a + 5

print(a)  # 15

This doesn’t modify the original 10; it creates a new object 15 and reassigns a.

---

Think of a checkout system.

Once the final price is calculated, you don’t want anything accidentally changing it later. If it’s mutable, some part of the code might tweak it without you noticing.

So you keep it immutable, once set, it can’t be changed.
Simple rule: if it must not change, make it impossible to change.

[EimanTahir071]

What are mutable vs immutable objects?

In programming, mutable and immutable objects describe whether an object’s state can change after it’s created.

Mutable objects

A mutable object can be modified in place—its internal data/state changes.
Example (Python): list
You can append/remove/update elements without creating a new list.
Example (JavaScript): Map, Set, plain objects ({})
You can add/remove entries or properties

Immutable objects

An immutable object cannot be modified after creation. Any “change” produces a new object instead.
Example (Python): tuple, str, int, frozenset
Example (JavaScript): strings ("abc") are immutable; operations like concatenation create a new string.

Why it matters
Predictability & safety: Immutable objects are less likely to be accidentally altered by other code.
Sharing across code: Immutable objects can be safely shared (no one can change them behind your back).
Performance tradeoffs: Mutable structures can be updated without allocation; immutable approaches may allocate more new objects, but can simplify reasoning and enable optimizations.