The TypeError str item assignment error means you tried to change a single character inside a string. It’s an easy mistake to make, but it fails because strings are Immutable in Python.

# WRONG — strings don't support index assignment
message = "Hello"
message[0] = "J"          # TypeError: 'str' object does not support item assignment

# FIX 1 — slicing + concatenation: replace a character at a specific position
message = "Hello"
new_message = "J" + message[1:]   # 'J' + 'ello'
print(new_message)                # Output: Jello

# FIX 2 — .replace(): swap every occurrence of a character or substring
new_message = message.replace("H", "J")
print(new_message)                # Output: Jello

# FIX 3 — list conversion: when you need multiple character-level edits
chars = list("Hello")             # ['H', 'e', 'l', 'l', 'o']
chars[0] = "J"                    # lists support item assignment
new_message = "".join(chars)
print(new_message)                # Output: Jello

The Cause

You can access characters by index, but you can’t assign a new character to an index.

Problem Code:

message = "Hello"
message[0] = "J" # Try to change 'H' to 'J'
# CRASH! TypeError: 'str' object does not support item assignment

The Fix: Create a New String

You cannot change the original string. You must build a new string that includes your change.

Fix 1: Using Slicing + Concatenation

message = "Hello"
new_message = "J" + message[1:] # 'J' + 'ello'

print(new_message) # Output: Jello

Fix 2: Using .replace()

If you want to replace all instances of a character, .replace() is easier.

message = "Hello"
new_message = message.replace("H", "J")

print(new_message) # Output: Jello

Just remember: message.replace() doesn’t change message; it returns a new string with the replacement made.

TypeError: ‘str’ object does not support item assignment — String Immutability and Three Fix Patterns

TypeError: ‘str’ object does not support item assignment enforces one rule: Python strings never change after creation. Every operation that looks like it modifies a string actually builds a new one and leaves the original untouched.

Three fix patterns cover every real-world scenario.

Slicing + concatenation handles single-position replacement. new_str = “J” + original[1:] replaces the first character. new_str = original[:i] + “X” + original[i+1:] replaces any character at index i. Use this when the position matters more than the character value.

.replace() handles value-based substitution. original.replace(“H”, “J”) swaps every occurrence of “H” with “J” in one call. It returns a new string — assign the result or you lose it. Use this when you know the character or substring you want to swap, not the position.

list() conversion handles multiple targeted edits. Convert the string to a list of characters with list(my_string), apply as many index assignments as you need, then rejoin with “”.join(chars). This is the only pattern that gives you true index-level write access — use it when you need to change several specific positions in one pass.

The pattern to know for performance: if you build a string character by character inside a loop, use a list to accumulate the characters and join once at the end. Concatenating strings in a loop with + creates a new string on every iteration — O(n²) on large inputs. The list + join pattern runs in O(n).

SLOW — new string object on every iteration

result = “”
for char in data:
result += transform(char)

FAST — one join at the end

chars = [transform(char) for char in data]
result = “”.join(chars)