Write a function that replaces all characters in a list except for a given character

The most Pythonic and efficient way to replace characters in a list, except for a specified one, is using a list comprehension. This approach directly constructs a new list by iterating once over the original, applying a conditional replacement for each element.

Mechanics and Why it Works

A list comprehension [expression_if_true if condition else expression_if_false for item in iterable] is a concise and highly optimized construct in Python for creating new lists. For this problem, the structure [c if c == keep else rep for c in lst] iterates through each character c in the input lst. If c matches the keep character, c itself is retained in the new list. Otherwise, the rep (replacement) character is used. This method is preferred over explicit for loops with append calls because it's often more readable, less prone to off-by-one errors, and frequently performs better due to internal C optimizations. If the input lst is a string, you can convert it to a list first (list(my_string)) and then use str.join() on the result to get a string back.

Example and Trade-offs

Consider lst = ['a', 'b', 'a', 'c'], keep = 'a', and rep = ''. The list comprehension processes each element: 'a' (kept), 'b' (replaced with ''), 'a' (kept), 'c' (replaced with ''), yielding ['a', '', 'a', '*']. This solution gracefully handles edge cases such as an empty input list (returning an empty list) or when the keep character is not present (all characters are replaced). A key benefit is that it creates a new list, ensuring the original list remains immutable. The primary trade-off is memory usage, as a new list of roughly the same size as the input is generated.

def replace_except(lst, keep, rep='*'):
    return [c if c == keep else rep for c in lst]

In the interview, also mention…

Discuss the time complexity as O(N) because the function iterates through the list once. The space complexity is also O(N) as a new list is created to store the results. For extremely large datasets where memory is a concern and the full list isn't needed immediately, you could suggest a generator expression instead of a list comprehension, which would provide O(1) space complexity until iterated over.