Maletas selladas: mutable e inmutable

En la reunión de la mañana, la supervisora Do Miran levanta una pegatina de precinto. «Nadie puede abrir una maleta que lleve esto. Pero el parte de hoy dice que una maleta sellada ha engordado.»

El código que envía la tienda duty free es corto. Al intentar meter un artículo en una tupla, saltó un TypeError. Sin embargo, al imprimir la tupla otra vez, el artículo estaba dentro. La supervisora lo resume: «El precinto está en la maleta de fuera. Eso no precinta la maleta que va dentro.»

2-1. Maletas selladas y maletas abiertas (9 min)

Los objetos se dividen en dos grupos. Si su contenido puede cambiar después de crearlos, son mutables; si no puede cambiar, son inmutables.

Los objetos inmutables simplemente no tienen ninguna forma de cambiar su contenido.

word = "gate"
print(word.upper(), word)
# GATE gate
word[0] = "G"
# TypeError: 'str' object does not support item assignment

fs = frozenset({1, 2})
fs.add(3)
# AttributeError: 'frozenset' object has no attribute 'add'

word.upper() no modifica word. Crea y devuelve una cadena nueva en mayúsculas. Todos los métodos de las cadenas funcionan así.

Entonces, ¿qué es n = n + 1? No se ha modificado la maleta del entero 10. Se obtiene un objeto entero nuevo, 11, y la etiqueta n se mueve hacia él. «Cambiar» un objeto inmutable siempre significa objeto nuevo + reasignación.

El tablero de abajo dibuja también los enteros como maletas propias. Fíjate adónde va la flecha de n después de la línea 3.

2-2. Las dos caras de += (10 min)

a += b parece una sola operación. Pero Python la resuelve así:

1. Si el tipo de a tiene el método __iadd__ (suma en el sitio), lo llama. Modifica la maleta en el sitio y devuelve esa misma maleta.
2. Si no lo tiene, hace como a = a + b: crea un objeto nuevo con __add__ y mueve la etiqueta.

print(hasattr(list, "__iadd__"), hasattr(int, "__iadd__"))
# True False
print(hasattr(str, "__iadd__"), hasattr(tuple, "__iadd__"))
# False False

Las listas son mutables y tienen __iadd__. Los tipos inmutables no lo tienen: una maleta sellada no se puede modificar en el sitio. Por eso el mismo += se comporta de dos maneras.

a = [1, 2]
b = a
a += [3]
print(a, b, a is b)
# [1, 2, 3] [1, 2, 3] True

a = (1, 2)
b = a
a += (3,)
print(a, b, a is b)
# (1, 2, 3) (1, 2) False

a = "T1"
b = a
a += "-A"
print(a, b, a is b)
# T1-A T1 False

Por eso a = a + [3] de la lección 1 y a += [3] con una lista dan resultados distintos: el primero crea una lista nueva; el segundo usa la misma. |= en set y en dict también modifica en el sitio, igual que la lista.

Prueba los tres tipos uno tras otro.

2-3. El precinto solo cubre la maleta de fuera: listas dentro de tuplas (8 min)

Que una tupla sea inmutable significa, exactamente, que «no se pueden cambiar las referencias que guarda». Cada casilla apunta siempre al mismo objeto. Pero si ese objeto es una lista, la lista en sí puede cambiar todo lo que quiera.

t = (1, [2])
t[1].append(3)
print(t)
# (1, [2, 3])
t[1] = [9]
# TypeError: 'tuple' object does not support item assignment

El código del parte usaba += en lugar de append. Y aquí pasa algo curioso:

t = (1, [2])
try:
    t[1] += [3]
except TypeError as e:
    print("TypeError:", e)
print(t)
# TypeError: 'tuple' object does not support item assignment
# (1, [2, 3])

Hubo un error y, aun así, la lista cambió. Es porque t[1] += [3], desglosado, son dos pasos:

t = (1, [2])
tmp = t[1]
tmp = tmp.__iadd__([3])   # paso 1: modifica la lista en el sitio (funciona)
print(t)
# (1, [2, 3])
t[1] = tmp                # paso 2: la vuelve a poner en la casilla de la tupla (falla)
# TypeError: 'tuple' object does not support item assignment

En el paso 1 la lista ya ha cambiado. La asignación a la casilla del paso 2 falla y lanza el error, pero no hay forma de deshacer lo anterior. Por eso la báscula gritaba «una maleta sellada no se puede abrir» mientras el artículo entraba.

Hay una forma sencilla de saber si algo está sellado hasta dentro: comprobar si hash() funciona. Una tupla con hash solo contiene objetos que también tienen hash (normalmente, inmutables) (lección 12).

print(hash(("passport", ("snack",))) == hash(("passport", ("snack",))))
# True
hash(("passport", ["snack"]))
# TypeError: unhashable type: 'list'

2-4. El coste de unir cadenas con += (6 min)

Como las cadenas son inmutables, s += "x" crea en principio una cadena nueva cada vez. Si construyes una cadena de longitud n letra a letra, el número de caracteres copiados crece como 1 + 2 + … + n.

def plus(n):
    s = ""
    for i in range(n):
        s += "x"
    return s

def plus_shared(n):
    s = ""
    for i in range(n):
        last = s          # la misma cadena lleva una etiqueta más
        s += "x"
    return s

def join(n):
    return "".join(["x" for i in range(n)])

print(plus(5) == plus_shared(5) == join(5))
# True

En CPython, si una cadena tiene una sola etiqueta, += aplica a escondidas una optimización que la alarga en el sitio. Por eso plus es más rápido de lo que cabría esperar. Pero basta con una etiqueta más para que la optimización desaparezca. Estas son medidas tomadas en este PC (CPython 3.14.2):

Al duplicar las iteraciones, plus_shared tardó casi cuatro veces más: la cantidad copiada crece con el cuadrado. Esa optimización no es una promesa del lenguaje, así que, cuando acumules cadenas en un bucle, guárdalas en una lista y únelas de una vez con "".join().

2-5. Enteros pequeños e interning: por qué no se usa is para comparar valores (7 min)

Un objeto inmutable nunca va a cambiar, así que es seguro que varios compartan un único objeto con el mismo valor. CPython lo aprovecha para crear de antemano los objetos que se usan a menudo.

Caché de enteros pequeños. CPython crea al arrancar los enteros del -5 al 256 y siempre devuelve esos mismos objetos.

print(int("256") is int("256"), int("257") is int("257"))
# True False
print(int("-5") is int("-5"), int("-6") is int("-6"))
# True False

Creamos los enteros en tiempo de ejecución con int("…") a propósito. Si escribes literales directamente en el código, como 257 is 257, el compilador puede fusionar las constantes iguales en una y dar True. Python incluso avisa de este tipo de comparaciones:

x = 256
print(x is 256)
# SyntaxWarning: "is" with 'int' literal. Did you mean "=="?
# True

Interning de cadenas. CPython reúne en un solo objeto las constantes de cadena que parecen nombres (interning). Las cadenas creadas durante la ejecución pueden ser objetos distintos aunque tengan el mismo valor. Con sys.intern() puedes hacer que las cadenas con el mismo valor sean un único objeto.

import sys
a = "gate"
b = "".join(["ga", "te"])
print(a == b, a is b)
# True False
print(sys.intern(b) is a)
# True

Como el resultado depende de la caché y del interning, comparar valores con is acierta con unos valores y falla con otros. Los valores se comparan siempre con ==; is se reserva para objetos únicos como None.

Caso cerrado (10 min)

Este es el código del parte y la forma de crear una maleta que de verdad no se pueda abrir.

sealed = ("passport", ["snack"])
try:
    sealed[1] += ["perfume"]
except TypeError as e:
    print("scale:", e)
print(sealed)
# scale: 'tuple' object does not support item assignment
# ('passport', ['snack', 'perfume'])

sealed = ("passport", ("snack",))   # también una tupla por dentro
try:
    sealed[1] += ("perfume",)
except TypeError as e:
    print("scale:", e)
print(sealed)
# scale: 'tuple' object does not support item assignment
# ('passport', ('snack',))

• La primera maleta solo estaba sellada por fuera. El __iadd__ de la lista interior funcionó primero, y lo único que falló fue la asignación a la casilla.
• La segunda maleta también es una tupla por dentro. Las tuplas no tienen __iadd__, así que solo se crea una tupla nueva y la asignación a la casilla falla. La maleta original queda intacta.

La supervisora pega un precinto nuevo también en la maleta interior. «El precinto no termina por fuera. Hay que mirar también las maletas que van dentro.»

Ejercicios

1. Después de ejecutar x = 1000, y = x y x += 1, ¿qué vale y? Dibuja las etiquetas y luego compruébalo.
2. Si ejecutas s = {1}, t = s y s |= {2}, ¿qué le pasa a t? Prueba también cambiándolo por frozenset({1}).
3. Con t = ([],), ¿cómo termina cada una de estas, t[0] += [1] y t[0].extend([1])? Después de ejecutarlas, imprime también t.