Which String Methods Come Up in Interviews?

Interviewers usually reach for the same short list of methods. They ask about the cleaning methods, the searching methods, and the methods that split and join text.

s = '  Hello, World  '

print(repr(s.strip()))
print(s.lower())
print(s.replace('World', 'Python'))
print(s.split(', '))
print('-'.join(['a', 'b']))
print(s.startswith('  '))
print(s.find('World'))
print(s.count('l'))
print(repr(s.title()))
print(s.isdigit())

Several of those results are worth reading carefully. The find call returns 9, which is the position of the letter W, because the two leading spaces are counted as well. The count call returns 3, which is two letter l characters in Hello and one in World. The title() call looks as if it should change something, but the words are already capitalised, so it gives back the same text.

The cleaning methods come in pairs that are worth knowing. strip() removes whitespace from both ends, and lstrip() and rstrip() remove it from one side only. The argument is optional, and when you give one it removes that character instead of whitespace, so s.strip(',') removes commas from the ends.

The searching methods fall into three families. find() and index() return a position, and they differ in what happens when there is no match. index() raises a ValueError while find() returns -1. The in operator tests membership and gives you a boolean. The startswith() and endswith() methods accept a tuple of alternatives, so filename.endswith(('.csv', '.tsv')) checks both of them without an or.

Every membership test is case-sensitive, and that is the most common source of a wrong answer in an interview. Python has no built-in case-insensitive contains, so the usual habit is to lowercase both sides before you compare them.

Substring tests use the in operator, and the case-insensitive version uses lower() on both sides.

text = 'Please find the error in this report'

print('error' in text)
print('Error' in text)
print('error' in text.lower())

# startswith and endswith accept a tuple of alternatives
filename = 'data.csv'
print(filename.endswith(('.csv', '.tsv')))

# Split the text and join part of it back together
parts = text.split()
print(len(parts))
print(' '.join(parts[2:4]))

The membership test is the one to reach for. The in operator works on any container, and for strings it checks for a substring rather than for an exact match. For case-insensitive matching you lowercase both sides, and never just one of them, because a one-sided test gives you an answer that only works in one direction.

The split and join pair is the other half of the story. split() with no argument splits on any amount of whitespace and throws the empty pieces away, which is why it is the right call when you want to count the words in a paragraph. split() with a separator splits on that exact string and keeps the empty pieces, so 'a,,b'.split(',') gives you three elements and not two. join() then puts a separator back between the pieces.

There are two details to know. The separator in join() belongs to the string that you call it on, so the expression reads as "comma joined items". And join() needs every element to be a string, so passing an integer raises a TypeError and you should convert it first with str(). And if you only need to check whether something is there, then do not split the text at all. A substring test walks the text once, while splitting builds a list of every piece and takes memory.

Most hand-written string loops in interviews are a sign that you have not met the built-in methods yet. Removing whitespace is strip() and not a while loop. Splitting on a separator is split() and not a find-and-append loop. Reversing is text[::-1]. Checking for a prefix is startswith() and not a slice with a comparison. Lowercasing and stripping together is a chain, such as text.strip().lower().

The methods that have genuine edge cases are the ones to warn an interviewer about. split() with no separator collapses runs of whitespace and removes the empty pieces, while split(' ') splits on exactly one space and keeps the empty strings. So 'a b'.split() gives two elements and 'a b'.split(' ') gives three. A third variant, splitlines(), splits on line boundaries and copes with different line endings.

strip() removes whitespace by default, but when you give it an argument it removes that character instead, and that is not always what people expect. The call 'xxhixx'.strip('x') removes the x characters from both ends and returns hi, and not hihi.

replace() replaces every occurrence unless you give it a count, and it is case-sensitive, so replacing cat does not touch Cat. The count() method counts occurrences that do not overlap each other, which differs in a subtle way from the number of times a character appears in a row of repeated characters. The call 'aaa'.count('aa') is 1 and not 2.

Finally, the case methods are not a complete Unicode case mapping. upper() and lower() handle most of the Unicode range, but title() and capitalize() use their own idea of where a word begins, and that idea does not always match what a human would call a word. They can behave in a surprising way on names and on acronyms. For text that has to survive a case change and come back unchanged, test it rather than assuming it will work.