Python Subset Operations Clearly Explained

Introduction to Python Subsets

Set A is a subset of set B if all the elements in A are also in B. Python subset syntax provides several ways to test whether one set is a subset of another. Those include the issubset() instance method, the issubset() class method, the subset operator <= (less than or equal), and the proper subset operator < (less than). Each of these options provides a slightly different capability and convenience.

Testing for a subset allows you to determine whether one collection of items exists within a larger set. An example of this is a person who has a set of desired items and wants to determine whether all those items are sold by one store. That store will be a one-stop-shop if all the desired items are a subset of the store’s inventory.

Using the issubset() Instance Method

The issubset() instance method of Python set objects checks whether all elements of the calling set are included in an iterable, which is given as an argument. It returns True if they do, and False otherwise.

Example:

set_a = {1, 2, 3}
set_b = {1, 2, 3, 4, 5}

result = set_a.issubset(set_b)
print(result)

Output:

True

In the example above, set_a is a subset of set_b since all elements of set_a are present in set_b, resulting in True.

Example:

set_a = {1, 2, 3}
set_b = {2 ,3, 4}

result = set_a.issubset(set_b)
print(result)

Output:

False

Here, set_a is not a subset of set_b because 1 is in set_a but not in set_b, leading to False.

The next example demonstrates that a set is a subset of itself since this fits the definition of a subset.

Example:

set_a = {1, 2, 3}

result = set_a.issubset(set_a)
print(result)

Output:

True

The following example demonstrates that issubset() works with other iterable types, e.g. a list.

set_a = {1, 2, 3}
lst = [1, 2, 2, 3, 4]

result = set_a.issubset(lst)
print(result)

Output:

True

In the example above, because the argument given to issubset() is a list and not a set, it can have repeated elements. And regardless of the repeated element, 2, issubset() works the same way as it does with set arguments. It returns True since all the elements of set_a can be found in lst.

Using the issubset() Class Method

Similar to the instance method, the issubset() class method allows you to check whether a set, given as the first argument, has all its elements within an iterable, given as the second.

The difference between the class method and instance method version of issubset() is that the instance method is called on a specific set object, whereas the class method includes the set object as its first parameter. Following the first argument, which must be a set, the second argument can be objects of any iterable type.

Since this version of issubset() is a class method of the set class, you call it with a set. prefix.

Example:

set_a = {1, 2, 3}
lst = [1, 1, 2, 3, 4]

result = set.issubset(set_a, lst)
print(result)

Output:

True

This achieves the same result as the previous example but using the class method.

Using the Subset Operator <=

The <= operator checks whether one iterable object on the left is a subset of another iterable one on the right. It returns True if it is and False otherwise.

Example:

set_a = {1, 2, 3}
set_b = {1, 2, 3, 4, 5}

result = set_a <= set_b
print(result)

Output:

True

In the example above, set_a is a subset of set_b, and therefore the result is True.

Unlike the issubset() instance and class methods, <= does not require a set object. It will implicitly convert any iterable objects it operates on to sets and treat them as such.

Example:

lst_a = [1, 2, 2, 3]
lst_b = [1, 2, 3, 4, 5]

result = lst_a <= lst_b
print(result)

Output:

True

In the above example, the result is True because lst_b contains all the elements in lst_a at least once. Since both lists are treated as sets by the operator, lst_b does not need to include 2 twice for lst_a to be considered its subset.

Using the Proper Subset Operator <

The < operator is the same as <= except that it checks whether one set is a proper subset of another. A proper subset means that all elements of the first set are in the second set, but the second set has at least one more element. Or in other words, a proper subset is like a regular subset, but identical sets are not allowed.

Example:

set_a = {1, 2, 3}
set_b = {1, 2, 3, 4, 5}

result = set_a < set_b
print(result)

Output:

True

In the example above, set_a is a proper subset of set_b because all its elements are in set_b and it has fewer elements.

The next example demonstrates how a proper subset differs from a regular subset.

Example:

set_a = {1, 2, 3}

result = set_a < set_a
print(result)

Output:

False

Here, the result of the < operator is False because set_a is not a proper subset of itself.

Summary & Reference for Python Subset Operations

Python subset operations allow you to determine whether one set is fully contained within another.

The issubset() instance method checks whether all elements of the calling set are present in another iterable object. It returns True if they are, False otherwise.

set_a = {1, 2, 3}
lst = [1, 2, 2, 3, 4]
result = set_a.issubset(lst)  # result --> True

The issubset() class method, an alternative to the instance method, is called directly on the set class. Its first argument must be a set, and the second can be an object of any iterable type.

set_a = {1, 2, 3}
lst = [1, 2, 2, 3, 4]
result = set.issubset(set_a, lst)  # --> True

The subset operator <= checks whether one iterable is a subset of another. It implicitly converts non-set iterables to sets before performing the comparison.

set_a = [1, 2, 3]
set_b = [1, 2, 3, 4, 5]
result = set_a <= set_b  # --> True

The proper subset operator < is similar to <= but ensures that the first set is a proper subset of the second, meaning it has fewer elements.

set_a = {1, 2, 3}
set_b = {1, 2, 3, 4, 5}
result = set_a < set_b  # --> True

set_a = {1, 2, 3}
set_b = {1, 2, 3}
result = set_a < set_b  # --> False