String Immutability and Memory Reallocation

Upon Completion of This Topic

You will understand why Python strings are immutable, how string operations work in memory, and how to avoid performance pitfalls when processing large strings.

Strings Cannot Be Modified

python

name = "Hello"
name[0] = "h"
# TypeError: 'str' object does not support item assignment

Strings in Python are immutable objects. Once created, their content cannot be changed. Any operation that appears to "modify" a string actually creates a new string.

python

name = "Hello"
print(id(name))  # 4385123456

name = name.lower()
print(id(name))  # 4385123520 ← A different object!

id() returns the memory address of an object. After lower(), the id has changed, meaning that the original string was not modified; instead, a new string was created.

Mutable vs. Immutable

Type	Mutable	Example
`str`	Immutable	`"hello"`
`tuple`	Immutable	`(1, 2, 3)`
`int`	Immutable	`42`
`float`	Immutable	`3.14`
`list`	Mutable	`[1, 2, 3]`
`dict`	Mutable	`{"a": 1}`
`set`	Mutable	`{1, 2, 3}`

python

# List: Mutable — contents can be modified directly
items = [1, 2, 3]
items[0] = 99
print(items)  # [99, 2, 3] — same object, contents changed

# String: Immutable — cannot be modified, a new object is created
text = "hello"
new_text = text.replace("h", "H")
print(text)      # "hello" — original remains unchanged
print(new_text)  # "Hello" — a new object

Why Design for Immutability?

1. Hashable — Can Be Used as Dictionary Keys

python

# Strings can be used as dictionary keys (because they are immutable)
scores = {"alice": 90, "bob": 85}

# Lists cannot be used as dictionary keys (because they are mutable)
# scores = {[1, 2]: "value"}  # TypeError: unhashable type: 'list'

Dictionaries use the hash value of keys to find data. If a key changes, its hash value also changes, making it impossible to find the data. Only immutable objects can be hashed.

2. Safety — Safe to Share

python

def greet(name):
    greeting = "Hello, " + name
    return greeting

original = "World"
result = greet(original)
print(original)  # "World" — the function cannot modify original

When you pass a string to a function, you don't have to worry about the original being changed within the function. Lists, on the other hand, can be modified within a function using .append().

3. Thread Safety

Multiple threads can simultaneously read the same string without any issues because no one can modify it, eliminating the need for locks.

String Interning

Python reuses frequently used strings. This is called interning.

python

a = "hello"
b = "hello"
print(a is b)      # True — shares the same object!
print(id(a) == id(b))  # True

c = "hello world!"
d = "hello world!"
print(c is d)      # False or True — depends on the implementation

Short and simple strings (like identifiers) are interned. Even if the same string appears multiple times, it only exists once in memory. This is possible because it's immutable — it can be shared without anyone being able to modify it.

python

# is vs ==
a = "hello"
b = "hello"
print(a == b)  # True — are the values the same?
print(a is b)  # True — is it the same object? (because of interning)

# Always use == to compare strings. is is unpredictable

Performance Pitfall — String Concatenation

python

# Bad: String concatenation in a loop — O(n²)
result = ""
for i in range(10000):
    result += str(i) + ","  # Creates a new string each time!

In each iteration, a new string is created, and the previous content is copied. With 10,000 iterations, approximately 50 million string copies occur (1 + 2 + 3 + ... + 10000).

python

# Good: Use join — O(n)
result = ",".join(str(i) for i in range(10000))

join() calculates the final size in advance and allocates memory only once. The number of copies is reduced to O(n).

Performance Comparison

python

import time

# Method 1: += (slow)
start = time.time()
result = ""
for i in range(100000):
    result += str(i)
print(f"+=: {time.time() - start:.3f}s")

# Method 2: join (fast)
start = time.time()
result = "".join(str(i) for i in range(100000))
print(f"join: {time.time() - start:.3f}s")

# Method 3: io.StringIO (large text)
import io
start = time.time()
buf = io.StringIO()
for i in range(100000):
    buf.write(str(i))
result = buf.getvalue()
print(f"StringIO: {time.time() - start:.3f}s")

# Example result:
# +=: 0.852s
# join: 0.031s (27 times faster)
# StringIO: 0.029s

Practical Patterns

Ways to "Modify" Strings

python

text = "Hello, World!"

# Case conversion
text.upper()      # "HELLO, WORLD!"
text.lower()      # "hello, world!"
text.title()      # "Hello, World!"

# Replacement
text.replace("World", "Python")  # "Hello, Python!"

# Character-by-character modification (using a list)
chars = list(text)   # ['H', 'e', 'l', 'l', 'o', ...]
chars[0] = 'h'
result = "".join(chars)  # "hello, World!"

All of these methods return a new string. The original remains unchanged.

f-string Combination

python

name = "Hoon"
age = 30
greeting = f"Hello, {name}! You are {age} years old."

f-strings internally create the final string at once. This is more efficient and readable than concatenating multiple strings with +.

Comparison with Other Languages

java

// Java — String is immutable, StringBuilder is mutable
String s = "Hello";
s = s + " World";  // Creates a new String object

StringBuilder sb = new StringBuilder("Hello");
sb.append(" World");  // Modifies the same object (mutable)
String result = sb.toString();

javascript

// JavaScript — Strings are immutable (same as Python)
let s = "Hello";
s[0] = "h";      // Doesn't cause an error but is ignored
console.log(s);  // "Hello" (not changed)

// C — char array is mutable
char s[] = "Hello";
s[0] = 'h';      // OK — changes to "hello"

In most modern languages (Python, Java, JavaScript, Go, C#), strings are immutable. This is a common design decision for safety and optimization. Java's StringBuilder, Go's strings.Builder, and Python's join() or io.StringIO serve the same purpose — a mutable buffer that assembles the final immutable string.

Key Takeaways

Concept	Summary
Immutability	Content cannot be changed after creation. All "modifications" create new objects.
`id()`	Checks the memory address of an object.
Interning	Identical strings are reused in memory (possible because they are immutable).
`join()`	The correct way to concatenate strings. Avoid using `+=` in loops.
`is` vs `==`	`is` checks for object identity, `==` checks for value equality. Use `==` for strings.

String immutability is a design decision in Python. It allows strings to be used as dictionary keys, ensures safe passing between functions, and enables memory optimization through interning. Remember this in practice: don't build strings with += in loops; use join() instead.

BioPlayground

String Immutability and Memory Reallocation

String Immutability and Memory Reallocation

Upon Completion of This Topic

Strings Cannot Be Modified

Mutable vs. Immutable

Why Design for Immutability?

1. Hashable — Can Be Used as Dictionary Keys

2. Safety — Safe to Share

3. Thread Safety

String Interning

Performance Pitfall — String Concatenation

Performance Comparison

Practical Patterns

Ways to "Modify" Strings

f-string Combination

Comparison with Other Languages

Key Takeaways

💬 Questions & Comments