5 Best Ways to Replace the Last N Occurrences in a Python List

In Python, lists are a fundamental data structure used to store collections of items. Occasionally, you may encounter a situation where you need to replace the last n occurrences of a specific element within a list. For instance, suppose you have a list [1, 3, 5, 3, 3, 3] and you want to replace the last two occurrences of 3 with 9, resulting in [1, 3, 5, 3, 9, 9]. This article will provide various methods to achieve this task efficiently.

Method 1: Using Slicing and List Comprehension

This method employs list slicing to isolate the portion of the list to be modified and a list comprehension to apply the replacement. This method is both straightforward and pythonic, maintaining readability and taking advantage of Python’s syntactic sugar.

Here’s an example:

def replace_last_occurrences(lst, to_replace, replacement, n):
    index = len(lst) - 1 - lst[::-1].index(to_replace)
    return lst[:index] + [replacement if x == to_replace else x for x in lst[index:]]
    
my_list = [1, 3, 5, 3, 3, 3]
modified_list = replace_last_occurrences(my_list, 3, 9, 2)
print(modified_list)

Output:

In the code example, the function replace_last_occurrences() finds the starting index for replacement using list slicing and .index() method. Following the index, it uses list comprehension to iterate and perform replacements over the last n occurrences. The original list upfront remains untouched, which ensures the previous elements are preserved.

Method 2: Using Reverse Enumeration

To replace the last n occurrences, one can reverse the list order, track occurrences using enumeration, and apply changes accordingly. This approach is ideal for cases that demand preservation of memory space because it eliminates the need for additional lists or slices.

Here’s an example:

def replace_last_occurrences_reverse_enum(lst, to_replace, replacement, n):
    count = 0
    for i, v in reversed(list(enumerate(lst))):
        if v == to_replace:
            lst[i] = replacement
            count += 1
            if count == n:
                break
    return lst

my_list = [1, 3, 5, 3, 3, 3]
modified_list = replace_last_occurrences_reverse_enum(my_list, 3, 9, 2)
print(modified_list)

Output:

The replace_last_occurrences_reverse_enum() function iterates the list in reverse order and updates the elements as soon as they match the criteria. By using enumeration, we keep the logic simple and avoid creating additional list slices.

Method 3: Utilizing a Stack-based Approach

A stack-based approach involves pushing elements onto a stack until the last n occurrences are found, at which point replacements are made. This method can be more intuitive for those familiar with stack operations and doesn’t require modifying the input list in place.

Here’s an example:

def replace_last_occurrences_stack(lst, to_replace, replacement, n):
    stack = []
    count = 0
    for el in reversed(lst):
        if el == to_replace and count < n:
            stack.append(replacement)
            count += 1
        else:
            stack.append(el)
    return stack[::-1]

my_list = [1, 3, 5, 3, 3, 3]
modified_list = replace_last_occurrences_stack(my_list, 3, 9, 2)
print(modified_list)

Output:

In the replace_last_occurrences_stack() function, the program uses a stack to temporarily store elements from the original list. As it encounters the specified n occurrences from the end, it replaces them. Finally, the stack is reversed to obtain the correctly ordered list.

Method 4: Using Traditional Loop and Count

This conventional method utilizes a standard loop to traverse the list from the end and a counter to keep track of the replacements made. It may be viewed as less elegant but is very clear for understanding and debugging, making it a viable option for beginners.

Here’s an example:

def replace_last_occurrences_loop(lst, to_replace, replacement, n):
    count = 0
    for i in range(len(lst) - 1, -1, -1):
        if lst[i] == to_replace and count < n:
            lst[i] = replacement
            count += 1
    return lst

my_list = [1, 3, 5, 3, 3, 3]
modified_list = replace_last_occurrences_loop(my_list, 3, 9, 2)
print(modified_list)

Output:

With the replace_last_occurrences_loop() function, we directly interact with the list indices to replace the elements. This method is straightforward but may seem verbose compared to more pythonic solutions.

Bonus One-Liner Method 5: Using List Slicing and Replace

Python’s capabilities allow for a powerful one-liner that can achieve the replace task by combining list slicing with str.replace() and then casting back to a list. For succinctness and minimalism, this approach is unmatched, although it may be less readable.

Here’s an example:

my_list = [1, 3, 5, 3, 3, 3]
replaced_list = my_list[::-1]
replaced_list = list(map(int, replaced_list.replace('3', '9', 2)[::-1]))
print(replaced_list)

Output:

This one-liner technique uses a string representation of the reversed list and the str.replace() function to replace the values, then maps back the string elements to integers and reverses the list again to its original order. Although it is concise, using string operations for list manipulations may not be the most efficient or clear approach.

Summary/Discussion

• Method 1: Using Slicing and List Comprehension. Strengths: Readable, concise, pythonic. Weakness: Creates a copy of part of the list, which may have performance implications for large lists.
• Method 2: Using Reverse Enumeration. Strengths: Memory efficient, no additional list copies. Weakness: More complex logic than other methods.
• Method 3: Utilizing a Stack-based Approach. Strengths: Intuitive for those familiar with stacks. Weakness: Inversion of the list twice, which may introduce a slight performance overhead.
• Method 4: Using Traditional Loop and Count. Strengths: Easy for beginners to understand. Weakness: Less pythonic and may lead to longer, more error-prone code.
• Method 5: Bonus One-Liner. Strengths: Extremely concise. Weaknesses: Readability and potential efficiency issues due to string-to-list conversions.