Why Are Strings Immutable in Python?

Python strings are immutable. Once a string object exists, you cannot change the characters inside it, and any attempt to do so raises a TypeError. Instead, you build a new string that holds the changed text and use that new string.

text = 'hello'

try:
    text[0] = 'H'
except TypeError as error:
    print('TypeError:', error)

upper = text.upper()
print(upper, text)

print(text.replace('l', 'L'))
print(text + ' world')

The error message tells you that the string object does not support item assignment. Every other line in the script works because each string method returns a brand new string instead of changing the original one. That is why the last print shows both values next to each other. The uppercase word is the new string, and the original word is still exactly as it was.

This is also the reason that you never see text[0] = used on a string in working code, and it is the reason that code which builds a long string inside a loop must collect the pieces in a list and join them at the end, instead of adding to the string again and again.

There is one internal detail worth knowing about. CPython keeps a small cache of one-character strings, so there are some implementation tricks around single characters. None of that is language behaviour that you should rely on in your own code.

Strings are hashable and immutable, and those two facts are exactly what a dictionary key needs. The hash of a key must not change while the key is inside the dictionary, otherwise the lookup would start failing.

key = 'session-id'
cache = {key: {'user': 'ada'}}
print(cache['session-id'])

# Two identical literals are interned, so they share one object.
a = 'hello'
b = 'hello'
print(a is b)

# A string built at runtime is a separate object.
c = ''.join(['hel', 'lo'])
print(c == a)
print(c is a)

The dictionary lookup works with a literal that you wrote out again, because the lookup compares values and not identities. Interning then shows its hand. The two copies of the word hello are the same object, so a is b is True. The string that you built by joining two pieces has the same content but it is a separate object, so c is a is False.

Interning is not only a curiosity. It means that long or repeated strings can share the same memory, which matters when you build a large dictionary that is keyed by strings. It also means that the is operator is not a reliable way to compare strings. You should use == for that, because two strings with the same content can easily be two different objects.

Immutability is also what makes strings safe to share. Because no piece of code can change the contents of a string, you can cache it in a module constant, pass it between threads, and use it as a key in a set without any locking at all. Strings are the one kind of object in Python that is genuinely safe to share everywhere, and that comes straight from this design choice.

Strings are immutable because Python treats them as values. The same design gives numbers, tuples, and frozensets the same property, and it is a deliberate choice rather than an accident of how the interpreter happens to work.

The benefit falls into three parts.

First, hashing and dictionary keys. A dictionary works out the hash of every key and stores it, so that it can compare keys quickly later. If the content of a key could change, then that stored hash would become wrong and the lookup would quietly fail. Immutability is what makes string keys safe, and it is also why lists cannot be dictionary keys while tuples can.

Second, safe sharing. An immutable string can be handed to another function, cached in a module constant, stored in a set, or passed to another thread, and nobody is able to change it underneath you. You do not need to copy it just to be safe, and you do not need a lock to protect it. That is why string interning is a memory saving and not a correctness risk.

Third, predictable behaviour with caching and identity checks. Because a string cannot change, the interpreter can reuse the same object for repeated literals, and it can intern short strings without any risk of surprising you later.

The practical cost is that every string method that looks like it modifies a string actually returns a new one. That is why text.replace returns a value that you must assign, why text.strip() does not remove the whitespace in place, and why a long string that you build inside a loop should use a list plus join. The cost is small, and the alternative of mutable strings would break dictionaries, hashing, and thread safety.