Strings: Intermediate

text = "Python"
first = text[___]
last = text[___]
print(first)
print(last)

This raises IndexError: string index out of range. Always check the string length before accessing by index if the position might be invalid.

The first slice [0:6] returns "Python" (characters 0 through 5). The second [7:18] returns "Programming" (characters 7 through 17).

You can omit the start or end index. Omitting start defaults to 0. Omitting end defaults to the string length.

text[:6] gives "Python" (from start to index 6). text[7:] gives "Programming" (from index 7 to end). text[:] creates a copy of the entire string.

This extracts "pdf" using filename[-3:] (last 3 characters) and "document" using filename[:-4] (everything except last 4 characters including the dot).

text[::2] gives "Pto" (every other character). text[1::2] gives "yhn" (every other starting from index 1). text[::-1] gives "nohtyP" (reversed string).

The in operator checks if a substring exists within a string. It returns True or False.

.find() returns the position of the first occurrence of a substring, or -1 if not found. .index() does the same but raises an error if not found.

.count() returns the number of non-overlapping occurrences of a substring:

name = "data.backup.csv"
print(name.___(".csv"))
print(name.___("."))

startswith() and endswith() are cleaner than slicing for prefix and suffix checks. They also accept a tuple of options, so filename.endswith((".pdf", ".docx", ".txt")) checks all three extensions in a single readable call.

count() returns how many non-overlapping times a substring appears in a string. It is useful for quick frequency checks, such as counting how many dots are in a filename to determine if it has multiple extensions.

.strip() removes whitespace from both ends of a string. .lstrip() removes from the left only, .rstrip() from the right only.

.replace() substitutes all occurrences of a substring with another:

This replaces "cats" with "dogs". Note that "Cats" with capital C is not replaced because replace() is case-sensitive.

This chains replace() calls to remove all formatting, leaving just "5551234567".

F-strings (formatted string literals) are the modern way to embed expressions inside strings. Prefix the string with f and use curly braces {} to insert values.

This outputs: "My name is Maya and I am 28 years old." The variables are automatically converted to strings inside the {} placeholders.

These print: "$49.50" (2 decimal places), "85.4%" (percentage format), and "1,000,000" (comma separators).

filename = "report.pdf"
ext = filename___[-3:][:-3][7:]
print(ext)

Negative slicing with [-n:] reliably extracts the last n characters of any string, regardless of its total length. This makes it more robust than hardcoded index slices like [7:], which break if the string length changes.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

text = "I like Cats and cats"
result = text.replace("cats", "dogs")
print(result)

Case sensitivity is one of the most common sources of string comparison bugs. Always normalize user input to a consistent case before comparing or replacing. Calling .lower() before .replace() ensures both "cats" and "Cats" and "CATS" are all matched.

Indexing and slicing

Access characters by position and extract substrings with [start:end:step].

Search methods

Use in, find(), count(), startswith(), and endswith() to locate text.

Transform methods

strip(), replace(), and case methods to clean and modify strings.

Validation methods

isdigit(), isalpha(), isalnum() to verify string content.