Python | Test if all elements are present in list

Sometimes, while working with Python list, we have a problem in which we need to check for a particular list of values and want to be sure if a target list contains all the given values. This has it’s application in web development domain when required some type of filtering. Let’s discuss a way in which this task can be performed. 
Method : Using list comprehension + all() This task can be performed using the inbuilt functionality of all(). The all() can be fed with list comprehension logic to check if element of test list is present in target list and rest is done by all(). 

The target list : [6, 4, 8, 9, 10]
The test list : [4, 6, 9]
Does every element of test_list is in target_list ? : True

Time Complexity: O(n*n) where n is the number of elements in the list “test_list”. list comprehension + all() performs n*n number of operations.
Auxiliary Space: O(n), extra space is required where n is the number of elements in the list

Method #2: Using Counter() function

The target list : [6, 4, 8, 9, 10]
The test list : [4, 6, 9]
Does every element of test_list is in target_list ? : True

Method 3: Using set().issubset()

In this method, we first convert the test_list into a set, then use the issubset() function which returns true if all elements of the set are present in the target list.

The target list : [6, 4, 8, 9, 10]
The test list : [4, 6, 9]
Does every element of test_list is in target_list ? : True

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

Method 4: Using list comprehesion+recursion

In this example, list1 contains the elements [1, 2, 3, 4, 5], and list2 contains the elements [2, 4, 6]. Since not all elements in list2 are present in list1, the function returns False.

step-by-step approach:

1.Define a function called test_elements_in_list that takes two lists as arguments.

2.Use a list comprehension to iterate over each element elem in list2, and check if it is present in list1 using the in keyword. This will create a list of booleans that indicate whether each element of list2 is present in list1.

3.Use the all() function to check if all elements in present_in_list1 are True. If all elements are True, return True from the function, indicating that all elements in list2 are present in list1.

4.If any element in present_in_list1 is False, return False from the function, indicating that not all elements in list2 are present in list1.

5.Create two lists list1 and list2, and call the test_elements_in_list function with these lists as arguments.

6.Print the result of the function call using the print() function.

False

time complexity: O(n * m)

space complexity: O(n)

Method 5: Using numpy:

Algorithm:

1.Define the two lists to compare

2.Print the target list and the test list

3.Use the numpy module to convert the test list to a numpy array, and then use the numpy method in1d() to create a Boolean array that indicates whether each element of the test list is present in the target list

4.Use the numpy method all() to check whether all elements of the result array are True

5.Print the result

Output:

The target list : [6, 4, 8, 9, 10]
The test list : [4, 6, 9]
Does every element of test_list is in target_list ? : True

Time complexity:

The time complexity of the np.in1d() function is O(n log n), where n is the length of the longer of the two input lists. The all() function has a time complexity of O(n), where n is the length of the input Boolean array. Therefore, the time complexity of the overall algorithm is O(n log n), where n is the length of the longer of the two input lists.

Auxiliary Space:

The np.in1d() function creates a Boolean array of the same length as the first input list, which has a space complexity of O(n), where n is the length of the longer of the two input lists. The all() function has a space complexity of O(1), since it only needs to store the result Boolean value. Therefore, the space complexity of the overall algorithm is O(n), where n is the length of the longer of the two input lists.