How do you work with string data in pandas using the .str accessor, and how does it compare to applying Python string methods manually?

How to think about it

The interviewer is really watching which tool you reach for by reflex. Both .str.upper() and apply(lambda x: x.upper()) produce the same letters, so this is not about output — it is about whether you know that .str is faster, survives missing values, and reads cleanly inside a chain, while the lambda is slower and crashes on the first NaN. When you write s.apply(lambda x: x.upper()), pandas makes a Python function call per element and pays interpreter overhead on every row. .str.upper() dispatches one internal loop over the whole Series. And float('nan') has no .upper() method, so the lambda throws the instant a blank cell appears — while .str quietly passes NaN through untouched.

One messy column, several operations

Here is a name column with leading whitespace, mixed case, a real None, an apostrophe, and a hyphen — the kind of thing a CSV export actually hands you. Watch .str handle every row, including the missing one, without a single guard clause.

import pandas as pd

names = pd.Series(["  Alice Smith ", "bob jones", None, "CAROL O'BRIEN", "dave-k"])

print("Title case (after strip):")
print(names.str.strip().str.title())
print()

print("Contains 'jones' (na=False handles the None):")
print(names.str.contains("jones", case=False, na=False))
print()

split = names.str.strip().str.split(r"[\s\-]+", expand=True)
print("Split on whitespace or hyphen into columns:")
print(split)
print()

clean = (
    names
    .str.strip()
    .str.lower()
    .str.replace(r"[^a-z\s]", "", regex=True)   # drop punctuation
    .str.replace(r"\s+", "_", regex=True)        # spaces to underscores
)
print("Cleaned slugs:")
print(clean)

Title case (after strip):
0      Alice Smith
1        Bob Jones
2             None
3    Carol O'Brien
4           Dave-K
dtype: object

Contains 'jones' (na=False handles the None):
0    False
1     True
2    False
3    False
4    False
dtype: bool

Split on whitespace or hyphen into columns:
       0        1
0  Alice    Smith
1    bob    jones
2   None     None
3  CAROL  O'BRIEN
4   dave        k

Cleaned slugs:
0     alice_smith
1       bob_jones
2            None
3    carol_obrien
4           davek
dtype: object

Look at row 2 in every block: the None rides straight through as None or NaN rather than blowing up. Notice too that na=False forces the missing value to read False in the boolean mask — exactly what you want for filtering, so the mask stays usable for indexing. And the final pipeline chains five .str calls end to end because each one returns a Series, turning “strip, lowercase, strip punctuation, slugify” into one readable expression.

Operation	.str method
Normalize case	.str.lower() / .str.upper() / .str.title()
Trim whitespace	.str.strip() / .str.lstrip() / .str.rstrip()
Check content	.str.contains(pat, na=False) / .str.startswith()
Split into columns	.str.split(pat, expand=True)
Regex extract	.str.extract(r"(...)") → DataFrame
Replace	.str.replace(pat, repl, regex=True)
Length	.str.len()

For stricter null handling, convert to StringDtype with s.astype("string"): missing values become pd.NA instead of float('nan'), which is more predictable and avoids the object-dtype overhead.