Saltearse al contenido

Mutabilidad e inmutabilidad

«Inmutable» no significa que el valor no cambie nunca. Significa que no puede cambiar en su sitio: cualquier operación que parezca modificarlo construye un objeto nuevo y mueve la etiqueta. La diferencia parece filosófica hasta que se convierte en veinte veces de diferencia de rendimiento, en claves de diccionario que funcionan o fallan, y en un bug de estado compartido que nadie encuentra.

Mutable es «cambia donde está». Inmutable es «se reemplaza por otro y la etiqueta se mueve».

Inmutables Mutables
int, float, complex, bool list
str, bytes dict
tuple set
frozenset bytearray
namedtuple, frozen dataclass dataclass normal
range, slice, None instancias con __dict__

No es una lista de conveniencia: es la propiedad que decide si un objeto puede ser clave de un diccionario, si un cambio se propaga a través de un alias y qué operadores cuestan tiempo constante.

El caso que engaña: la tupla con una lista dentro

Sección titulada «El caso que engaña: la tupla con una lista dentro»
La tupla no protege lo que contiene
t = ([1, 2], 3) referencias fijas: no se pueden reasignar [1, 2] mutable: append funciona t t[0]

La tupla congela sus dos referencias, no los objetos apuntados. `t[0] = algo` falla; `t[0].append(3)` funciona.

t = ([1, 2], 3)
t[0] = [9] # TypeError: no se puede reasignar
t[0].append(3) # funciona: la lista de dentro es mutable
t # ([1, 2, 3], 3)
hash(t) # TypeError: unhashable type: 'list'

La primera línea y la tercera sorprenden a la vez. La tupla es inmutable en sus referencias: no puedes cambiar a qué apunta cada posición. Pero si lo apuntado es mutable, sigue siéndolo. Y como el hash de una tupla combina el hash de sus elementos, una tupla que contiene una lista no es hashable: no puede ser clave de un diccionario, aunque sea una tupla.

Esa es la definición operativa de inmutable en Python: hashable y sin operaciones que muten el estado. Una tupla de listas no cumple ninguna de las dos.

Con una lista, += muta en su sitio llamando a __iadd__. Con una tupla, no existe __iadd__, así que el intérprete cae a __add__ y construye una tupla nueva. La diferencia no es estilística:

Añadir un elemento a una secuencia de 1 000 elementos
Operación Coste Qué hace
l += x sobre list 64 ns muta en su sitio, id no cambia
l = l + x sobre list 1 313 ns copia los 1 000 punteros a una lista nueva
t += y sobre tuple 96 266 ns no hay otra opción: objeto nuevo

python mediciones/01-03-05-referencias.py

Unas veinte veces por operación. Y en un bucle la brecha se compone: + copia la lista entera en cada vuelta (O(n²)), mientras que += es O(1) amortizado. El id lo confirma: después de l += x el objeto es el mismo; después de l = l + x es otro.

En un bucle esto pasa de curiosidad a problema:

# O(n²): cada vuelta copia toda la lista
acumulado = []
for fila in filas:
acumulado = acumulado + [fila]
# O(n): cada vuelta appendea en el hueco reservado
acumulado = []
for fila in filas:
acumulado.append(fila)

Con cien mil filas, la primera versión tarda minutos y la segunda, milisegundos. La causa está en el capítulo 02 de la Parte II: list sobreasigna para que append sea O(1) amortizado; + no puede aprovechar nada de eso porque debe producir un objeto nuevo.

Hashabilidad. Sólo un objeto cuyo valor no cambia puede tener un hash estable. Si una clave de diccionario cambiara, quedaría guardada en la cubeta equivocada y sería inencontrable. Por eso dict exige claves inmutables.

Razonamiento local. Si un str no puede cambiar, pasarlo a una función no puede romper nada. La mitad de los bugs de estado compartido desaparecen cuando el dato es inmutable.

Compartir sin copiar. Dos hilos pueden leer el mismo frozenset sin bloqueos. Dos objetos pueden compartir la misma cadena de configuración sin miedo.

Caché. CPython puede reutilizar los enteros de −5 a 256 y las cadenas literales precisamente porque nadie puede modificarlos.

La elección entre mutable e inmutable no es de rendimiento: es de contrato. Una función que recibe una lista puede o no mutarla, y quien la llama no tiene forma de saberlo mirando la firma. Una función que recibe una tupla no puede mutarla, y eso convierte la firma en documentación.

Ese es el argumento real para frozen=True en una dataclass y para devolver tuplas en lugar de listas desde una API interna: no protege el dato de un atacante, protege el diseño de un futuro cambio accidental. Cuando alguien dentro de seis meses quiera «sólo añadir un campo», el TypeError se lo impide antes de que el bug llegue a producción.

El precio es real y hay que aceptarlo: inicializar un objeto congelado por fases requiere object.__setattr__ o un constructor que reciba todo de golpe. Si el objeto se construye en diez pasos, congelarlo produce código peor que el problema que evita.

Cuándo NO obsesionarse con la inmutabilidad

Sección titulada «Cuándo NO obsesionarse con la inmutabilidad»
  • No conviertas todo en tupla. Una lista que crece es la estructura correcta para una lista que crece; forzar tuplas produce código con t = t + (x,) que es O(n²).
  • frozen=True no es gratis. Una dataclass congelada sigue teniendo __dict__ salvo que añadas slots=True, y bloquea patrones legítimos como la inicialización por fases.
  • La inmutabilidad no sustituye a la sincronización. Un frozenset compartido es seguro de leer, pero reemplazar la referencia que lo apunta desde dos hilos sigue siendo una carrera. La Parte VI lo cubre.

Sin ejecutar, di qué imprime y por qué:

t = (1, [2, 3])
t[1] += [4]
print(t)
Solución

Imprime (1, [2, 3, 4]) y lanza TypeError al final.

t = (1, [2, 3])
try:
t[1] += [4]
except TypeError as e:
print("TypeError:", e)
print(t) # (1, [2, 3, 4]): la mutación sí ocurrió

t[1] += [4] se evalúa como t[1] = t[1].__iadd__([4]). El __iadd__ de la lista muta el objeto en su sitio —de ahí el 4 visible— y después Python intenta reasignar t[1], que es una tupla, y falla.

Es el ejemplo perfecto de las dos capas: la mutación ocurrió, la reasignación no. Quien capture el TypeError y mire t después encontrará el dato cambiado, y creerá que la excepción mintió.

  • Ramalho, L. Fluent Python, 2ª ed. Capítulo 6: mutabilidad, tuplas y reciclaje de objetos.
  • CPython 3.13: Objects/listobject.c (list_inplace_concat), Objects/tupleobject.c (tuple_concat).
  • Mediciones: mediciones/01-03-05-referencias.py.
  • 03 · Nombres, no variables: por qué el alias amplifica el efecto de mutar.
  • 05 · Copias: cómo aislar un objeto mutable de sus alias.
  • 09 · Hashabilidad: la consecuencia directa de ser inmutable.