Thread by @treyhunner

Here's a deceptively fuzzy #Python term: mutable object. 🤔

mutable object: an object whose "value" can change

But what does "value" really mean?

#TerminologyTuesday

Lists are mutable because a list object can be changed.

>>> numbers = [2, 1, 3]
>>> numbers.append(4)
>>> numbers
[2, 1, 3, 4]

If two variables refer to the same list, any change to the list will be reflected by both variables:

>>> x = numbers
>>> x.clear()
>>> numbers
[]

Strings are immutable in #Python. That means that there is no way to "change" a string object in Python.

Try as hard as you might, you cannot change strings. You can only make NEW strings.

name = "Trey"
name = name + "!" # makes a new string
name += "!" # same as above

If you play around with the built-in id function, you'll see that anything you do to a string that SEEMS like it may change the string actually returns a new string instead.

>>> name = "Trey"
>>> id(name)
139687084218480
>>> name = name.lower()
>>> id(name)
139687076401968

So mutable objects can change and immutable objects can't. Simple, right?

Not so fast... tuples are where things start to get fuzzy.

At first glance, tuples seem just as immutable as strings. But unlike strings, a tuple's value can change (depending on how you define "value").

If 2 names point to the same tuple and we "change" one, we're (again) just making a new tuple:

>>> a = b = (3, 4)
>>> id(a)
139687093427712
>>> a += (5, 6)
>>> id(b) # b is the old tuple
139687093427712
>>> id(a) # a is a new one
139687084242496
>>> a
(3, 4, 5, 6)
>>> b
(3, 4)

But what if our tuple contains a mutable object?

>>> result = (True, {"name": "Trey"})
>>> again = result
>>> result[1]["name"] = "Jay"
>>> again
(True, {'name': 'Jay'})

When we changed the dictionary our tuple contains, the original tuple seemed to change too! 😦

This is possible because tuples don't "contain" objects. They just contain references (a.k.a. "pointers" or "bindings") to objects.

Our tuple still points to the same dictionary. But the dictionary it's pointing to happened to have changed.

It's a bit fuzzier though because a tuple which points to a mutable object can have its sense of equality change:

>>> result = (True, {"name": "Trey"})
>>> other = (True, {"name": "Trey"})
>>> result == other
True
>>> result[1]["name"] = "Jay"
>>> result == other
False

In general, if an immutable object can contain a reference to a mutable object (as tuples can), then it's possible to make an "immutable" object which can *seem* to "change" (by changing one of the objects it contains a reference to).

For more on mutability in #Python see:

1️⃣ This definition (and related definitions): pym.dev/terms/#mutable
2️⃣ An explanation of how Python's variables work: pym.dev/pointers/
3️⃣ @AlSweigart's
4️⃣ My #pythonoddity talk trey.io/oddities

Did you learn something new about Python? 🐍💖

For more #TerminologyTuesday tweets and daily #Python tips, follow me at @treyhunner and @PythonMorsels. 🌠

For my longer-form Python tips, get on my email newsletter: pym.dev/newsletter 📨