Lesson 3: Strings — Slicing, Methods & f-Strings

What is a String?

A string is a sequence of characters — letters, digits, spaces, symbols. You create one with single quotes, double quotes, or triple quotes:

single = 'hello'
double = "hello"
multi = """multi-line
string"""

Strings are immutable: once created, you cannot change a string in place. Any operation that "changes" a string actually creates a brand-new one.

Why Strings Are the Most-Used Type

Every piece of text a program touches is a string: names, emails, messages, JSON payloads, file paths, API responses, log lines. Data cleaning, web scraping, and natural-language processing are almost entirely string gymnastics. Master strings and you master the majority of everyday programming.

What You'll Learn in This Lesson

• Index and slice strings with positive and negative indexes
• Use the most important string methods
• Master f-strings — the modern, professional way to format text
• Understand why strings are immutable
• Escape characters and work with multi-line text

Indexing — Grabbing One Character

Every character in a string has a position (an index), counting from 0:

Index:   0    1    2    3    4
Value:   A    m    o    l    s
        -5   -4   -3   -2   -1    <- negative indexes

• name[0] → first character
• name[4] → fifth character
• name[-1] → last character (negative indexes count from the end)
• name[-2] → second-to-last character

Trying to access an index that does not exist raises IndexError: string index out of range.

Mental model: index numbers sit between characters for slicing, but on characters for indexing. Index 0 is the first character, and -1 is the last — they meet in the middle.

Slicing — Grabbing a Range

A slice extracts a range of characters using the syntax start:end — and the end is exclusive (it stops just before end):

The full slice syntax is start:stop:step. Leave any part blank to use the default (start = 0, stop = end, step = 1).

Fence-post rule: a slice s[1:4] includes posts 1, 2, and 3 but stops before post 4.

Classic slice recipes:

• s[::-1] — reverse any string (the most popular slice in existence).
• s[:len(s)//2] — first half; s[len(s)//2:] — second half.
• s[-3:] — last three characters (e.g., grabbing a file extension: "report.pdf"[-3:] → "pdf").

Escape Characters — Special Text

Some characters need a backslash to be written inside a string:

For raw text (like Windows paths or regex), prefix with r: r"C:\Users\Amol" keeps every backslash literally.

String Methods — Built-in Superpowers

Strings ship with dozens of methods. The most important ones:

Because strings are immutable, every method returns a new string — the original is untouched. You can chain methods:

email = "  Amol@Example.COM  "
clean = email.strip().lower()
# "amol@example.com"

.split() and .join() are the two most-used methods in data work:

sentence = "Python,is,awesome"
parts = sentence.split(",")        # ['Python', 'is', 'awesome']
glued = " ".join(parts)            # 'Python is awesome'

Mental model: .split() chops a string into a list at a delimiter; .join() is the exact reverse — it welds a list back together with a glue string.

f-Strings — The Modern Way to Format

f-strings (formatted strings) embed expressions directly inside text using curly braces:

course = "Python"
lessons = 25
print(f"Welcome to {course} — {lessons} lessons!")
# Welcome to Python — 25 lessons!

You can even run expressions and format numbers inside the braces:

price = 9.567
print(f"Price: {price:.2f}")   # Price: 9.57
print(f"Sum: {2 + 3}")         # Sum: 5

Format specifiers (after the colon) give precise control:

These turn ugly numeric output into polished reports — essential for the data tables you will build later in the course.

f-strings vs the Old Ways

Professional Python code in 2026 uses f-strings almost exclusively.

Common Mistakes to Avoid

• Mistake: name[5] when the string has only 5 characters — Fix: remember indexes start at 0; the last valid index is len(name) - 1.
• Mistake: Expecting "Hello".upper() to change "Hello" — Fix: methods return new strings; assign the result: text = text.upper().
• Mistake: "count: " + 5 — Fix: use an f-string: f"count: {5}".
• Mistake: Slicing with the end index included — Fix: s[0:4] gives characters 0–3, not 0–4.
• Mistake: Forgetting \n vs \n — Fix: use r"..." raw strings for paths and regex.
• Mistake: Using .replace() and expecting the original to change — Fix: assign the result back.

Professional Tips & Tricks

• f-strings beat + concatenation: faster, safer, and readable.
• Chain methods: email.strip().lower().replace(' ', '_').
• Use .split() to turn messy text into clean lists — the basis of data cleaning.
• Use .join() to build strings from lists — it is faster and cleaner than repeated +.
• Check .isdigit() before casting user input to avoid ValueError.

Key Takeaways

• Strings are immutable sequences of characters with 0-based indexes.
• Negative indexes count from the end; [::-1] reverses a string.
• String methods return new strings — assign the result.
• f-strings with {...} are the professional formatting standard.
• Slicing works identically on lists and tuples (Lesson 8).
• .split() and .join() are the power pair for text processing.

Next up: Operators & expressions — how Python does math and logic.