Summary  
This chapter explains that strings are immutable, meaning any modification—such as changing characters, removing substrings, or altering case—always creates a new string using slicing, concatenation, or string methods, and highlights using join to efficiently build strings.  

General domain of usage  
Text processing and normalization (e.g., cleaning and formatting user input)

In Python, strings are **immutable**: once created, the characters they contain cannot be changed in place. Any "modification" you do actually creates a **new string**. This matters for correctness (no accidental in-place edits) and for performance (how you build larger strings).

Watch a short video demonstration on Python string immutability. See how attempts to modify a string in place result in errors, and learn practical ways to create new strings by slicing, concatenation, and using string methods. This video reinforces the key points from the chapter and shows real coding examples in action.

## No In-Place Edits

You can read characters by index, but you cannot assign to them.


s = "hello"

t = "H" + s[1:]   # Creates a new string: "Hello"
print(t)

s[0] = "H"      # TypeError: strings don't support item assignment

Most string methods return a **new** string and leave the original unchanged.

# Cleaning up user input from a registration form
user_name = "  Alice  "

user_name.strip()              # returns "Alice", but the variable still has spaces
print(user_name)               # "  Alice  "

user_name = user_name.strip()  # assign the cleaned value back
print(user_name)               # "Alice" → cleaned and ready to store

Chaining is fine, but remember you're getting a new object each step.

# Normalizing a user's chat message before saving it
user_message = "  hello\n"

clean_message = user_message.strip().upper()   
print(user_message)   # original remains "  hello\n"
print(clean_message)  # "HELLO" → cleaned and ready for processing

## "Modifying" By Creating a New String

Use slicing, `replace`, or concatenation to produce a new value.

s = "data"

s = s.replace("t", "T")       # "daTa"
print(s)

s = s[:1] + "A" + s[2:]       # "dATa"
print(s)

## Efficient Building

Repeated `+` in large loops can be slow (many intermediate strings). A common pattern is to **collect pieces** and join once:


# Combining message parts received from a device
response_parts = ["Status:", " ", "200", "\n", "Success"]
response_message = "".join(response_parts)  # "Status: 200\nSuccess"
print(response_message)

You'll learn more joining/formatting patterns in the next chapter.

Note

Which line attempts to modify a string **in place** and will raise an error?

You need to assemble a long string from many small pieces. What's recommended?

A focused, beginner-friendly course on working with numbers in Python. Learn about integers, floats, arithmetic operations, type conversion, and how to avoid common pitfalls when handling numerical data.

String Immutability

No In-Place Edits

"Modifying" By Creating a New String

Efficient Building

1. Which line attempts to modify a string in place and will raise an error?

2. What will the code output?

3. You need to assemble a long string from many small pieces. What's recommended?