How to Check If All Elements Are in Another List in Python

Checking if one list is a subset of another (meaning every element in the first list exists within the second) is a fundamental operation in data validation, filtering, and set theory logic. While Python provides the simple in operator for single items, checking an entire collection requires slightly different approaches depending on your performance needs and data types.

This guide explores the most Pythonic method using all(), the high-performance method using set(), and how to handle unhashable data types.

Method 1: Using the all() Function (Pythonic)

The all() function is the most readable way to solve this problem. It iterates through the subset list and checks if each element exists in the superset list.

Basic Implementation

This method works well for smaller lists and preserves the logic of "checking every item."

subset = [2, 4, 6]
superset = [1, 2, 3, 4, 5, 6, 7]

result = all(item in superset for item in subset)

print(f"Is subset contained in superset? {result}")

Output:

Is subset contained in superset? True

Understanding the Logic

If a single element in subset is missing from superset, all() stops immediately (short-circuits) and returns False.

subset = [2, 99] # 99 is missing
superset = [1, 2, 3]

if all(item in superset for item in subset):
    print("All elements found.")
else:
    print("Some elements are missing.")

Output:

Some elements are missing.

Method 2: Using Set Operations (High Performance)

If the order of elements doesn't matter and your data consists of hashable items (strings, numbers, tuples), converting lists to sets is significantly faster.

Using issubset()

Sets allow O(1) lookups, reducing the total complexity to O(N+M).

subset_list = [10, 20]
superset_list = [10, 20, 30, 40]

is_contained = set(subset_list).issubset(set(superset_list))

is_contained_operator = set(subset_list) <= set(superset_list)

print(f"Is contained? {is_contained}")
print(f"Operator check: {is_contained_operator}")

Output:

Is contained? True
Operator check: True

Method 3: Handling Duplicates (Strict Inclusion)

Both all() and set() ignore element frequency.

• subset = [1, 1, 1]
• superset = [1, 2]

Both methods above return True because the value 1 exists in the superset. If you need to ensure that the superset has enough counts of duplicate items (e.g., you need three 1s), use collections.Counter.

from collections import Counter

subset = ['a', 'a', 'b']
superset = ['a', 'b', 'c'] # Only one 'a'

print(f"Set check: {set(subset).issubset(set(superset))}")

subset_counts = Counter(subset)
superset_counts = Counter(superset)

has_enough_items = all(superset_counts[k] >= v for k, v in subset_counts.items())

print(f"Count check: {has_enough_items}")

Output:

Set check: True
Count check: False

Common Pitfalls: Unhashable Types

Sets require elements to be "hashable" (immutable). You cannot create a set of lists or dictionaries. If your list contains mutable objects, Method 2 will crash.

Error

list_of_lists_A = [[1], [2]]
list_of_lists_B = [[1], [2], [3]]

try:
    print(set(list_of_lists_A).issubset(set(list_of_lists_B)))
except TypeError as e:
    print(f"Error: {e}")

Output:

Error: unhashable type: 'list'

Solution

Fallback to Method 1 (all()) for unhashable types.

list_of_lists_A = [[1], [2]]
list_of_lists_B = [[1], [2], [3]]

result = all(item in list_of_lists_B for item in list_of_lists_A)

print(f"Unhashable containment check: {result}")

Output:

Unhashable containment check: True

Conclusion

To check if list A is contained in list B:

1. Use set(A).issubset(set(B)) for best performance on large lists of numbers or strings.
2. Use all(x in B for x in A) for smaller lists or lists containing unhashable objects (like other lists).
3. Use collections.Counter if the frequency of duplicates matters (e.g., inventory systems).