Lección 20 de 47 · Memoria: referencias y mutabilidad✦ WebMCP implementado
Mutable frente a inmutable y la trampa del [] por defecto
10 min de lectura4 retos
Algunos objetos de Python se pueden cambiar por dentro (las listas) y otros no (los textos, los números, las tuplas). Saber cuáles son cuáles explica cómo se pasan los argumentos a una función, cuándo hace falta copiar y por qué un [] como valor por defecto es una trampa.
¿De dónde vienen los nombres?
mutable = latín mutabilis (que puede cambiar), de mutare (cambiar)
Un objeto mutable se puede modificar sin crear otro. Inmutable es lo contrario.
copy = inglés copy (copiar)
Módulo de la biblioteca estándar con copy.copy() (copia superficial) y copy.deepcopy() (copia profunda).
deepcopy = inglés deep copy (copia profunda)
Copia el objeto y todo lo que contiene, nivel tras nivel, hasta el fondo.
frozenset = inglés frozen set (conjunto congelado)
Un set que no se puede cambiar. Es al set lo que la tupla es a la lista.
En 4 ideas
1/4
Inmutables: int, float, str, bool, tuple, frozenset, None. Mutables: list, dict, set. En PHP los arrays se copian al asignar y son «inmutables» por eso; en Python una lista se comparte y se cambia por dentro.
Una función recibe una referencia al objeto (otra etiqueta): si le pasas una lista y la modifica, tu lista cambia. Si solo reasigna su parámetro, tu variable no se entera. No existe el &$x de PHP.
Para copiar: lista.copy(), list(lista) o lista[:] hacen una copia superficial (el contenedor nuevo, los mismos elementos); copy.deepcopy() copia todo. Con listas de listas la diferencia importa.
Nunca [] ni {} como valor por defecto: se crea una sola vez y se comparte entre llamadas. Pon None y crea la lista dentro de la función.
1 · Qué se puede cambiar y qué no
Piensa en una pizarra y en un bolígrafo sobre papel. A una lista le puedes borrar y escribir encima sin cambiar de pizarra (mutable). Un texto es un papel impreso: para «cambiarlo» tienes que imprimir otro (inmutable).
Inmutables (no cambian)
Mutables (cambian por dentro)
int, float, bool
list
str
dict
tuple
set
frozenset, None
casi todas tus propias clases
Pythonmain.py
titulo = "comprar pan"
id_antes = id(titulo)
# En PHP: $titulo = strtoupper($titulo); (una cadena nueva)
mayusculas = titulo.upper()
print(titulo)
print(mayusculas)
print(id(mayusculas) == id_antes)
pendientes = ["Comprar pan"]
id_lista = id(pendientes)
# En PHP: $pendientes[] = "Llamar al banco";
pendientes.append("Llamar al banco")
print(pendientes)
print(id(pendientes) == id_lista)
upper()no cambiótitulo: devolvió un texto nuevo. append() sí cambió la lista, y sigue siendo el mismo objeto (mismo id). Un texto nunca se cambia: lo que haces es pegar la etiqueta a otro texto.
Pythonmain.py
tupla = ("Comprar pan", "Llamar al banco")
try:
tupla[0] = "Otra cosa"exceptTypeErroras error:
print(error)
# En PHP: $copia = [...$lista, "Repasar"];
nueva = tupla + ("Repasar Python",)
print(nueva)
print(tupla)
¿Por qué? · En PHP no existe
¿Por qué existen los inmutables? En PHP no hay nada igual
En PHP un array siempre es seguro de compartir porque se copia al pasarlo. En Python no se copia, así que alguien que reciba tu lista puede cambiártela. Los inmutables dan una garantía: lo que recibes no cambiará nunca.
Esa garantía tiene premio: solo los objetos inmutables pueden ser claves de un diccionario o elementos de un set. Una tupla (2026, 11, 18) vale como clave; una lista no. Y las tuplas son además más ligeras que las listas.
2 · Qué recibe una función: la referencia al objeto
En PHP tienes dos formas de pasar: por valor (se copia el array) y por referencia (&$x). En Python hay una sola: la función recibe una etiqueta nueva pegada al mismo objeto (llamado «paso por referencia al objeto»). Lo que pase después depende de si el objeto se puede cambiar.
Pythonmain.py
defanade_tarea(tareas, titulo):
# En PHP: function anadeTarea(array &$tareas, string $titulo)
tareas.append(titulo)
defreasigna(tareas):
# Pega la etiqueta local a una lista nueva; la de fuera no se entera.
tareas = ["Otra lista"]
return tareas
hoy = ["Comprar pan"]
anade_tarea(hoy, "Llamar al banco")
print(hoy)
reasigna(hoy)
print(hoy)
anade_tareamodificó el objeto y hoy lo ve. reasigna solo movió su pegatina local, y hoy sigue igual. Con un inmutable no hay nada que modificar, así que una función nunca puede cambiar un int o un str que recibe.
defanade_tarea(tareas, titulo):
tareas.append(titulo)
hoy = ["Comprar pan"]
# En PHP: anadeTareaRef($hoy, ...) ya modificaba $hoy; anadeTarea($hoy, ...) no.anade_tarea(hoy, "Llamar al banco")
print(len(hoy))
Python no tiene una versión «por copia»: la función siempre puede mutar lo que recibe. Por eso, una función bien educada hace una de dos cosas, y lo dice en su nombre o su documentación: modifica y devuelve None (como lista.sort()), o no toca el original y devuelve uno nuevo (como sorted(lista)).
3 · Copias: superficial frente a profunda
Como asignar no copia, cuando quieres un duplicado hay que pedirlo. Pero hay dos niveles. La copia superficial (shallow) hace una caja nueva y mete los mismos objetos dentro. La profunda (deep) duplica también todo lo que hay dentro. Es la diferencia entre fotocopiar el índice de una carpeta y fotocopiar todos sus folios.
Pythonmain.py
import copy
tablero = [["Comprar pan"], ["Llamar al banco"]]
# Tres formas de copia superficial.
a = tablero.copy()
b = list(tablero)
c = tablero[:]
print(a is tablero, b is tablero, c is tablero)
# Pero las listas de dentro siguen siendo las mismas.print(a[0] is tablero[0])
# En PHP: $copia = $tablero; $copia[0][] = "x"; (no afecta a $tablero)
a[0].append("Repasar Python")
print(tablero)
# Copia profunda: todo es nuevo.
d = copy.deepcopy(tablero)
d[1].append("Otra tarea")
print(tablero)
print(d)
a, b y c son listas nuevas, pero guardan las mismas dos listas interiores. Tocar una por el camino de a se ve en tablero. Con deepcopy, d es independiente de arriba abajo.
import copy
from types importSimpleNamespace
a = [SimpleNamespace(titulo="Comprar pan")]
# En PHP: $b = $a; (copia el array, pero los objetos son los mismos)
b = a.copy()
b[0].titulo = "Llamar al banco"print(a[0].titulo)
# En PHP: [clone $a[0]]
c = copy.deepcopy(a)
c[0].titulo = "Repasar Python"print(a[0].titulo)
En PHP ya conocías este fenómeno sin nombre: el array se copia, pero los objetos de dentro se siguen compartiendo (hasta que usas clone). La copia superficial de Python es esa misma copia de PHP; deepcopy es el clone aplicado a todo el árbol.
Quiero…
Python
Qué copia
Otra lista con los mismos elementos
lista.copy(), list(lista), lista[:]
Superficial
Otro diccionario
dic.copy(), dict(dic)
Superficial
Copia de cualquier objeto
copy.copy(x)
Superficial
Copia independiente de verdad
copy.deepcopy(x)
Profunda
¿Por qué? · En PHP no existe
¿Por qué la copia es superficial por defecto?
Una copia profunda tiene que recorrer todo el objeto, y si dos elementos comparten una parte, hay que cuidar de no duplicarla ni de caer en bucles infinitos. Es mucho más lenta, y la mayoría de las veces solo necesitas una lista nueva (por ejemplo, para ordenarla sin tocar la original).
Con listas de números o textos (inmutables), la copia superficial ya es independiente: nadie puede cambiar un 3 por dentro. El problema solo aparece con mutables dentro de mutables.
4 · +=: no es lo mismo en una lista que en una tupla
a += b parece una abreviatura de a = a + b, pero con las listas no lo es. En una lista, +=cambia el objeto (como extend); en una tupla o un texto, que no se pueden cambiar, crea uno nuevo y pega la etiqueta.
Pythonmain.py
lista = ["Comprar pan"]
otra = lista
lista += ["Llamar al banco"]
print(otra)
tupla = ("Comprar pan",)
otra_tupla = tupla
tupla += ("Llamar al banco",)
print(otra_tupla)
print(tupla)
La lista cambió también para otra (era el mismo objeto). La tupla original quedó intacta: tupla += ... creó una tupla nueva y movió la etiqueta.
Y hay un caso curioso que ilustra todo lo anterior: una tupla con una lista dentro.
Falla (no se puede reasignar tarea[1]) pero la lista de dentro ya había cambiado. Primero se ejecuta el += sobre la lista (mutable, funciona) y después se intenta guardar el resultado en la tupla (inmutable, error).
5 · La trampa del [] por defecto
Con lo que sabes ya puedes entender el fallo clásico de Python, el que te avisó la lección de funciones. Un parámetro con valor por defecto se crea una sola vez, cuando se ejecuta el def, y queda pegado a la función. Si ese valor es una lista, todas las llamadas que no pasen nada comparten esa misma lista.
Pythonmain.py
defcrea_tarea(titulo, etiquetas=[]):
etiquetas.append("pendiente")
return {"titulo": titulo, "etiquetas": etiquetas}
primera = crea_tarea("Comprar pan")
segunda = crea_tarea("Llamar al banco")
print(primera["etiquetas"])
print(segunda["etiquetas"])
print(primera["etiquetas"] is segunda["etiquetas"])
Cada tarea debería tener ["pendiente"] y tiene dos: es la misma lista acumulando. Lo arreglas con None como señal de «no me han dado nada» y creando la lista dentro de la función, en cada llamada.
defcrea_tarea(titulo, etiquetas=None):
# En PHP: array $etiquetas = [] (se evalúa en cada llamada)if etiquetas isNone:
etiquetas = []
etiquetas.append("pendiente")
return {"titulo": titulo, "etiquetas": etiquetas}
primera = crea_tarea("Comprar pan")
segunda = crea_tarea("Llamar al banco")
print(len(primera["etiquetas"]))
print(len(segunda["etiquetas"]))
¿Por qué? · En PHP no existe
¿Por qué el valor por defecto se crea una sola vez? En PHP no
En PHP el valor por defecto se evalúa cada vez que llamas, y como el array se copia, es siempre uno nuevo. En Python, def es una instrucción que se ejecuta una vez y guarda los valores por defecto en la función: es más rápido y simple, pero se pierde la copia automática.
La solución con None funciona porque None es inmutable: no puede acumular nada. Y is None (lección anterior) es la forma correcta de preguntar si no te pasaron nada.
Este fallo es tan típico que los linters de Python (ruff, pylint) lo marcan como error. Cuando veas =[] en una firma, para y cámbialo.
Hora de practicar
Retos · 0/4 resueltos
Reto 1 de 4 · ✓ Resuelto
Otra lista, no la misma
Escribe con_etiqueta(etiquetas, nueva), que devuelva una lista nueva con las etiquetas y la nueva al final, sin modificar la lista que recibe. En PHP no hacía falta pensarlo: el array llegaba copiado.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Haz una copia primero: copia = etiquetas.copy() o [*etiquetas, nueva].
Reto 2 de 4 · ✓ Resuelto
Cada tarea, sus etiquetas
Arregla crea_tarea(titulo, etiquetas=...) para que cada llamada sin etiquetas obtenga su propia lista vacía, y para que, si le pasan una lista, la tarea guarde una copia (no la misma). Devuelve {"titulo": ..., "etiquetas": ...}.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Pon None por defecto, crea [] dentro si hace falta y guarda list(etiquetas).
Reto 3 de 4 · ✓ Resuelto
Duplica el tablero
Escribe duplica_tablero(tablero), que reciba un diccionario de listas ({"hoy": [...], "luego": [...]}) y devuelva una copia totalmente independiente: cambiar una lista del duplicado no puede afectar al original. Es el clone recursivo que PHP no tiene.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista.dict.copy() es superficial: las listas de dentro siguen siendo las mismas. Importa copy y usa copy.deepcopy.
Reto 4 de 4 · ✓ Resuelto
Añadir sin perder el original
Escribe anade_al_final(pendientes, titulo), que reciba una tupla de títulos y devuelva una tupla nueva con el título añadido al final. La tupla original no puede cambiar (no puede, es inmutable): lo que vigilamos es que no devuelvas una lista.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Para una tupla de un solo elemento hay que poner la coma: (titulo,). Súmala con +.
Resumen
Lo que te llevas de esta lección
Inmutables: int, str, tuple, frozenset, None. Mutables: list, dict, set (en PHP, un array se copia al asignar).
Las funciones reciben una referencia al objeto: pueden cambiarlo (mutables) pero no «reasignar» tu variable. No hay & ni copia por valor.
.copy(), list(x) y x[:] son copias superficiales; copy.deepcopy(x) es profunda (como un clone recursivo de PHP).
+= en una lista muta; en una tupla o un texto crea uno nuevo.
Valor por defecto: None, nunca [] ni {} (en PHP el array por defecto se recrea en cada llamada; en Python no).
Para recordarlo: «Lista, Tupla, None»
LLista muta append, += cambian el objeto
TTupla renace += crea una tupla nueva
NNone por defecto nunca [] en la firma
Si dudas: Lista cambia por dentro, Tupla y texto nacen de nuevo, y en los parámetros por defecto, None.