¿Cuál es la diferencia entre objetos mutables e inmutables?

Question

Accepted Answer

Un objeto **inmutable** no puede cambiarse después de su creación; uno **mutable** sí. Esta distinción es central en Python y afecta a los alias, las claves de dict, los argumentos de función y a una clase de errores sutiles.

## Las dos categorías

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

## Inmutable: "cambiar" crea un objeto nuevo

```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
```

Con los inmutables, las operaciones que parecen "cambiar" el valor en realidad producen un objeto nuevo y reasignan la variable. El original nunca se altera.

## Mutable: se modifica en el sitio

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

## La trampa de los alias (el peligro práctico)

```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[:]
```

Asignar un objeto mutable no lo copia: ambos nombres referencian el mismo objeto, por lo que mutarlo a través de uno afecta al otro. Esto sorprende a muchos y causa errores reales.

## Por qué los inmutables pueden ser claves de dict / miembros de set

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

Las claves de dict y los miembros de set deben ser **hashables**, lo que requiere inmutabilidad (una clave mutable podría cambiar y romper la tabla hash).

## Argumentos de función

```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
```

## Por qué es importante

La mutabilidad es un concepto fundamental de Python que explica una amplia gama de comportamientos y errores: la trampa de los alias (la asignación no copia los mutables), por qué las funciones pueden modificar una lista pasada pero no un int, por qué solo los objetos inmutables pueden ser claves de dict/miembros de set, y la trampa del argumento por defecto mutable.

Comprender qué tipos son mutables frente a inmutables —y que mutar un objeto compartido afecta a todas las referencias a él— es esencial para escribir Python correcto y evitar algunas de sus sorpresas más comunes.