Python | Remove given element from list of lists (original) (raw)

The deletion of elementary elements from list has been dealt with many times, but sometimes rather than having just a one list, we have list of list where we need to perform this particular task. Having shorthands to perform this particular task can help. Let’s discuss certain ways to perform this particular task.

Method #1: Using list comprehension The logic behind this kind of method is to reduce the size of code and do the task to perform using loops as a way of list comprehension itself.

Python3

test_list = [[ 4 , 5 , 6 ], [ 5 , 6 , 4 , 1 ], [ 4 ], [ 4 , 8 , 9 , 10 ]]

print ("The original list : " + str (test_list))

N = 4

res = [[ele for ele in sub if ele ! = N] for sub in test_list]

print ("The list after deletion of element : " + str (res))

Output :

The original list : [[4, 5, 6], [5, 6, 4, 1], [4], [4, 8, 9, 10]] The list after deletion of element : [[5, 6], [5, 6, 1], [], [8, 9, 10]]

Time Complexity: O(n), where n is the number of elements in the list test_list. The list comprehension is used to perform the task and it takes O(n) time.
Auxiliary Space: O(n), additional space of size n is created where n is the number of elements in the new res list.

Method 2: Using list comprehension + list slicing In this method, we generally do the task similar to the above method, the variation is just we use list slicing for better code readability.

Python3

test_list = [[ 4 , 5 , 6 ], [ 5 , 6 , 4 , 1 ], [ 4 ], [ 4 , 8 , 9 , 10 ]]

print ("The original list : " + str (test_list))

N = 4

for sub in test_list:

`` sub[:] = [ele for ele in sub if ele ! = N]

print ("The list after deletion of element : " + str (test_list))

Output :

The original list : [[4, 5, 6], [5, 6, 4, 1], [4], [4, 8, 9, 10]] The list after deletion of element : [[5, 6], [5, 6, 1], [], [8, 9, 10]]

Time complexity: O(n*m), where n is the number of sublists in the list and m is the average length of the sublists.
Auxiliary space: O(1), since the list is modified in place and no additional data structure is used.

Method 3: Using enumerate function

Python3

test_list = [[ 4 , 5 , 6 ], [ 5 , 6 , 4 , 1 ], [ 4 ], [ 4 , 8 , 9 , 10 ]]

N = 4

res = [[ele for j,ele in enumerate (sub) if ele ! = N] for i,sub in enumerate (test_list)]

print (res)

Output

[[5, 6], [5, 6, 1], [], [8, 9, 10]]

Method 4: Using remove() function

This approach involves looping through each sublist and removing the element using the remove() function. It can be implemented as follows:

Python3

def remove_element(lst, element):

`` for sub in lst:

`` sub.remove(element)

test_list = [[ 4 , 5 , 6 ], [ 5 , 6 , 4 , 1 ], [ 4 ], [ 4 , 8 , 9 , 10 ]]

print ( "The original list :" , test_list)

remove_element(test_list, 4 )

print ( "The list after deletion of element :" , test_list)

Output

The original list : [[4, 5, 6], [5, 6, 4, 1], [4], [4, 8, 9, 10]] The list after deletion of element : [[5, 6], [5, 6, 1], [], [8, 9, 10]]

The time complexity of the remove_element() function using a for loop is O(n), where n is the total number of elements in the list of lists. This is because the function processes each element in the lists once.

The auxiliary space is O(1), because the function does not create any additional data structures to store the result. It modifies the original list in place.

Method 5: Using recursive function

Using recursive function method, we can remove the element in every nested list

Python3

def remove_element(start,oldlist,newlist,element):

`` if start = = len (oldlist): return newlist

`` sublist = []

`` for i in oldlist[start]:

`` if i = = element: pass

`` else :sublist.append(i)

`` newlist.append(sublist)

`` return remove_element(start + 1 ,oldlist,newlist,element)

test_list = [[ 4 , 5 , 6 ], [ 5 , 6 , 4 , 1 ], [ 4 ], [ 4 , 8 , 9 , 10 ]]

print ( 'The Original list: ' ,test_list)

element = 4

print ( 'The List after deleted 4 in every nested list:' ,remove_element( 0 ,test_list,[],element))

Output

The Original list: [[4, 5, 6], [5, 6, 4, 1], [4], [4, 8, 9, 10]] The List after deleted 4 in every nested list: [[5, 6], [5, 6, 1], [], [8, 9, 10]]

Method 6: Using filter()

Python3

test_list = [[ 4 , 5 , 6 ], [ 5 , 6 , 4 , 1 ], [ 4 ], [ 4 , 8 , 9 , 10 ]]

N = 4

print ( 'The Original list: ' ,test_list)

res = [ list ( filter ( lambda x: x ! = N, sub)) for sub in test_list]

print ( "The list after deletion of element : " + str (res))

Output

The Original list: [[4, 5, 6], [5, 6, 4, 1], [4], [4, 8, 9, 10]] The list after deletion of element : [[5, 6], [5, 6, 1], [], [8, 9, 10]]

Time Complexity: O(N*M)
Auxiliary Space: O(N*M)

Method 5: Using map() and filter() functions

This approach involves using the map() and filter() functions in combination with lambda functions to remove the specified element from the list of lists.

Algorithm:

  1. Initialize a variable “N” to the element that needs to be removed.
  2. Define a lambda function “remove_element” that returns a filtered sublist by removing the element “N” from the input sublist.
  3. Use the map() function to apply the “remove_element” function to each sublist in the input list and convert the resulting map object to a list.

Python3

def remove_element(N, sub): return list ( filter ((N).__ne__, sub))

test_list = [[ 4 , 5 , 6 ], [ 5 , 6 , 4 , 1 ], [ 4 ], [ 4 , 8 , 9 , 10 ]]

print ( "The original list : " + str (test_list))

N = 4

res = list ( map ( lambda sub: remove_element(N, sub), test_list))

print ( "The list after deletion of element : " + str (res))

Output

The original list : [[4, 5, 6], [5, 6, 4, 1], [4], [4, 8, 9, 10]] The list after deletion of element : [[5, 6], [5, 6, 1], [], [8, 9, 10]]

Time Complexity: O(n*m), where n is the number of sublists in the input list and m is the average length of the sublists. This is because the map() function applies the remove_element function to each sublist, which takes O(m) time to execute.

Auxiliary Space: O(n*m), since a new list of lists is created to store the filtered sublists, which has n sublists each of average length m.