How Strings Work Differently Across Languages in DSA Python - Step-by-Step

Mental Model

Strings are sequences of characters, but how they are stored and changed depends on the language.

Analogy: Think of strings like a row of lockers: some languages lock each locker so you can't change what's inside (immutable), while others let you open and change lockers anytime (mutable).

Immutable string (Python):
[H] -> [e] -> [l] -> [l] -> [o] -> null

Mutable string (like list in Python):
[H] -> [e] -> [l] -> [l] -> [o] -> null
↑ (can change any locker)

Dry Run Walkthrough

Input: string: 'hello', try to change character at index 1 to 'a'

Goal: Show how changing a character works differently in immutable vs mutable strings

Step 1: Attempt to change character at index 1 in immutable string

[h] -> [e] -> [l] -> [l] -> [o] -> null

Why: Immutable strings do not allow changing characters directly

Step 2: Create a new string with the change applied

[h] -> [a] -> [l] -> [l] -> [o] -> null

Why: To change a character, a new string must be made with the desired change

Step 3: Change character at index 1 in mutable string (like list)

[h] -> [a] -> [l] -> [l] -> [o] -> null

Why: Mutable strings allow direct change without creating a new copy

Result:

Immutable string remains unchanged; new string created: h -> a -> l -> l -> o -> null
Mutable string changed directly: h -> a -> l -> l -> o -> null

Annotated Code

DSA Python

class MutableString:
    def __init__(self, initial):
        self.chars = list(initial)  # store characters in a list for mutability

    def set_char(self, index, char):
        if 0 <= index < len(self.chars):
            self.chars[index] = char  # directly change character

    def __str__(self):
        return ''.join(self.chars)

def immutable_string_change(s, index, char):
    # Cannot change string directly, create new string
    if 0 <= index < len(s):
        return s[:index] + char + s[index+1:]
    return s

# Driver code
original = 'hello'

# Immutable string attempt
try:
    # This will raise an error in Python
    # original[1] = 'a'
    pass
except TypeError:
    print('Cannot change immutable string directly')

new_string = immutable_string_change(original, 1, 'a')
print('Original immutable:', original)
print('New immutable:', new_string)

# Mutable string example
mutable = MutableString('hello')
mutable.set_char(1, 'a')
print('Mutable changed:', mutable)

self.chars = list(initial) # store characters in a list for mutability

store string as list to allow changes

self.chars[index] = char # directly change character

directly update character at index

return s[:index] + char + s[index+1:]

create new string with changed character

Output

Original immutable: hello

New immutable: hallo

Mutable changed: hallo

Complexity Analysis

Time: O(n) because creating a new string copies all characters except the changed one

Space: O(n) because a new string copy is made for immutable change, mutable uses O(n) once for storage

vs Alternative: Immutable strings require new copies on change, which is slower and uses more memory; mutable strings allow direct changes saving time and space

Edge Cases

Changing character at invalid index

No change occurs, original string or mutable string remains the same

DSA Python

if 0 <= index < len(s):

Empty string

No change possible, returns empty string or empty mutable string

DSA Python

if 0 <= index < len(s):

When to Use This Pattern

When you see string modification in a problem, remember some languages require making new strings while others allow direct changes, affecting performance and approach.

Common Mistakes

Mistake: Trying to change a character directly in an immutable string
Fix: Create a new string with the desired changes instead of modifying in place

Summary

Strings can be immutable or mutable depending on the language.

Use immutable strings when safety and simplicity matter; mutable strings when frequent changes are needed.

The key insight is that immutable strings require creating new copies to change, while mutable strings allow direct modification.