What is the difference between mutable and immutable objects?

Question

Accepted Answer

An **immutable** object cannot be changed after creation; a **mutable** object can. This distinction is central to Python and affects aliasing, dict keys, function arguments, and a class of subtle bugs.

## The two categories

```text
Immutable: int, float, bool, str, tuple, frozenset, bytes, None
Mutable:   list, dict, set, bytearray, and most custom objects
```

## Immutable: "changing" creates a new object

```python
x = "hello"
x.upper()       # returns a NEW string "HELLO" — x is unchanged
x += " world"   # rebinds x to a NEW string; the original "hello" is untouched

n = 5
n += 1          # creates a new int 6; doesn't modify the int object 5
```

With immutables, operations that seem to "change" the value actually produce a new object and rebind the variable. The original is never altered.

## Mutable: modified in place

```python
lst = [1, 2, 3]
lst.append(4)   # modifies the SAME list object → [1, 2, 3, 4]
lst[0] = 99     # in-place change
```

## The aliasing trap (the practical danger)

```python
# mutable — two names point to the SAME object
a = [1, 2, 3]
b = a            # b is NOT a copy — it's the same list
b.append(4)
print(a)         # [1, 2, 3, 4] ← a changed too! (they're aliases)

# to actually copy:
b = a.copy()     # or list(a), or a[:]
```

Assigning a mutable object doesn't copy it — both names reference the same object, so mutating through one affects the other. This surprises many and causes real bugs.

## Why immutables can be dict keys / set members

```python
d = {(1, 2): "point"}   # ✅ tuple key — immutable, hashable
d = {[1, 2]: "x"}       # ❌ TypeError — lists are unhashable (mutable)
```

Dict keys and set members must be **hashable**, which requires immutability (a mutable key could change and break the hash table).

## Function arguments

```python
def modify(lst): lst.append(99)   # mutates the caller's list (passed by reference)
def rebind(n): n += 1             # rebinds locally; caller's int unchanged
```

## Why it matters

Mutability is a foundational Python concept that explains a wide range of behavior and bugs: the aliasing trap (assignment doesn't copy mutables), why functions can modify a passed-in list but not an int, why only immutable objects can be dict keys/set members, and the mutable-default-argument pitfall.

Understanding which types are mutable vs immutable — and that mutating a shared object affects all references to it — is essential for writing correct Python and avoiding some of its most common surprises.