Learn What Immutable Means in Python: Absolute Beginners Tutorial

If you have been learning Python for even a short time, you have probably seen the word immutable in error messages, documentation, or tutorials — and wondered what it really means. This tutorial explains the concept from first principles, with examples you can run and challenges you can try.

Python organizes its values into objects. Every object has a type, a value, and an identity. The word immutable describes what can happen to that value after the object is created. For an immutable object, nothing can. For a mutable object, the value can change while the identity stays the same. Understanding this distinction shapes how you read code, how you track bugs, and how you make decisions about which data structures to reach for.

What Immutable Actually Means

Immutable means cannot be changed after creation. Once Python creates an immutable object and gives it a value, that value is locked. You cannot alter it directly. You can, however, create a new object that holds a different value, and you can point a variable name at that new object.

This is a distinction that trips up many beginners. Reassigning a variable looks like you are changing an object, but you are not. You are simply changing which object the variable name refers to. The original object is untouched.

# x points to the integer object 10
x = 10
print(id(x))   # e.g. 140234567890

# "adding 1" does NOT change the object at id 140234567890
# Python creates a NEW integer object (11) and points x at it
x = x + 1
print(id(x))   # a different id — a different object entirely

The integer 10 that existed on the first line still exists in memory, unchanged. Python just stopped using that object for x.

Contrast this with a mutable type. A list is mutable, meaning you can change its contents while keeping the same object:

my_list = [1, 2, 3]
print(id(my_list))   # e.g. 140234599001

my_list.append(4)    # modifies the existing object in place
print(id(my_list))   # SAME id — same object, new content
print(my_list)       # [1, 2, 3, 4]

The list object was modified in place. Its identity — the number returned by id() — did not change. That is what mutable means: the value changes, the identity stays the same.

Which Python Types Are Immutable and Which Are Mutable

Python's built-in types split cleanly into two groups. Knowing which side a type falls on saves you from a category of confusing bugs.

Object Identity and the id() Function

Python assigns every object a unique integer called its identity. You can read this number using id(). Two variables can hold the same value but point to different objects, or they can both point to the exact same object. The is operator tests identity (same object), while == tests equality (same value).

a = 5
b = 5

print(a == b)   # True  — same value
print(a is b)   # True  — CPython caches small ints, same object

x = 1000
y = 1000

print(x == y)   # True  — same value
print(x is y)   # False — large ints are not cached, different objects

The cached-integer behavior is an implementation detail of CPython (the standard Python interpreter). Python guarantees that integers from -5 to 256 will reuse the same object, but this is not a language rule — it is a performance optimization. You should use == to compare values and reserve is for cases where you genuinely need to know if two names point to the exact same object.

"An object's identity never changes once it has been created." — Python Language Reference, Data Model

For strings, CPython applies a similar optimization called string interning. Short strings that look like identifiers are often interned, meaning equal strings share one object. Longer strings or strings built at runtime may not be interned, so do not rely on is to compare strings.

# Demonstrating what happens to identity when you "change" a string
name = "python"
print(id(name))

name = name.upper()   # .upper() returns a NEW string object
print(id(name))       # different id — the original "python" object is untouched
print(name)           # PYTHON

inner = [1, 2, 3]
container = (10, inner, "fixed")

# This raises TypeError — you cannot replace an element in a tuple
# container[0] = 99

# But this works — the list inside can still be mutated
inner.append(4)
print(container)   # (10, [1, 2, 3, 4], 'fixed')

Python Learning Summary Points

1. An immutable object's value cannot change after it is created. Python's built-in immutable types are int, float, bool, complex, str, bytes, and tuple. Mutable types include list, dict, set, and bytearray.
2. Reassigning a variable does not mutate the original object. It creates a new object (or reuses an existing one) and redirects the variable label to it. The id() function reveals this: an immutable "update" always produces a new id, while an in-place mutation on a mutable type keeps the same id.
3. Only immutable objects can be used as dictionary keys or set elements, because Python needs their hash values to remain stable. If you need an immutable version of a list, use a tuple. If you need an immutable version of a set, use a frozenset.

Immutability is one of those concepts that pays dividends the longer you work with Python. It explains why string methods always return new values, why you can safely share integer constants between parts of a program, and why passing a list to a function can have side effects while passing an integer cannot. Once the mental model clicks, a whole class of confusing Python behaviors resolves itself.