🧠 Python DeepCuts — 💡 How Python Handles Strings Internally

Strings are everywhere in Python — but internally, they are highly optimised objects.

Python applies several techniques behind the scenes:

• Unicode handling
• interning
• immutability optimisations
• memory reuse

This DeepCut explores how Python manages strings efficiently.

---

🧩 Strings Are Immutable

Strings cannot be modified in-place.

text = "python"

new_text = "P" + text[1:]

The original string remains unchanged.

Python creates a completely new object instead.

This immutability:

• improves safety
• enables caching & interning
• allows strings to be hashable

---

🧠 Python Stores Strings as Unicode

All Python strings are Unicode.

english = "hello"
emoji = "🚀"

Internally, Python chooses compact storage depending on the characters used.

This means:

• ASCII strings use less memory
• wider Unicode characters may require more space

Python optimises representation automatically.

---

🔄 String Interning

Python reuses many commonly used strings automatically.

a = "python"
b = "python"

a is b

Often returns:

True

This is called string interning:

• identical strings share memory
• avoids duplicate allocations
• speeds up comparisons

Common for:

• identifiers
• literals
• small static strings

---

🧬 Dynamically Built Strings Behave Differently

Runtime-created strings are not always interned.

a = "".join(["py", "thon"])
b = "python"

a == b
a is b

The values match, but the objects may differ.

This is why:

• == checks value
• is checks identity

---

🔍 Manual Interning with sys.intern

You can force interning manually.

import sys

a = sys.intern("python")
b = sys.intern("python")

Useful in:

• parsers
• compilers
• token-heavy systems

Especially when the same strings repeat frequently.

---

⚠️ String Concatenation Costs

Repeated concatenation creates many temporary objects.

text = ""

for i in range(5):
    text += str(i)

Each += creates:

• a new string
• a new allocation

For large workloads, prefer:

"".join(parts)

This is far more memory-efficient.

---

🧠 Identity vs Equality

Because of interning, this can be misleading:

a is b

Two strings may:

• have equal values
• but be different objects

Always use:

==

for value comparison.

---

✅ Key Points

• Python strings are immutable Unicode objects
• Interning allows memory reuse for repeated strings
• is checks identity, not value
• Runtime-generated strings may not be interned
• Repeated concatenation creates many temporary objects

Strings are one of Python’s most optimized and heavily used core types.

---

import sys

# Immutability
text = "python"
new_text = "P" + text[1:]

print(text)
print(new_text)

# Unicode memory
english = "hello"
emoji = "🚀"

print(sys.getsizeof(english))
print(sys.getsizeof(emoji))

# Interning
a = "python"
b = "python"

print(a is b)

# Dynamic strings
a = "".join(["py", "thon"])
b = "python"

print(a == b)
print(a is b)

# Manual interning
a = sys.intern("python")
b = sys.intern("python")

print(a is b)

# Concatenation
text = ""

for i in range(5):
    text += str(i)

print(text)

# Equality vs identity
a = "hello"
b = "".join(["he", "llo"])

print(a == b)
print(a is b)