Chapter 5: Strings in Depth

Strings are among the most important and versatile objects in Python. They are the primary way the language represents text, and they form the bridge between human meaning and program logic. Whether you are displaying messages, processing data, or formatting output, you will work with strings constantly. Understanding how they behave (especially their immutability, slicing semantics, and formatting tools) is essential for writing clear, reliable code.

At first glance, a string seems simple: a sequence of characters enclosed in quotes. But beneath that simplicity lies a carefully designed structure that supports Unicode, efficient storage, and a wide range of operations. Strings can be indexed, sliced, concatenated, compared, and iterated like any other sequence. They also provide a rich set of methods for searching, transforming, and analysing text.

In this chapter we look at how strings are written, quoted, and represented in code, including multi-line and raw strings, and how to access and manipulate substrings safely (and why strings cannot be changed in place).We also look at the standard toolkit for transforming and examining text using built-in methods and loops, and how to interpolate values and control layout using modern and legacy formatting styles, as well as how Python stores and processes text from all writing systems to work efficiently with bytes and encodings.

Literals and escape sequences

Every string in Python begins as a literal, which is a piece of text written directly in your source code. String literals can be enclosed in single quotes ('...'), double quotes ("..."), or triple quotes ('''...''' or """..."""). The different forms exist for convenience and readability, not for meaning. All create the same kind of str object.

single  = 'Hello'
double  = "World"
triple  = '''This can span
multiple lines.'''

Triple-quoted strings are especially useful for documentation and long text blocks, since they preserve line breaks and indentation exactly as written. They are also the standard way to create multi-line docstrings.

Strings can include almost any printable character directly, but certain characters, such as quotes, newlines, or tabs, need special handling. Python uses escape sequences to represent these. An escape sequence begins with a backslash (\) followed by one or more characters that indicate the desired symbol or control code.

text = "Line one\nLine two\tTabbed"
print(text)
# Output:
# Line one
# Line two    Tabbed

Here, \n represents a newline and \t represents a tab. These sequences are interpreted at runtime, not stored literally, so the string’s internal value contains the actual control characters.

Common escape sequences

These escapes make it possible to include any Unicode character in a string, even ones that cannot be typed directly. For instance, "\u03C0" produces the Greek letter π, and "\N{EM DASH}" inserts an em dash.

print("\u03C0 =", 3.14159) # π = 3.14159

Raw strings

Sometimes you want a string to contain backslashes literally, without Python interpreting them as escapes. This is common in regular expressions, Windows file paths, and other patterns that use many backslashes. To prevent escape processing, prefix the literal with r or R to create a raw string:

path = r"C:\Users\Robin\Documents"
print(path) # C:\Users\Robin\Documents

In a raw string, the backslash is treated as an ordinary character. The only exception is that a raw string cannot end with a single backslash, because it would escape the closing quote.

String concatenation and repetition

Adjacent string literals written together are automatically concatenated by the compiler, even without a + operator. This can help split long strings across lines neatly:

message = (
  "Python strings "
  "can join automatically "
  "when written this way."
)
print(message)

Strings can also be concatenated or repeated explicitly using operators:

a = "Py"
b = "thon"
print(a + b) # Python
print(a * 3) # PyPyPy

Concatenation creates a new string, as all strings are immutable. The repetition operator (*) is a simple and efficient way to produce repeated patterns or padding.

Together, literals, escapes, and raw forms give Python’s strings both expressive range and precise control. They allow text to be written naturally in code while preserving full compatibility with every character Python’s Unicode engine can represent.

Indexing, slicing, and immutability

Indexing, slicing, and immutability together define how Python strings behave as ordered, unchanging sequences. You can retrieve and combine parts freely, but the sequence itself remains stable and reliable throughout the life of your program.

Strings in Python are sequences, which means each character occupies a specific position that can be accessed directly. Every string has a defined order starting from index 0 for the first character and increasing by one for each character that follows. Negative indices count backward from the end, with -1 referring to the last character, -2 to the second-last, and so on.

word = "Python"
print(word[0])  # P
print(word[5])  # n
print(word[-1]) # n
print(word[-2]) # o

Indexing retrieves a single character as a one-character string. Attempting to access an index beyond the valid range raises an IndexError, so it is good practice to confirm length with len() when needed.

name = "Rachel"
print(len(name)) # 6

Slicing

Slicing extracts a portion of a string by specifying a range of indices in square brackets. The syntax s[start:end] returns the substring beginning at start and continuing up to but not including end. Either bound may be omitted, in which case it defaults to the beginning or end of the string.

text = "Pythonic"
print(text[2:3]) # tho
print(text[:2])  # Py
print(text[3:])  # nic

Slices can also include a third value, the step, which controls the interval between selected characters. A step of 2 takes every second character, and a negative step reverses the direction.

text = "Acrobat"
print(text[::2])  # Arbt
print(text[::-1]) # taborcA

These operations always return a new string. They never alter the original, because strings are immutable. This means that once a string has been created its contents cannot change.

Immutability

Attempting to assign a new value to an individual character or slice causes an error because strings do not support modification in place. The correct approach is to build a new string instead.

word = "Fable"
# word[0] = "T" # TypeError: 'str' object does not support item assignment
new_word = "T" + word[1:]
print(new_word) # Table

Although this may seem restrictive it actually simplifies reasoning about code. Because a string’s contents never change, you can safely pass it between functions without worrying that it will be altered elsewhere. When a transformation is needed, Python constructs a new string and binds the result to a name, leaving the original untouched.

String methods and iteration

Strings come with a large set of built-in methods for inspecting, searching, and transforming text. Because strings are immutable, each method that appears to modify a string actually returns a new one, leaving the original unchanged. These methods make it easy to clean data, adjust case, find patterns, and perform substitutions without writing additional loops or functions.

String methods and iteration form a complete toolkit for everyday text handling in Python. They allow you to clean, transform, and examine text clearly and efficiently, using constructs that read almost like natural language.

Basic transformations

The most common methods deal with the overall shape of the text—changing case, removing whitespace, or joining and splitting substrings.

name = "  Ada Lovelace  "
print(name.strip())  # remove leading and trailing spaces
print(name.upper())  # ADA LOVELACE
print(name.lower())  # ada lovelace
print(name.title())  # Ada Lovelace

strip() removes whitespace from both ends, while lstrip() and rstrip() remove it from only one side. Case conversion methods (upper(), lower(), title(), capitalize(), swapcase()) all return new strings with the desired transformation.

Searching and replacing

Python provides simple, readable methods for locating and substituting text within a string. These include find(), replace(), startswith(), and endswith().

text = "data-driven design"
print(text.find("data"))             # 0
print(text.replace("data", "user"))  # user-driven design
print(text.startswith("data"))       # True
print(text.endswith("sign"))         # True

find() returns the index of the first occurrence or -1 if not found. replace() produces a new string with all matches replaced. These methods handle the most common search operations without requiring explicit loops.

"drive" in text # True

Splitting and joining

Two of the most powerful and frequently used string methods are split() and join(). split() breaks a string into a list of parts, while join() combines a list of strings into one, using the string it is called on as a separator.

sentence = "one two three"
words = sentence.split()
print(words)  # ['one', 'two', 'three']

joined = "-".join(words)
print(joined) # one-two-three

By default, split() uses any whitespace as a delimiter, but you can specify another separator. The reverse method join() is the preferred way to build strings from lists because it is both efficient and expressive.

Character tests

Several methods return Boolean values based on the content of the string. These methods are useful for validation, filtering, and user input checks.

• isalpha() : Only letters
• isdigit() : Only digits
• isalnum() : Letters or digits
• isspace() : Only whitespace
• isupper() : All uppercase
• islower() : All lowercase

code = "ABC123"
print(code.isalnum()) # True
print(code.isalpha()) # False

These checks are often used in conditions and comprehensions to clean or validate text input.

Iteration over strings

Because strings are sequences, they can be iterated character by character in a for loop or comprehension. Each iteration yields a one-character string.

for ch in "ABC":
  print(ch)

This property lets you use strings naturally with many Python constructs that expect iterable objects, including sum(), max(), min(), sorted(), and generator expressions.

letters = "vector"
print(sorted(letters))  # ['c', 'e', 'o', 'r', 't', 'v']

Iteration also supports slicing and membership tests, which combine to make string processing in Python both concise and intuitive.

f-strings and formatting techniques

Formatting strings is one of the most practical skills in Python. It allows you to combine variables and text into readable messages, structured reports, or dynamic output. Over time, Python has introduced several ways to do this. The modern and most preferred method is the formatted string literal, or f-string, introduced in version 3.6. Older techniques, such as the str.format() method and the percent (%) operator, still exist for compatibility and are sometimes useful in specialised cases.

f-strings

An f-string is a string literal prefixed with f (or F). Inside it, you can place expressions within curly braces, and Python will evaluate them at runtime, inserting the resulting values into the string. The syntax is compact, fast, and easy to read.

name = "Ada"
language = "Python"
print(f"{name} loves {language}.")  
# Ada loves Python.

Anything inside the braces can be a valid Python expression, including calculations or function calls.

x = 7
y = 3
print(f"{x} + {y} = {x + y}")  
# 7 + 3 = 10

You can also apply formatting options directly within the braces using a colon followed by a format specifier. This controls how numbers, dates, and other values appear.

pi = 3.14159265
print(f"{pi:.2f}")   # 3.14
print(f"{pi:10.3f}") # field width 10, 3 decimals

Formatting codes resemble those from the older format() method and give precise control over alignment, width, precision, and fill characters.

amount = 12345.678
print(f"{amount:,.2f}")   # 12,345.68
print(f"{amount:^15.1f}") # centered in 15-character field

str.format() method

Before f-strings, Python’s main approach to formatting was the format() method. It uses braces as placeholders inside the string, which are replaced by positional or keyword arguments. Although slightly more verbose than f-strings, it remains powerful and widely used in libraries and templates.

template = "Hello, {}. Welcome to {}."
print(template.format("Ada", "Python"))
# Hello, Ada. Welcome to Python.

You can reference arguments by position or name, giving flexibility when reusing templates.

print("{1} and {0}".format("bread", "butter")) # butter and bread
print("{name} scored {score}".format(name="Alan", score=95))

Formatting specifiers can also be added after a colon, just like with f-strings.

print("Value: {:.3f}".format(3.14159)) # Value: 3.142

Percent formatting

The oldest style of formatting in Python uses the percent operator (%) much like C’s printf(). It still works and can be useful when working with legacy code or porting examples from older texts.

name = "Ada"
age = 36
print("Name: %s, Age: %d" % (name, age))

Here, %s formats a string, %d an integer, and %f a floating point number. Although concise, this method is less flexible and more error-prone than modern alternatives, as mismatched placeholders and arguments can cause runtime errors.

Choosing a formatting style

All three systems ultimately serve the same goal: combining text with dynamic values. f-strings are usually best for inline expressions and readability. The format() method works well when templates must be reused or passed as data. Percent formatting remains available for older codebases. The important thing is to be consistent within a project so readers can understand at a glance how values are being inserted.

Encoding and Unicode handling

Every string in modern Python represents a sequence of Unicode characters. This design allows Python to handle text from virtually any language or symbol set without loss of information. Unicode is a universal standard that assigns every character (letters, digits, punctuation, emojis, and more) a unique number called a code point. Python’s str type stores these code points internally, independent of how they are represented in memory or on disk.

text = "café"
print(text)
print(len(text))  # 4
print(ord("é"))   # 233 (Unicode code point)

Here, ord() returns the numeric code point for a character, while chr() does the reverse: turning a code point number back into a character.

print(chr(0x03C0))  # π

This separation between logical characters and their binary representation makes Python text handling simple and consistent across platforms. However, when text is read from or written to files, networks, or external systems, it must be converted to or from a specific encoding. Encoding defines how Unicode code points are stored as bytes.

Common encodings

The most widely used encoding today is UTF-8 (Unicode Transformation Format, 8-bit). It can represent every Unicode character using one to four bytes and is backward compatible with ASCII. Most Python environments, editors, and web standards use UTF-8 by default.

message = "Hello π"
data = message.encode("utf-8")  # str → bytes
print(data)                     # b'Hello \xcf\x80'

decoded = data.decode("utf-8")  # bytes → str
print(decoded)                  # Hello π

The encode() method converts a string to a bytes object using the chosen encoding, while decode() reverses the process. These conversions are essential when working with files, network sockets, or APIs that expect binary data.

with open("example.txt", "w", encoding="utf-8") as f:
  f.write("naïve café")

Python’s file I/O automatically encodes and decodes text when an encoding is specified. If you omit it, Python uses the platform default, which can differ between operating systems.

Bytes versus strings

Bytes and strings may look similar but represent different kinds of data. A string (str) is a sequence of Unicode characters. A bytes object (bytes) is a sequence of raw 8-bit values. The two are distinct types and cannot be combined directly.

# invalid: b"data" + "text" → TypeError

To combine or compare them, you must convert one to the other using encode() or decode(). This explicitness avoids ambiguity about how text should be represented in binary form.

b = b"cafe"
print(b.decode("utf-8"))  # cafe

Unicode escapes and special characters

Unicode characters can also be represented directly in string literals using escape sequences such as \u and \U. These sequences make it possible to include symbols that are not easily typed or visible.

greek = "\u03B1\u03B2\u03B3"  # αβγ
emoji = "\U0001F600"          # 😀
print(greek, emoji)

Python interprets these escapes at parse time, converting them into their proper Unicode characters. This ensures that strings behave consistently regardless of how they are entered.

Error handling during encoding

When encoding or decoding fails (usually because a byte sequence is invalid or a character cannot be represented) you can control the behaviour with the errors parameter. Common strategies include 'ignore', 'replace', and 'backslashreplace'.

text = "Spicy jalapeño"
print(text.encode("ascii", errors="ignore"))  # b'Spicy jalapeno'
print(text.encode("ascii", errors="replace")) # b'Spicy jalape?o'
print(text.encode("ascii", errors="backslashreplace"))
# b'Spicy jalape\\xf1o'

Inspecting encodings

The sys module reveals the default system encoding used by Python. Although it is usually UTF-8 in modern versions, it can vary on older systems or specialised environments.

import sys
print(sys.getdefaultencoding())  # typically 'utf-8'

Understanding encodings ensures that text input and output behave consistently across files, terminals, and network interfaces. With Unicode at its core, Python lets you handle any form of written language or symbol safely and predictably.

Encoding and Unicode handling complete Python’s text model. Together with literals, slicing, and formatting, they allow programs to represent and manipulate human language accurately, from simple ASCII to the entire range of global writing systems and symbols.