Advanced String Handling

The Architecture: Stone Tablets (Immutability)

Python strings are Immutable. Once you create a string object, it cannot be changed.

Think of a Python string as a text carved into a Stone Tablet. You cannot change a letter on the tablet. If you want to fix a typo, you must carve a completely new tablet with the correction and throw the old one away (or let the Garbage Collector crush it).

s = "Hello World"

# ❌ Types like Lists are mutable (Whiteboard)
# list[0] = "J"  # Works!

# ❌ Strings are Stone Tablets
# s[0] = "J"     # TypeError: 'str' object does not support item assignment

# ✅ The "New Tablet" Way
# Create a NEW string and move the variable label to it
s = "J" + s[1:] 
print(s)  # "Jello World"

Memory Internals: String Interning

If strings are immutable, does Python create a new object every time you type "hello"? Not always. Python uses a technique called Interning (caching) for small, common strings.

# Python automatically interns simple strings
a = "hello"
b = "hello"
print(a is b)  # True (They point to the EXACT same object in memory)

# But it doesn't intern everything...
s1 = "hello world" * 1000
s2 = "hello world" * 1000
print(s1 == s2) # True (Same value)
print(s1 is s2) # False (Different objects)

# You can FORCE interning for optimization (Advanced)
import sys
s3 = sys.intern("hello world" * 1000)
s4 = sys.intern("hello world" * 1000)
print(s3 is s4) # True (Memory saved!)

Slicing: Surgical Extraction

Slicing is one of Python's most powerful features. The syntax [start:end:step] allows you to extract or reverse substrings in O(k) time (where k is slice length).

text = "Python Programming"

# 1. Range [Start (inclusive) : End (exclusive)]
print(text[0:6])   # "Python"
print(text[:6])    # "Python" (Implicit start 0)
print(text[7:])    # "Programming" (Implicit end)

# 2. Negative Slicing (From the end)
print(text[-1])    # "g" (Last char)
print(text[-4:])   # "ming" (Last 4 chars)

# 3. The Step Argument
print(text[::2])   # "Pto rgamn" (Every 2nd char)
print(text[::-1])  # "gnimmargorP nohtyP" (REVERSE string!)

Performance: The Concatenation Trap

This is a classic interview question. Why should you avoid + in a loop?

Remember the "Stone Tablet". Every time you do s = s + "x", Python has to create a new tablet, copy all the old characters, adds the new one, and destroy the old tablet.

If the string is length N, copying it takes O(N). Doing this N times in a loop leads to O(N²) complexity. Uses immense CPU and RAM.

words = ["Python", "is", "fast", "if", "used", "correctly"]

# ❌ The Rookie Way (Quadratic Time O(N²))
# Creates intermediate strings: "Pythonis", "Pythonisfast"...
s = ""
for w in words:
    s += w + " "  

# ✅ The Pro Way (Linear Time O(N))
# Calculates total size once, allocates memory, fills it.
s = " ".join(words)
print(s)

Case Study: Input Sanitization

Data from users is always messy. A "Gold Standard" engineer knows how to clean it efficiently.

Standard Cleaning Pipeline

raw_input = "   User_Name_123   "

# 1. Strip Whitespace
clean = raw_input.strip()  # "User_Name_123"

# 2. Case Normalization
# 'casefold()' is better than 'lower()' - it handles German 'ß' -> 'ss'
normalized = clean.casefold()

# 3. Checking content
if normalized.isalnum():
    print("Valid alphanumeric")
    
# 4. Replacement
print(clean.replace("_", " ")) # "User Name 123"