Mutability, aliasing and cloning

You and your partner share one shopping list on the fridge. You call it “the list,” they call it “groceries.” Different names, same paper. When they cross out milk, it’s crossed out on your list too, because there is only one list.

That’s an alias: two names, one object.

If you each want your own list, you need to photocopy it. Now crossing something out on one doesn’t touch the other. That’s a clone.

The real words

• Every value is an object living somewhere in memory. A variable is a name that refers to an object.
• Mutable objects (lists, dictionaries, sets, most objects you’ll create) can be changed in place. Immutable ones (numbers, strings, tuples) can’t.
• An alias is a second name for the same object. b = a creates an alias.
• a is b asks “same object?” while a == b asks “same contents?”. Two clones are == but not is.
• A clone is a new object with the same contents: a[:], list(a), a.copy(). These make a shallow copy: if the list contains other lists, those inner lists are still shared. copy.deepcopy(a) copies all the way down.
• Passing a list to a function passes a reference to it. If the function mutates it, the caller sees the change: a side effect. Sometimes that’s what you want (lst.sort()); often it’s a surprise.
• A classic trap: changing a list while looping over it (for example, removing items) skips elements. Loop over a copy instead: for x in lst[:]:.

Why does it matter for immutable values? It doesn’t: if nothing can change, sharing is perfectly safe. That’s one reason immutability is so useful, and you’ll see it again in F03.