Python – Remove elements at Indices in List

Given List, remove all the elements present in the indices list in Python.

Input : test_list = [5, 6, 3, 7, 8, 1, 2, 10], idx_list = [2, 4, 5] 
Output : [5, 6, 7, 2, 10] 
Explanation : 3, 6, and 1 has been removed.

Input : test_list = [5, 6, 3, 7, 8, 1, 2, 10], idx_list = [2] 
Output : [5, 6, 7, 8, 1, 2, 10] 
Explanation : 3 has been removed.  

In this article, we will cover how to Remove items at a specific index from Python List, and cover different methods that are listed below:

• Remove an item by index and get its value using pop()
• Remove items by index or slice using del.
• Remove items at a specific index using enumerate() + loop 
• Remove items at a specific index using enumerate() + list comprehension

Method 1: Remove an item by index and get its value using pop()

In this example, we will use the pop method to remove the element from the list, here in the pop we will pass the index value to remove the element at that position.

Output:

[5, 3, 7, 8, 1, 2, 10]

Time complexity: O(n), where n is the length of the list. 
Auxiliary space: O(1), since the operation does not require any additional space besides the list itself.

Method 2: Remove items by index or slice using del

In this example, we will use the del keyword to delete the specific elements present in the list. Here we will remove multiple items from the list by index. Please note that we need to sort the indices in reversed order to ensure that the shift of indices induced by the deletion of elements at lower indices won’t invalidate the index specifications of elements at larger indices.

Output:

[5, 6, 3, 8, 1, 2, 5]

Time complexity: O(nlogn), where n is the length of the test_list. 
Auxiliary Space: O(1), constant extra space is required

Method 3: Remove items at a specific index using enumerate() + loop

In this, we iterate for all the elements, and if the index is present in the list, then that index element is omitted from the result list.

Output:

The original list is : [5, 6, 3, 7, 8, 1, 2, 10]
Filtered List after removal : [5, 6, 7, 2]

Time complexity: O(n), where n is the length of the input list test_list
Auxiliary space: O(n), where n is the length of the input list test_list. 

Method 4: Remove items at a specific index using enumerate() + list comprehension

In this, we perform the task of iteration using list comprehension in a compact way, the rest of the methods are similar to the above.

Output:

The original list is : [5, 6, 3, 7, 8, 1, 2, 10]
Filtered List after removal : [5, 6, 7, 2]

Time Complexity: O(n), where n is the length of the original list test_list. 
Auxiliary Space: O(m), where m is the length of the index list idx_list. 

Method#5: Using Recursive method.

Algorithm:

1. If the input index list is empty, return the original list.
2. Extract the first index from the input index list and recursively process the rest of the list.
3. Remove the element at the current index from the result of the recursive call.
4. Return the updated list.

The original list is : [5, 6, 3, 7, 8, 1, 2, 10]
Filtered List after removal : [5, 6, 7, 2]

Time complexity: O(m*n)

The function removes elements from the list for each index in the input index list, so the time complexity is O(m*n), where m is the length of the index list and n is the length of the input list.

Auxiliary Space:  O(max(m, n))

The function uses a recursive approach, so the space complexity is O(m), where m is the length of the input index list due to the recursive call stack. However, the space complexity of the list created is also O(n) as each element is removed one by one. So, the overall space complexity is O(max(m, n)).

 Method #6: Using filter() and lambda function:

Approach:

Create a new list using filter() function and lambda function.
The lambda function takes each element in test_list, and checks if its index is not in idx_list. If the index is not in idx_list, the lambda function returns True and the element is kept in the new list. If the index is in idx_list, the lambda function returns False and the element is filtered out.
The filtered new list is assigned to new_list.
The new_list is printed as the output.

[5, 6, 7, 2, 10]

Time complexity: O(n^2) – We use index() method inside lambda function that has O(n) time complexity.
Auxiliary Space: O(n) – We create a new list to store the remaining elements.

METHOD 7: Using List Comprehension

APPROACH:

1.Create a new list by iterating through the original list and adding elements to the new list only if the index is not in the index list.
2.Return the updated list.

ALGORITHM:

1.Initialize a new list.
2.Iterate through the original list using a for loop.
3.Check if the index of the current element is present in the index list using an if condition.
4.If the index is not present in the index list, add the element to the new list.
5.Return the updated list.

Updated list: [5, 6, 7, 2, 10]

Time Complexity: O(n)
Auxiliary Space: O(n)