Python String Methods Practice: f-strings, split, join, strip, slicing

For a quick copy-paste reference of every method covered here, see the Python string methods cheat sheet.

The most common string confusion in Python:

"a  b  c".split()      # ['a', 'b', 'c'] — whitespace grouped
"a  b  c".split(" ")   # ['a', '', 'b', '', 'c'] — literal space

When sep is not specified (or is None):

1. Runs of consecutive whitespace are treated as one separator
2. Leading and trailing whitespace is stripped
3. The result never has empty strings at the ends

When sep is specified:

1. Each occurrence of the separator creates a split
2. Consecutive separators create empty strings
3. Leading/trailing separators create empty strings at the ends

"  hello world  ".split()      # ['hello', 'world']
"  hello world  ".split(" ")   # ['', '', 'hello', 'world', '', '']

Rule of thumb:

• Use split() for human-written text with arbitrary whitespace
• Use split(sep) for structured data (CSV, logs) where empty fields matter
• For multiple delimiters, use re.split()

This trips up almost everyone:

"test.txt".rstrip(".txt")   # "tes" — not "test"!

Why? strip(), lstrip(), and rstrip() treat the argument as a set of characters to remove from the ends. They keep removing any character that appears in the set until they hit one that doesn't.

"aabbcc".strip("abc")  # "" — all chars are in the set!
"file.txt".rstrip(".txt")  # "file" if lucky, less if unlucky

The fix: Use removeprefix() and removesuffix() (Python 3.9+):

"test.txt".removesuffix(".txt")  # "test"
"test.txt".removeprefix("test")  # ".txt"

For older Python, use slicing with a check:

s = "test.txt"
if s.endswith(".txt"):
    s = s[:-4]

join() is the inverse of split(), but it has a strict requirement:

",".join(["a", "b", "c"])  # "a,b,c"
",".join([1, 2, 3])        # TypeError: sequence item 0: expected str instance, int found

The fix: Convert all items to strings first:

# Option 1: map (slightly faster)
",".join(map(str, items))

# Option 2: generator expression
",".join(str(x) for x in items)

# Option 3: list comprehension
",".join([str(x) for x in items])

This is intentional design—Python prefers explicit conversion over surprising coercion.

f-strings use a powerful formatting syntax after the colon:

f"{value:[[fill]align][width][,][.precision][type]}"

Alignment

Add a fill character before the alignment:

f"{'hi':_<10}"   # "hi________"
f"{'hi':_>10}"   # "________hi"
f"{'hi':_^10}"   # "____hi____"

Number formatting

n = 1234567
f"{n:,}"         # "1,234,567" — thousands separator
f"{n:_}"         # "1_234_567" — underscore separator

n = 42
f"{n:05d}"       # "00042" — zero-pad to 5 digits
f"{n:+d}"        # "+42" — always show sign

x = 3.14159
f"{x:.2f}"       # "3.14" — 2 decimal places
f"{x:10.2f}"     # "      3.14" — width 10, 2 decimals

Debug syntax (Python 3.8+)

The = specifier prints both the expression and its value:

x = 42
print(f"{x=}")        # x=42
print(f"{x = }")      # x = 42 (spaces preserved)
print(f"{x*2 = }")    # x*2 = 84 (works with expressions)
print(f"{x = :.2f}")  # x = 42.00 (with format spec)

This replaces the common pattern of writing f"x = {x}" for debugging.

String slicing uses the same syntax as lists:

s = "Python"
s[0:3]    # "Pyt" — indices 0, 1, 2
s[3:]     # "hon" — from index 3 to end
s[:3]     # "Pyt" — from start to index 3
s[::2]    # "Pto" — every 2nd character
s[::-1]   # "nohtyP" — reversed

Key insight: Slicing never raises IndexError. Out-of-bounds indices are silently clamped:

s = "hi"
s[0:100]  # "hi" — not an error
s[100:]   # "" — empty string
s[5]      # IndexError! — indexing does raise

Reverse a string:

"hello"[::-1]  # "olleh"

The -1 step means "go backwards by 1".

split("\n") has two problems:

1. It doesn't handle Windows line endings (\r\n)
2. A trailing newline creates an empty string at the end

"a\nb\n".split("\n")    # ['a', 'b', '']
"a\nb\n".splitlines()   # ['a', 'b']

"a\r\nb".split("\n")    # ['a\r', 'b'] — \r left behind
"a\r\nb".splitlines()   # ['a', 'b'] — handles all endings

splitlines() recognizes: \n, \r\n, \r, and several others.

Pass keepends=True if you need the line endings:

"a\nb".splitlines(keepends=True)  # ['a\n', 'b']

"Does this string contain X?" is one of the most common string operations.

The in operator (existence check)

if "cat" in "concatenate":
    print("Found it!")  # This runs

Use in when you only need yes/no. It's readable and fast.

find() vs index()

Both return the position of a substring:

"hello".find("ll")   # 2
"hello".index("ll")  # 2

"hello".find("x")    # -1 (not found)
"hello".index("x")   # ValueError: substring not found

When to use which:

• find(): when "not found" is a valid case you'll handle
• index(): when "not found" should crash (it's a bug)

# find() pattern: check the return value
pos = text.find(target)
if pos != -1:
    # Found at position pos
    ...

# index() pattern: let it crash if missing
pos = text.index(target)  # Bug if not found

Right-to-left: rfind() and rindex() search from the end.

For validating user input:

user_input = input("Enter age: ")
if user_input.isdigit():
    age = int(user_input)
else:
    print("Please enter a number")

Note: All return False for empty strings. isnumeric() is broader than isdigit()—it includes Unicode numerals like ½ and ².

Backslashes are escape characters in normal strings:

print("Line1\nLine2")   # Prints on two lines
print("C:\\Users\\name")  # Need double backslashes

Raw strings treat backslashes as literal:

print(r"Line1\nLine2")  # Prints: Line1\nLine2
print(r"C:\Users\name")  # Prints: C:\Users\name

Use raw strings for:

1. Regex patterns: \d means "digit" in regex, but Python sees \d as an escape. For a deeper look at regex syntax, see the Python regex cheat sheet.

   import re
   re.findall(r"\d+", "abc123")  # ['123']
   re.findall("\\d+", "abc123")  # Same, but ugly
   

2. Windows paths:

   path = r"C:\Users\name\Documents"
   

Gotcha: Raw strings can't end with an odd number of backslashes (use regular string or add space).

For ASCII text, lower() works fine:

"Hello".lower() == "hello"  # True

For international text, use casefold():

# German sharp S
"ß".lower()     # "ß" — still sharp S
"ß".casefold()  # "ss" — proper lowercase

# Case-insensitive comparison
"STRASSE".casefold() == "straße".casefold()  # True
"STRASSE".lower() == "straße".lower()        # False!

Rule: Use casefold() for case-insensitive comparison of user input. Use lower() when you specifically want ASCII-only lowercasing. If you work across languages, Python vs JavaScript string handling covers the key differences in how each language approaches string operations.

TypeError: sequence item 0: expected str instance, int found

From join() with non-strings. Fix: ",".join(map(str, items))

IndexError: string index out of range

From indexing (not slicing) beyond the string length. Fix: check len() first, or use slicing which doesn't raise.

TypeError: 'str' object does not support item assignment

Strings are immutable. You can't do s[0] = "X". Fix: build a new string with slicing or replace().

Clean and split CSV-like input

text = "  Alice, Bob ,Carol "
names = [s.strip() for s in text.split(",")]
# ['Alice', 'Bob', 'Carol']

Check multiple extensions

if filename.endswith((".jpg", ".png", ".gif")):
    process_image(filename)

Title case with exceptions

s = "the quick BROWN fox"
s.title()      # "The Quick Brown Fox" — capitalizes every word
s.capitalize() # "The quick brown fox" — first char only

Multiline f-strings

# Use parentheses for implicit concatenation
message = (
    f"Hello {name}, "
    f"you have {count} items "
    f"worth {total:.2f}"
)

# Or triple quotes for literal newlines
message = f"""
Hello {name},
You have {count} items.
"""

Replace with count limit

# Replace all occurrences (default)
"a-b-c-d".replace("-", "_")     # "a_b_c_d"

# Replace only first N occurrences
"a-b-c-d".replace("-", "_", 2)  # "a_b_c-d"

Replace multiple characters

# For a few characters, chain replace:
s.replace("a", "").replace("b", "").replace("c", "")

# For many, use str.translate:
s.translate(str.maketrans("", "", "abc"))

• Python Tutorial: Strings
• Common string operations (str methods)
• Format String Syntax
• Format Specification Mini-Language
• PEP 498 – Literal String Interpolation (f-strings)
• PEP 616 – removeprefix and removesuffix