Mis apuntes · Aprende Python desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 20 de 47 · Memoria: referencias y mutabilidad ✦ WebMCP implementado

Mutable frente a inmutable y la trampa del [] por defecto

10 min de lectura 4 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.

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, boollist
strdict
tupleset
frozenset, Nonecasi 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"
except TypeError as 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
def anade_tarea(tareas, titulo):
    # En PHP: function anadeTarea(array &$tareas, string $titulo)
    tareas.append(titulo)


def reasigna(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_tarea modificó 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.

PHP 8.5index.php
<?php
declare(strict_types=1);

function anadeTarea(array $tareas, string $titulo): array
{
    $tareas[] = $titulo;
    return $tareas;
}

function anadeTareaRef(array &$tareas, string $titulo): void
{
    $tareas[] = $titulo;
}

$hoy = ["Comprar pan"];
anadeTarea($hoy, "Llamar al banco");
echo count($hoy) . PHP_EOL;

anadeTareaRef($hoy, "Llamar al banco");
echo count($hoy) . PHP_EOL;
Pythonmain.py
def anade_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.

PHP 8.5index.php
<?php
declare(strict_types=1);

final class Tarea
{
    public function __construct(public string $titulo) {}
}

$a = [new Tarea("Comprar pan")];
$b = $a;
$b[0]->titulo = "Llamar al banco";
echo $a[0]->titulo . PHP_EOL;

$c = [clone $a[0]];
$c[0]->titulo = "Repasar PHP";
echo $a[0]->titulo . PHP_EOL;
Pythonmain.py
import copy
from types import SimpleNamespace

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…PythonQué copia
Otra lista con los mismos elementoslista.copy(), list(lista), lista[:]Superficial
Otro diccionariodic.copy(), dict(dic)Superficial
Copia de cualquier objetocopy.copy(x)Superficial
Copia independiente de verdadcopy.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.

Pythonmain.py
tarea = ("Comprar pan", ["urgente"])

try:
    tarea[1] += ["casa"]
except TypeError as error:
    print(error)

print(tarea)

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
def crea_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.

PHP 8.5index.php
<?php
declare(strict_types=1);

function creaTarea(string $titulo, array $etiquetas = []): array
{
    $etiquetas[] = "pendiente";
    return ["titulo" => $titulo, "etiquetas" => $etiquetas];
}

$primera = creaTarea("Comprar pan");
$segunda = creaTarea("Llamar al banco");

echo count($primera["etiquetas"]) . PHP_EOL;
echo count($segunda["etiquetas"]) . PHP_EOL;
Pythonmain.py
def crea_tarea(titulo, etiquetas=None):
    # En PHP: array $etiquetas = [] (se evalúa en cada llamada)
    if etiquetas is None:
        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

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

Resumen

Lo que te llevas de esta lección

  1. Inmutables: int, str, tuple, frozenset, None. Mutables: list, dict, set (en PHP, un array se copia al asignar).
  2. Las funciones reciben una referencia al objeto: pueden cambiarlo (mutables) pero no «reasignar» tu variable. No hay & ni copia por valor.
  3. .copy(), list(x) y x[:] son copias superficiales; copy.deepcopy(x) es profunda (como un clone recursivo de PHP).
  4. += en una lista muta; en una tupla o un texto crea uno nuevo.
  5. 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.