Mutable vs Immutable Types in Python

Sticky notes and flowers explain Python types.

In Python, every value is either mutable (can change) or immutable (locked once created).

Immutable types can’t change the original

But Python can create a new value. I think of immutable types like sticky notes. You write one and stick it on the fridge. If you want to change the message, you don't edit the original note you replace it with a new sticky note. Same kind of note, but a new version.

word = " yay "

loud = word.upper()
quiet = word.lower()
swapped = word.replace("yay", "woohoo")
trimmed = word.strip()
fancy = word.title()

print(f"{word=}")
print(f"{loud=}")
print(f"{quiet=}")
print(f"{swapped=}")
print(f"{trimmed=}")
print(f"{fancy=}")

# Output:
# word=' yay '
# loud=' YAY '
# quiet=' yay '
# swapped=' woohoo '
# trimmed='yay'
# fancy=' Yay '

The string “yay” didn’t change. Python made a new “YAY”.

When we created word = "yay", Python carved out a spot in memory for that string. Then when we called word.upper(), Python didn't touch the original. It made a completely new string "YAY" in a different memory location. The variable loud points to this new string, while word still points to the original, untouched "yay".

This is what immutability means. Once created, the value stays fixed. You have to make new values rather than changing existing ones. Here are the common immutable types you'll work with:

Python’s common immutable data types

Mutable types can be changed in place

I like to picture it like flowers in a vase in that the flowers change season to season. But the vase stays the same, and you swap out what’s inside.

flowers = ["sunflower", "cherry blossom"]
flowers.append("rose")     # vase is the same, flowers changed
print(flowers)             # ['sunflower', 'cherry blossom', 'rose']

The mutable types commonly used:

Quick-reference chart of common mutable data types

The distinction

If it's a collection that holds multiple things (like lists, dictionaries, sets), it's usually mutable and can be changed in place. If it's a single value (numbers, strings), it's usually locked down and immutable.

When you need to work with them, mutable types are more efficient to update without creating new copies, while immutable types give you guarantees that the data won't unexpectedly change.

This distinction matters. Functions with mutable default arguments can behave in surprising ways. When you pass mutable objects to functions, the function might change the original object. Understanding which data types can change and which cannot helps you write more predictable code and avoid confusing bugs as your programs grow.