Every useful program works with text. Programs read names, display messages, search for words, clean up data, format reports, parse input, and produce readable output. Text is everywhere: user responses, file contents, error messages, labels, identifiers, addresses, dates written as words, and records pulled from databases. Python's string type is the primary tool for handling all of it.

You have been working with strings since Chapter 3. You have printed them, stored them in variables, concatenated them, and formatted them with f-strings. In this chapter you go deeper. You will learn how strings are structured as sequences of characters, how to read specific characters or slices using indexes, how to apply Python's rich set of string methods, and how to write functions that analyze, clean, and transform text.

By the end of this chapter you should be able to read text character by character, extract substrings, search for patterns, count occurrences, change case, remove whitespace, split text into pieces, join pieces back together, and write a small but complete text analysis program. These skills connect directly to the work ahead: file processing in Chapter 21, CSV data in Chapter 22, and larger applications throughout Part VI.

A string is a sequence of characters. It can hold letters, digits, punctuation, spaces, symbols, and special characters. You write string values using either single quotes or double quotes, and Python treats both the same way.

Strings can hold any printable text. They can be short or very long. An empty string ("") is a valid string with zero characters.

You have probably used strings mainly for output — labeling results, printing messages, building prompts. But strings also carry data. Consider these examples:

• A program reads a user's name and checks whether it starts with a capital letter.
• A program opens a file and searches each line for a particular word.
• A program cleans a list of product codes by stripping extra spaces and converting everything to uppercase.
• A program splits a sentence into individual words and counts how many times each word appears.

All of these tasks require understanding strings not just as values to display, but as structured data to examine and transform.

Every character in a string occupies exactly one position. A single letter, a space, a digit, a hyphen, an exclamation point — each one is a character. The string "cat" has three characters. The string "Hello!" has six: H, e, l, l, o, and !. The space character counts too: "hot dog" has seven characters.

Python gives you tools for working with individual characters, groups of characters, and the whole string at once.

Because a string is a sequence, each character has a numbered index — its position in the string. Python indexes start at zero, not one.

To read one character, use square brackets with the index number.

Python also allows negative indexes, which count backward from the end of the string. The last character is always at index -1, the second-to-last at -2, and so on.

Negative indexes are useful when you want the end of a string but do not know its length ahead of time.

The built-in len() function returns the number of characters in a string.

Since indexes start at zero, the valid positive indexes for a string of length n are 0 through n - 1. Trying to access word[13] in the example above would produce an IndexError.

You can combine len() with a for loop to visit every character in a string.

This pattern is useful when you need the index number alongside the character. If you only need the character itself, you can iterate more directly, as you will see in Section 16.6.

You can extract a portion of a string using a slice. A slice uses square brackets with two index numbers separated by a colon: string[start:stop]. The result is a new string containing the characters from start up to but not including stop.

If you omit the start index, Python begins from the very beginning of the string. If you omit the stop index, Python goes all the way to the end.

Negative indexes work in slices too.

This is commonly used to extract or remove file extensions, check endings, or strip known suffixes.

Slicing never modifies the original string. It produces a new string value. The original remains unchanged. You will learn why in Section 16.4.

Slices can also take a third value: string[start:stop:step]. This controls how many positions to skip between characters.

Strings in Python are immutable. This means once a string is created, you cannot change any of its characters. You can read characters, extract slices, and create new strings based on old ones — but you cannot replace a character in place.

This surprises many beginners. If strings cannot be changed, how do you "modify" one? The answer is: you build a new string.

You used slicing and concatenation to produce a new string value. The original "cat" was never touched. The variable new_word points to a brand new string.

Immutability makes strings safe to pass around in programs. If a function receives a string, it cannot accidentally modify the original. This prevents a common class of programming bugs. It also allows Python to store strings efficiently in memory.

As you work with string methods in the next sections, remember this rule: string methods never change the original string. They always return new string values. If you want to keep the result, you must assign it to a variable.

Python strings come with a large collection of built-in methods — functions that belong to string objects and know how to work on the string they are called on. You call a method using dot notation: string.method().

This section covers the most important methods for everyday text processing.

upper() converts all letters to uppercase. lower() converts all to lowercase. capitalize() makes the first letter uppercase and all others lowercase. title() capitalizes the first letter of each word.

These are especially useful for normalizing input. If you ask users to type a city name, one might type "paris" and another "PARIS". Converting both with .lower() lets you compare them reliably.

strip() removes leading and trailing whitespace — spaces, tabs, and newline characters. lstrip() strips only from the left, rstrip() only from the right. Stripping is essential when reading data from files or user input, where extra spaces are common.

These return True or False and are useful in conditions.

replace(old, new) returns a new string with every occurrence of old replaced by new. Notice that replace() is case-sensitive: "cats" was replaced but "Cats" was not.

You can chain method calls like this, though chaining many steps can reduce readability.

These are useful for validating input.

Python gives you several ways to find out whether a string contains a particular character or substring, where it appears, and how many times.

The simplest check is the in operator, which you have used with lists. It works with strings too.

in returns True if the substring appears anywhere inside the string.

find() returns the index of the first occurrence of a substring. If it is not found, it returns -1.

index() does the same thing, but raises a ValueError if the substring is not found. Use find() when absence is a normal possibility, and index() when you expect the substring to always be present.

count() counts how many times a substring appears.

To examine every character in a string, use a for loop directly:

This is cleaner than looping with range(len(word)) when you do not need the index. Here is a practical example: counting how many vowels a word contains.

Text data in the real world is messy. Users type inconsistently. Files have extra spaces. Systems export data in different formats. Two of the most common cleaning tasks involve case and whitespace.

Consider a program that asks users to type a country name. Different users might type:

All of these mean the same thing, but string comparison is case-sensitive. "france" == "FRANCE" is False. The solution is to normalize before comparing.

By converting the response to lowercase before comparing, the program works correctly regardless of how the user typed it.

Users often type leading or trailing spaces accidentally, especially on mobile devices. Always strip user input before using it.

This one-liner takes the input, immediately strips whitespace, and assigns the cleaned result to name.

Each code was stripped and uppercased. The original strings were not changed; clean_code() returned new strings.

One of the most powerful string tools is split(), which breaks a string into a list of smaller strings. Its partner, join(), reassembles pieces back into a single string.

When called with no arguments, split() splits on any whitespace — spaces, tabs, or newlines — and removes the whitespace from the results.

The result is a list of strings. You can loop over it, index into it, and measure its length.

You can split on any character or substring by passing it as an argument.

join() is the reverse of split(). It takes a list of strings and joins them into one string, placing a separator between each piece.

The syntax is slightly unusual: you call join() on the separator string.

A common workflow is to split text into parts, modify the parts, then join them back together.

This is cleaner and more explicit than trying to modify the string directly.

You have used f-strings for basic formatting since Chapter 4. This section introduces additional formatting tools that make output easier to read, especially when displaying tables or aligned data.

An f-string can include format specifications after a colon inside the curly braces. These control width, alignment, and decimal places.

Setting a minimum width:

The :10 tells Python to use at least 10 characters for the name, padding with spaces on the right.

Aligning text:

< aligns left, > aligns right, ^ centers. These are most useful when building report output.

Controlling decimal places:

.2f means "floating-point number, two decimal places."

For simple padding without f-strings:

These are useful for formatting section headings in text reports.

This is exactly the kind of console output you will produce when generating reports from files and CSV data in later chapters.

With all these tools, you can now write meaningful programs that analyze text — counting words, finding patterns, computing statistics, and summarizing content. This section ties the chapter together with a complete worked example.

Trace each iteration. What is result at the end?

Trace the loop. What is in output at the end? What does join() produce?

Trace each step. What is the final output?

What type of error is this? Why? How would you correctly create "Jello" from "Hello"?

What error does this produce? Why? What is the correct index for the last character?

What is wrong here?

What is wrong with the .join() call? Write the correct version.

The function does not produce the expected result. Explain why. Fix it.

What is the syntax error?