Strings

Start with the smallest useful string

A string literal is text written directly in your program. Python accepts single or double quotes. Pick the style that makes the text easiest to read.

customer = "Maya"
status = 'ready'

print(customer)
print(status)

Maya
ready

The quotes mark where the string begins and ends; they are not normally part of the value itself. A value such as "1975" is still a string because it is quoted, even though its characters look like a number.

Choose quotes that make the text readable

You can put a single quote inside a double-quoted string, or a double quote inside a single-quoted string. When the same quote character must appear inside the string, escape it with a backslash.

message = "Maya's order is ready."
quoted = 'The status is "ready".'
escaped = 'It\'s ready.'

print(message)
print(quoted)
print(escaped)

Maya's order is ready.
The status is "ready".
It's ready.

Escape sequences can also represent special characters. For example, \n creates a newline and \t represents a tab.

receipt = "Item: Notebook\nQty: 2"
print(receipt)

Item: Notebook
Qty: 2

Build messages without losing the meaning

You can combine strings with +, but repeated concatenation quickly becomes hard to read when values are mixed into a sentence. For user-facing messages, an f-string usually makes the relationship between the sentence and its values clearer.

name = "Maya"
items = 3

message = f"Hello, {name}. You have {items} items."
print(message)

Hello, Maya. You have 3 items.

The expressions inside the braces are evaluated and converted for display. Keep f-string expressions small enough that the sentence remains easy to scan. If a calculation is complicated, compute it first, give it a meaningful name, then format the result.

subtotal = price * quantity
print(f"Subtotal: ${subtotal:.2f}")

print(f"Subtotal: ${price * quantity:.2f}")

Read parts of a string with indexes and slices

Strings are sequences. Each character has a position called an index. Python indexes start at zero, so the first character is position 0. Negative indexes count from the end.

code = "SV-2048"

print(code[0])
print(code[-1])
print(code[:2])
print(code[3:])

S
8
SV
2048

A slice uses a start position and an end position, and the end position is excluded. That rule is useful because text[:n] contains at most the first n characters.

Strings are immutable: operations return new strings

Immutable means the string object cannot have one of its characters replaced in place. This fails:

name = "maya"
name[0] = "M"

TypeError: 'str' object does not support item assignment

Create a new string instead. Most string methods follow the same pattern: they return a new value and leave the original string unchanged.

name = "maya"
formatted = name.title()

print(name)
print(formatted)

maya
Maya

This behavior matters when you clean input. Calling email.strip() without storing or using the returned value does not rewrite email.

Learn a small method toolkit first

Python strings have many methods, but beginners can solve a surprising number of tasks with a small set. Learn them by the problem they solve rather than by alphabetical order.

raw_tags = " cloud,python, beginner "
tags = [tag.strip() for tag in raw_tags.split(",")]
summary = " | ".join(tags)
print(summary)

cloud | python | beginner

You do not need to memorize the whole method catalog. Start with the transformation you need, inspect the returned value, and add methods only when a real task requires them.

Normalize text deliberately before comparing it

String comparisons are exact unless you transform the values first. That means "READY" == "ready" is False. If the business rule says case should not matter, make that rule explicit.

entered = "  READY "
normalized = entered.strip().casefold()

if normalized == "ready":
    print("Continue")

Continue

Do not automatically lowercase text just because you can. Usernames, identifiers, product codes, file paths, and external systems can have their own case rules. Normalize only when the domain says values should be compared that way.

Five predictable beginner mistakes

Build a small shipping label step by step

A checkout form collects a customer name and a city with accidental surrounding spaces. We want a readable label and a normalized city for comparison.

raw_name = "  maya chen "
raw_city = " Seattle "
order_id = 2048

name = raw_name.strip().title()
city = raw_city.strip()
city_key = city.casefold()
label = f"Order #{order_id} — {name} — {city}"

print(label)
print(city_key)

Order #2048 — Maya Chen — Seattle
seattle

Each transformation has one reason: strip() removes accidental outer whitespace, title() prepares a display name for this example, casefold() creates a separate comparison key, and the f-string builds the final label. Keeping display text and comparison text as separate variables makes the intent easier to inspect.

Practice before moving on

1. Given raw = " python ", create a cleaned value without changing the original variable. Print both values.
2. Predict the result of "SubjectVision"[0:7] and "SubjectVision"[-6:], then run the code.
3. Create a product message using an f-string with a product name, quantity, and price formatted to two decimal places.
4. Take "red, green,blue", split it into pieces, remove surrounding whitespace from each piece, and join the cleaned values with " | ".
5. Write a small input-normalization example where display text preserves the user's capitalization but a separate comparison key uses casefold().

Quick recap

• Python text values use the immutable str type.
• Quotes and escape sequences control how string literals are written.
• Indexes and slices read parts of a string without mutating it.
• String methods return new strings; store the result when you need it later.
• F-strings make readable messages when expressions stay small and clear.

Next chapter: Booleans and Comparisons — where values become yes/no decisions for control flow.

Official references used in this chapter

• Python 3.14 tutorial — Text
• Python 3.14 built-in type — str
• Python 3.14 tutorial — Input and Output