Python String API for Interviews
Work through split, join, replace, find, ord/chr, and string formatting patterns that appear in interview problems involving parsing and transformation.
Python String API for Interviews is a free DSA Interview Prep lesson on CoddyKit — lesson 1 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the DSA Interview Prep learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.
Strings Are Immutable in Python
Python strings are immutable — you cannot change a character in place. Every string operation that appears to modify a string actually creates a new one. This means s[0] = 'X' raises a TypeError. When you need in-place manipulation, convert to a list of characters first, do your work, then ''.join(chars) to reconstruct. This is the standard interview pattern for string mutation problems.
s = 'hello'
# s[0] = 'H' # TypeError!
# In-place mutation pattern:
chars = list(s)
chars[0] = 'H'
result = ''.join(chars)
print(result) # 'Hello'
# Reversing a string
print(s[::-1]) # 'olleh'
print(''.join(reversed(s))) # 'olleh'split() and join(): Parsing and Building
s.split(sep) splits a string on a delimiter and returns a list of substrings. sep=None (default) splits on any whitespace and discards empty strings — ideal for parsing space-separated input. 'sep'.join(iterable) concatenates strings with a separator between them. The idiom ' '.join(words) is the efficient way to build a space-separated string from a list — never use + in a loop.
# split
sentence = ' hello world '
words = sentence.split() # ['hello', 'world']
print(words)
csv = 'a,b,c,d'
parts = csv.split(',') # ['a', 'b', 'c', 'd']
print(parts)
# join
print(' '.join(words)) # 'hello world'
print(','.join(['x','y','z'])) # 'x,y,z'
# Reverse words in a sentence
print(' '.join(sentence.split()[::-1])) # 'world hello'find(), index(), and in
s.find(sub) returns the index of the first occurrence of sub, or -1 if not found. s.index(sub) does the same but raises ValueError if absent — prefer find in interview code to avoid unhandled exceptions. The in operator for strings is O(n×m) substring search, same as find. Use optional start and end parameters to search within a slice without copying.
s = 'abcabcabc'
print(s.find('bc')) # 1 (first occurrence)
print(s.find('bc', 2)) # 4 (search from index 2)
print(s.find('xyz')) # -1 (not found)
print('abc' in s) # True
# Count occurrences manually
count = 0
start = 0
while True:
idx = s.find('bc', start)
if idx == -1: break
count += 1
start = idx + 1
print(count) # 3replace(), strip(), and Case Methods
s.replace(old, new, count=-1) returns a new string with all (or the first count) occurrences replaced. s.strip() removes leading and trailing whitespace (or specified characters). Case methods lower(), upper(), capitalize(), and swapcase() create new strings — remember these return values, they do not mutate. Normalising case before comparison is essential for case-insensitive problems.
s = ' Hello, World! '
print(s.strip()) # 'Hello, World!'
print(s.strip().lower()) # 'hello, world!'
print('banana'.replace('a', 'o')) # 'bonono'
print('banana'.replace('a', 'o', 2)) # 'bonona'
# Normalise for comparison
def same_ignoring_case(a, b):
return a.lower() == b.lower()
print(same_ignoring_case('Racecar', 'racecar')) # Truestartswith(), endswith(), and isalnum()
Predicate string methods return boolean and are O(k) where k is the pattern length. s.startswith(prefix) and s.endswith(suffix) accept tuples for multiple alternatives. s.isalpha(), s.isdigit(), s.isalnum(), and s.isspace() test character classes. These are used in valid-palindrome, valid-number, and URL-parsing interview problems.
print('hello'.startswith('hel')) # True
print('hello'.endswith(('lo', 'la'))) # True
# isalnum for palindrome filtering
def clean(s):
return ''.join(c.lower() for c in s if c.isalnum())
print(clean('A man, a plan, a canal: Panama'))
# 'amanaplanacanalpanama'
print(clean('123abc!@#'))
# '123abc'ord(), chr(), and ASCII Arithmetic
ord(c) returns the Unicode code point of character c. chr(n) converts an integer back to a character. For lowercase letters, ord(c) - ord('a') gives 0-25 — a clean way to build frequency arrays of fixed size 26 without a hash map, which is faster in practice for the English alphabet. This technique appears in anagram and palindrome problems.
print(ord('a')) # 97
print(ord('z')) # 122
print(chr(65)) # 'A'
# Frequency array for lowercase letters
def char_freq(s):
freq = [0] * 26
for c in s:
freq[ord(c) - ord('a')] += 1
return freq
print(char_freq('anagram')) # [3,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0]
# index 0='a'(3), 6='g'(1), 12='m'(1), 17='r'(1)String Formatting for Output
In coding interviews, clean output sometimes matters. Python offers three formatting styles: %-formatting (old), .format() (classic), and f-strings (modern, preferred). F-strings are the most readable and support expressions directly: f'{value:.2f}' formats a float to 2 decimal places. Knowing how to format numbers, pad strings, and print tables quickly reduces debugging time under pressure.
name = 'Alice'
score = 95.678
# f-string (preferred in interviews)
print(f'{name}: {score:.1f}') # Alice: 95.7
print(f'{name:>10}: {score:05.1f}') # right-align
# Zero-pad an integer
print(f'{42:04d}') # 0042
# Join and format a list
nums = [1, 2, 3, 4]
print(', '.join(str(n) for n in nums)) # '1, 2, 3, 4'Efficient String Building with join()
String concatenation with + in a loop creates a new string each iteration, costing O(n²) total for n characters. The correct pattern: append parts to a list and call ''.join(parts) at the end, which is O(n). This is one of the most common Python performance anti-patterns. In an interview, mentioning this trade-off shows that you understand Python's memory model.
# SLOW: O(n^2) due to repeated string allocation
def build_bad(chars):
s = ''
for c in chars:
s += c # creates a new string each time!
return s
# FAST: O(n)
def build_good(chars):
parts = []
for c in chars:
parts.append(c)
return ''.join(parts) # single allocation
# Or even more concise:
def build_best(chars):
return ''.join(chars)
print(build_best(['h','e','l','l','o'])) # 'hello'Parsing Integers and Floats from Strings
Converting between strings and numbers is fundamental in parsing problems. int(s) and float(s) parse numeric strings; they raise ValueError for invalid input. For safer parsing, use a try-except block. The string methods isdigit() and isnumeric() pre-validate before conversion. Problems like 'atoi' (string to integer) require handling leading spaces, signs, and overflow.
def my_atoi(s):
s = s.lstrip() # remove leading spaces
if not s: return 0
sign = 1
idx = 0
if s[0] in '-+':
sign = -1 if s[0] == '-' else 1
idx = 1
num = 0
while idx < len(s) and s[idx].isdigit():
num = num * 10 + int(s[idx])
idx += 1
result = sign * num
INT_MAX, INT_MIN = 2**31 - 1, -(2**31)
return max(INT_MIN, min(INT_MAX, result))
print(my_atoi(' -42')) # -42
print(my_atoi('4193 with words')) # 4193String Slicing in Algorithm Problems
String slicing is used constantly but has hidden costs: s[i:j] creates a new string of length j-i in O(j-i) time. When you need to pass substrings to recursive functions, consider passing indices (start, end) instead of the actual substring to avoid O(n²) allocation overhead. This optimization matters in problems like longest-palindromic-substring where many substrings are tested.
# Naive: O(n^3) because slicing inside nested loops
def is_palindrome_naive(s):
return s == s[::-1] # O(n) slice + O(n) compare
# Pass indices to avoid allocating substrings
def is_palindrome_range(s, left, right):
while left < right:
if s[left] != s[right]:
return False
left += 1; right -= 1
return True # O(right-left) time, O(1) space
print(is_palindrome_range('racecar', 0, 6)) # True
print(is_palindrome_range('hello', 0, 4)) # FalseString Interview Quick Reference
Keep these string methods mentally indexed for interviews:
split / join— parse and buildstrip / lstrip / rstrip— trim whitespacelower / upper— normalise casefind / index— locate substringsreplace— substitutionsisalnum / isalpha / isdigit— character class checksord / chr— ASCII arithmetic for fixed-alphabet problemsstartswith / endswith— prefix/suffix checks
# Combining methods: reverse words, preserve spaces
def reverse_words(s):
return ' '.join(reversed(s.split()))
print(reverse_words(' hello world '))
# 'world hello'
# Check anagram using sorted strings
def is_anagram(s, t):
return sorted(s) == sorted(t)
print(is_anagram('anagram', 'nagaram')) # True
print(is_anagram('rat', 'car')) # FalseQuick Check
Test your understanding of Data Structures & Algorithms — Coding Interview Prep concepts from this lesson.
Lesson Recap
In this lesson you learned: Python strings are immutable — mutation requires converting to a list, modifying, then joining back, ord/chr enable fixed-size frequency arrays of size 26 for lowercase-letter problems, which are faster than hash maps for bounded alphabets, and building strings with + in a loop costs O(n²) — always accumulate in a list and use ''.join() at the end for O(n). Next up we explore the sliding window technique for substring problems.
Frequently asked questions
Is the “Python String API for Interviews” lesson free?
Yes — the full text of “Python String API for Interviews” is free to read here on the web, and the DSA Interview Prep course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the DSA Interview Prep course, upgrade to CoddyKit PRO.
What will I learn in “Python String API for Interviews”?
Work through split, join, replace, find, ord/chr, and string formatting patterns that appear in interview problems involving parsing and transformation. You practise DSA Interview Prep with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.
Do I need any experience to start DSA Interview Prep?
No prior experience is required. DSA Interview Prep on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 4, so you can start here or from the beginning and move at your own pace.
How long does the “Python String API for Interviews” lesson take?
Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.
Can I write and run code in this DSA Interview Prep lesson?
Yes. Every DSA Interview Prep lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.
All lessons in this course
- Python String API for Interviews
- Sliding Window for Substrings
- Anagrams and Character Frequency Maps
- String Encoding, Reversal, and Palindromes