Nombres, no variables
La metáfora que trae todo el mundo de C o de Java es la caja: una variable es un recipiente, y asignar mete un valor dentro. En Python no hay cajas. Hay objetos sueltos en memoria y nombres que los señalan. Cuando escribes b = a, no estás copiando el contenido de a en b: estás pegando una segunda etiqueta al mismo objeto.
Esa diferencia explica la mitad de los errores que en Python parecen inexplicables: el argumento que se modifica sin querer, la lista de configuración que cambia en dos sitios a la vez, el diccionario que se llena solo.
En una línea
Sección titulada «En una línea»Una asignación no guarda un valor: pega una etiqueta a un objeto que ya existe.
Dos etiquetas, un objeto
Sección titulada «Dos etiquetas, un objeto»`b = a` hace que dos nombres apunten al mismo objeto. `c = list(a)` crea un objeto nuevo. La igualdad de contenido no dice cuál de los dos casos tienes: para eso está `is`.
a = [1, 2, 3]b = a # alias: no copiac = list(a) # copia: objeto nuevo
a is b # Truea is c # Falsea == c # True — mismo contenido, objetos distintos
b.append(4)a # [1, 2, 3, 4] — el alias lo vec # [1, 2, 3] — la copia noLa prueba: el contador de referencias
Sección titulada «La prueba: el contador de referencias»No hace falta creer la metáfora. Cada objeto lleva la cuenta de cuántas referencias lo apuntan, y esa cuenta sube con cada asignación:
| Momento | refcount |
|---|---|
a = [] |
2 |
b = a |
3 |
c = [a] (dentro de otra lista) |
4 |
python mediciones/01-03-05-referencias.py
El dos inicial es el objeto más la referencia temporal que getrefcount crea al recibirlo como argumento. Lo que importa es el incremento: cada asignación suma una referencia, ninguna resta contenido. Si b = a copiara, el contador no se movería.
Ese contador es también lo que decide cuándo muere un objeto: cuando llega a cero. Es el tema de la Parte V.
is frente a ==, ahora con consecuencias
Sección titulada «is frente a ==, ahora con consecuencias»==pregunta: ¿tienen el mismo contenido?ispregunta: ¿son el mismo objeto?
Para inmutables la distinción casi nunca importa, porque no puedes cambiar uno sin crear otro. Para mutables lo es todo: dos listas iguales pueden evolucionar por separado, o pueden ser la misma lista con dos nombres.
La regla práctica: is sólo con None y con centinelas propios. Todo lo demás, ==. El capítulo 01 ya mostró por qué is con enteros y cadenas es una trampa: depende de la caché y del plegado de constantes.
El alias entra en las funciones
Sección titulada «El alias entra en las funciones»Cuando pasas un objeto a una función, el parámetro es otro nombre para el mismo objeto. No hay copia en la llamada:
def añadir_uno(items): items.append(1)
mi_lista = []añadir_uno(mi_lista)mi_lista # [1]Esto no es un defecto: es lo que permite que una función reordene una lista en su sitio, o que un método modifique su objeto. Pero significa que toda función que muta su argumento está modificando el estado del llamador, y eso tiene que ser una decisión explícita, no un accidente.
La distinción que hay que tener clara:
| La función… | Efecto en el llamador |
|---|---|
Reasigna el parámetro (items = []) |
Ninguno: sólo mueve su etiqueta local |
Muta el objeto (items.append(x)) |
Cambia el objeto del llamador |
| Devuelve un objeto nuevo | Ninguno, salvo que el llamador lo guarde |
Dónde se esconden las referencias
Sección titulada «Dónde se esconden las referencias»Un alias no siempre se ve como b = a. Cualquier estructura que guarde el objeto suma una referencia, y todas ellas cuentan para el reciclaje:
| Operación | Referencias que añade |
|---|---|
b = a |
1 (el nombre) |
lista.append(a) |
1 (el hueco de la lista) |
d["clave"] = a |
1 (el valor del diccionario) |
objeto.atributo = a |
1 (el atributo) |
f(a) |
1 mientras dura la llamada (el parámetro) |
weakref.ref(a) |
0 (referencia débil: no impide liberar) |
Esto explica dos comportamientos que parecen magia. El primero: guardar un objeto en una lista lo mantiene vivo aunque el nombre original desaparezca. El segundo: una caché que guarda objetos en un diccionario los mantiene vivos para siempre, y es una de las fugas de memoria más comunes. La Parte V vuelve sobre ello con weakref.
La trampa
Sección titulada «La trampa»Cuándo no aplica
Sección titulada «Cuándo no aplica»- Con inmutables, el alias es inofensivo: si nadie puede cambiar el objeto, dos nombres son indistinguibles de dos copias.
a = "texto"; b = ano puede romper nada. - Cuando el objeto se trata como valor, es decir, nunca se muta después de crearlo. Una tupla, un
frozenseto unadataclass(frozen=True)convierten el problema en imposible. - Cuando la copia defensiva cuesta más que el riesgo. Copiar una estructura de un millón de filas en cada llamada para protegerte de una mutación que no ocurre es un pesimismo caro. Documenta el contrato y mide.
Ejercicio
Sección titulada «Ejercicio»Predice la salida de este programa y explica cada línea:
a = [1, 2]b = ac = a[:]b.append(3)c.append(4)print(a, b, c)
def f(x): x = x + [9]
f(b)print(b)Solución
[1, 2, 3] [1, 2, 3] [1, 2, 4] y después [1, 2, 3].
b = aes alias:append(3)afecta al mismo objeto, y se ve por los dos nombres.c = a[:]es copia superficial:append(4)sólo toca la copia.- Dentro de
f,x = x + [9]reasigna el nombre localxa una lista nueva; no muta el objeto del llamador.bqueda intacto.
La última línea es la que separa «entiendo el alias» de «entiendo la asignación»: x + [9] crea, x += [9] muta. El capítulo 04 mide la diferencia.
Referencias
Sección titulada «Referencias»- Ramalho, L. Fluent Python, 2ª ed. Capítulo 6: Object References, Mutability, and Recycling.
- Lott, S. F. Modern Python Cookbook, 3ª ed. Receta 5.4: variables, referencias y asignación.
- Mediciones:
mediciones/01-03-05-referencias.py.
Capítulos relacionados
Sección titulada «Capítulos relacionados»- 04 · Mutabilidad: la propiedad que hace que el alias sea peligroso o inofensivo.
- 05 · Copias: cómo romper el alias cuando lo necesitas.
- 06 · Argumentos: el alias en la frontera de las funciones.