Python | Remove List elements containing given String character

Last Updated : 22 Apr, 2023

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

# Python3 code to demonstrate working of 
# Remove List elements containing String character
# Using loop

# initializing list
test_list = ['567', '840', '649', '7342']

# initializing string 
test_str = '1237'

# printing original list
print(&quot;The original list is : &quot; + str(test_list))

# Remove List elements containing String character
# Using loop
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)

# printing result 
print(&quot;The list after removal : &quot; + 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

# Python3 code to demonstrate working of 
# Remove List elements containing String character
# Using list comprehension

def check_pres(sub, test_str):
    for ele in sub:
        if ele in test_str:
            return 0
    return 1
    
# initializing list
test_list = ['567', '840', '649', '7342']

# initializing string 
test_str = '1237'

# printing original list
print(&quot;The original list is : &quot; + str(test_list))

# Remove List elements containing String character
# Using list comprehension
res = [ele for ele in test_list if check_pres(ele, test_str)]

# printing result 
print(&quot;The list after removal : &quot; + 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

# Python3 code to demonstrate working of
# Remove List elements containing String character
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


# initializing list
test_list = ['567', '840', '649', '7342']

# initializing string
test_str = '1237'

# printing original list
print("The original list is: " + str(test_list))

# Remove List elements containing String character
# Using list comprehension
res = [ele for ele in test_list if check_pres(ele, test_str)]

# printing result
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

#Python3 code to demonstrate working of
#Remove List elements containing String character
#Using filter() and lambda function
#initializing list
test_list = ['567', '840', '649', '7342']

#initializing string
test_str = '1237'

#printing original list
print("The original list is : " + str(test_list))

#Remove List elements containing String character
#Using filter() and lambda function
res = list(filter(lambda x: all(y not in test_str for y in x), test_list))

#printing result
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

# initialize a list of strings
test_list = ['567', '840', '649', '7342']

# initialize a string
test_str = '1237'

# print the original list
print("The original list is:", test_list)

# remove elements from the list that contain any character from test_str
for elem in test_list[:]:
    if any(char in elem for char in test_str):
        test_list.remove(elem)

# print the result
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

# Python3 code to demonstrate working of
# Remove List elements containing String character
# Using recursive method
def remove_elements(test_list, test_str):
    if not test_list: # base case
        return []
    elif any(ele in test_str for ele in test_list[0]): # check if element contains string character
        return remove_elements(test_list[1:], test_str)
    else:
        return [test_list[0]] + remove_elements(test_list[1:], test_str)

# initializing list
test_list = ['567', '840', '649', '7342']

# initializing string
test_str = '1237'

# printing original list
print("The original list is : " + str(test_list))

# Remove List elements containing String character
# Using recursive method
res = remove_elements(test_list, test_str)

# printing result
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

# initialize a list of strings
test_list = ['567', '840', '649', '7342']

# initialize a string
test_str = '1237'

# create a regular expression pattern that matches any character from test_str
pattern = re.compile('[{}]'.format(test_str))

# filter out elements in test_list that do not match the pattern
filtered_list = list(filter(lambda x: not pattern.search(x), test_list))

# assign the filtered list back to test_list
test_list = filtered_list

# print the result
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.

manjeet_04

Improve

Article Tags :

Python | Remove List elements containing given String character

Explore

Python Fundamentals

Python Data Structures

Advanced Python

Data Science with Python

Web Development with Python

Python Practice