Python | Remove List elements containing given String character
Sometimes, while working with Python lists, we can have problem in which we need to perform the task of removing all the elements of list which contain at least one character of String. This can have application in day-day programming. Lets discuss certain ways in which this task can be performed.
Method #1 : Using loop This is brute force way in which this task can be performed. In this, we iterate for all list elements and check for occurrence of any character using loop.
Python3
test_list = [ '567' , '840' , '649' , '7342' ]
test_str = '1237'
print ("The original list is : " + str (test_list))
res = []
for sub in test_list:
flag = 0
for ele in sub:
if ele in test_str:
flag = 1
if not flag:
res.append(sub)
print ("The list after removal : " + str (res))
|
Output :
The original list is : ['567', '840', '649', '7342']
The list after removal : ['840', '649']
Time Complexity: O(n^2) where n is the number of elements in the list ‘test_list’ as we are using nested for loop.
Auxiliary Space: O(n) as we are using an additional list ‘res’ to store the elements after removal.
Method #2 : Using list comprehension This is another way to perform this task. This is similar to above method. In this we perform the task in similar way as above just as one liner.
Python3
def check_pres(sub, test_str):
for ele in sub:
if ele in test_str:
return 0
return 1
test_list = [ '567' , '840' , '649' , '7342' ]
test_str = '1237'
print ("The original list is : " + str (test_list))
res = [ele for ele in test_list if check_pres(ele, test_str)]
print ("The list after removal : " + str (res))
|
Output :
The original list is : ['567', '840', '649', '7342']
The list after removal : ['840', '649']
Time complexity: O(n*m), where n is the length of the list and m is the maximum length of a string in the list.
Auxiliary space: O(1), as the function check_pres only uses a constant amount of space.
Method #3: Using operator.countOf() method
Python3
import operator as op
def check_pres(sub, test_str):
for ele in sub:
if op.countOf(test_str, ele) > 0 :
return 0
return 1
test_list = [ '567' , '840' , '649' , '7342' ]
test_str = '1237'
print ( "The original list is: " + str (test_list))
res = [ele for ele in test_list if check_pres(ele, test_str)]
print ( "The list after removal : " + str (res))
|
Output
The original list is: ['567', '840', '649', '7342']
The list after removal : ['840', '649']
Time Complexity:O(N)
Auxiliary Space: O(N)
Method #4: Using filter() and lambda function
Python3
test_list = [ '567' , '840' , '649' , '7342' ]
test_str = '1237'
print ( "The original list is : " + str (test_list))
res = list ( filter ( lambda x: all (y not in test_str for y in x), test_list))
print ( "The list after removal : " + str (res))
|
Output
The original list is : ['567', '840', '649', '7342']
The list after removal : ['840', '649']
Time Complexity: O(N)
Auxiliary Space: O(N) as a new list is returned after filtering the elements.
Method #5: used in this code is a for loop and the “any” function
Python3
test_list = [ '567' , '840' , '649' , '7342' ]
test_str = '1237'
print ( "The original list is:" , test_list)
for elem in test_list[:]:
if any (char in elem for char in test_str):
test_list.remove(elem)
print ( "The list after removal:" , test_list)
|
Output
The original list is: ['567', '840', '649', '7342']
The list after removal: ['840', '649']
Time Complexity: O(n^2)
Auxiliary Space: O(1)
Method#6: Using Recursive method.
Algorithm:
- Define a function named remove_elements that takes two arguments: test_list and test_str.
- If the test_list is empty, return an empty list as the base case.
- If the first element of the test_list contains a character from the test_str, recursively call the remove_elements function with the tail of the test_list (i.e., all elements except the first).
- If the first element of the test_list does not contain any characters from the test_str, add it to the result list and recursively
- call the remove_elements function with the tail of the test_list.
- Return the result list.
Python3
def remove_elements(test_list, test_str):
if not test_list:
return []
elif any (ele in test_str for ele in test_list[ 0 ]):
return remove_elements(test_list[ 1 :], test_str)
else :
return [test_list[ 0 ]] + remove_elements(test_list[ 1 :], test_str)
test_list = [ '567' , '840' , '649' , '7342' ]
test_str = '1237'
print ( "The original list is : " + str (test_list))
res = remove_elements(test_list, test_str)
print ( "The list after removal : " + str (res))
|
Output
The original list is : ['567', '840', '649', '7342']
The list after removal : ['840', '649']
Time complexity:
The time complexity of this algorithm is O(n*m), where n is the length of the input list and m is the maximum length of the string elements in the list. This is because we need to iterate over each element in the list and each character in the string elements to check if the string element contains any character from the given string.
Auxiliary Space:
The space complexity of this algorithm is O(n), where n is the length of the input list. This is because we are creating a result list to store the elements that do not contain the given character. Additionally, the recursive calls will consume some amount of memory on the call stack, but since we are not creating any new data structures in each call, the space complexity of the call stack is constant with respect to the input size.
Method 7 : using the re module to filter out the elements in the list that do not match a regular expression pattern.
steps for this method:
Import the re module.
Initialize a list of strings test_list and a string test_str.
Create a regular expression pattern pattern that matches any character from test_str.
Use the filter() function with a lambda function that matches the regular expression pattern to filter the elements from test_list.
Convert the filtered result to a list using the list() function.
Assign the filtered list back to test_list.
Python3
import re
test_list = [ '567' , '840' , '649' , '7342' ]
test_str = '1237'
pattern = re. compile ( '[{}]' . format (test_str))
filtered_list = list ( filter ( lambda x: not pattern.search(x), test_list))
test_list = filtered_list
print ( "The list after removal:" , test_list)
|
Output
The list after removal: ['840', '649']
The time complexity of this method is O(n), where n is the number of elements in the list.
The auxiliary space complexity is O(k), where k is the length of the regular expression pattern.
Last Updated :
22 Apr, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...