# Python Set issubset()

Rate this post

Python’s `set.issubset(set)` returns `True` if all elements of this set are members of the specified set argument. It determines whether the set on which the method is called is the subset of the specified set.

Here’s a minimal example that checks whether sets `s` is a subset of `t`:

```>>> s = {'Alice', 'Bob'}
>>> t = {'Alice', 'Bob', 'Carl', 'Liz'}
>>> s.issubset(t)
True```

Another minimal Harry Potter example:

```>>> hogwarts = {'Ron', 'Harry', 'Hermione', 'Dumbledore', 'Parvati', 'Malfoy'}
>>> gryffindors = {'Ron', 'Harry', 'Hermione'}
>>> gryffindors.issubset(hogwarts)
True```

## Syntax

Let’s dive into the formal syntax of the `set.issubset()` method.

`set.issubset(set)`

## Return Value of set.issubset()

The return value of `set.issubset()` is a Boolean whether the set is the subset of the set defined as an argument.

There are some subtleties you need to understand regarding the set subset method. Let’s dive into them by example!

```>>> {'Alice'}.issubset({'Alice', 'Bob'})
True```

? Can you also pass a list as an argument to the `set.issubset()` method? The answer is yes—the method takes any iterable.

```>>> {'Alice'}.issubset(['Alice', 'Bob'])
True```

A set is the subset of itself.

```>>> s = {1, 2, 3}
>>> s.issubset(s)
True```

This also means that two empty sets are the subsets of each other.

```>>> set().issubset(set())
True```

In fact, the empty set is a subset of every other set.

```>>> set().issubset({1, 2, 3})
True```

Can we pass multiple set arguments into the `set.issubset()` method? No! It only takes one argument.

```>>> {1, 2, 3}.issubset({1, 2}, {3})
Traceback (most recent call last):
File "<pyshell#18>", line 1, in <module>
{1, 2, 3}.issubset({1, 2}, {3})
TypeError: issubset() takes exactly one argument (2 given)```

To fix this `TypeError`, pass only one set argument into the `set.issubset()` method.

## What is the Time Complexity of set.issubset() in Python?

The worst-case runtime complexity of the `set.issubset()` method for a set with n elements and a set argument with m elements is O(n) because you need to check for each set element whether it’s a member of the set argument.

You can see this in the following simple experiment where we run the set method multiple times for increasing set sizes:

I ran this experiment on my Acer Aspire 5 notebook (I know) with Intel Core i7 (8th Gen) processor and 16GB of memory. Here’s the code of the experiment:

```import matplotlib.pyplot as plt
import time

sizes = [i * 10**5 for i in range(50)]
runtimes = []

for size in sizes:
t = set(range(size))
s = set(range(0, size, 2))

# Start track time ...
t1 = time.time()
s.issubset(t)
t2 = time.time()
# ... end track time

runtimes.append(t2-t1)

plt.plot(sizes, runtimes)
plt.ylabel('Runtime (s)')
plt.xlabel('Set Size')

plt.show()
```

## Other Python Set Methods

All set methods are called on a given set. For example, if you created a set `s = {1, 2, 3}`, you’d call `s.clear()` to remove all elements of the set. We use the term “this set” to refer to the set on which the method is executed.