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.
En una línea
Sección titulada «En una línea»Mutable es «cambia donde está». Inmutable es «se reemplaza por otro y la etiqueta se mueve».
El mapa
Sección titulada «El mapa»| 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 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 reasignart[0].append(3) # funciona: la lista de dentro es mutablet # ([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.
La medición: += frente a +
Sección titulada «La medición: += frente a +»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:
| 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 listaacumulado = []for fila in filas: acumulado = acumulado + [fila]
# O(n): cada vuelta appendea en el hueco reservadoacumulado = []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.
Por qué la inmutabilidad paga
Sección titulada «Por qué la inmutabilidad paga»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 inmutabilidad como contrato de API
Sección titulada «La inmutabilidad como contrato de API»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.
La trampa
Sección titulada «La trampa»Cuándo no aplica
Sección titulada «Cuándo no aplica»- 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=Trueno es gratis. Una dataclass congelada sigue teniendo__dict__salvo que añadasslots=True, y bloquea patrones legítimos como la inicialización por fases.- La inmutabilidad no sustituye a la sincronización. Un
frozensetcompartido es seguro de leer, pero reemplazar la referencia que lo apunta desde dos hilos sigue siendo una carrera. La Parte VI lo cubre.
Ejercicio
Sección titulada «Ejercicio»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ó.
Referencias
Sección titulada «Referencias»- 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.
Capítulos relacionados
Sección titulada «Capítulos relacionados»- 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.