Python Set issuperset: Checking Set Containment
Python's set.issuperset() checks whether one set contains every element of another. See how it compares with the >= and > operators, practical use cases, and edge cases.

Use set.issuperset() to check whether one set contains every element of another. The method returns True when every element of the argument is present in the set, and False otherwise.
skills = {'python', 'sql', 'git'}
required = {'python', 'git'}
print(skills.issuperset(required)) # True
print(required.issuperset(skills)) # FalseThe second call returns False because skills contains 'sql', which is missing from required. The relationship is non-strict: a set is always considered a superset of itself.
Method Form vs Operator
Python offers two equivalent ways to express a superset check: the method call and the >= operator.
a.issuperset(b)
a >= bThe difference is in what the right-hand side may be. The operator requires b to be a set or frozenset; passing a list raises TypeError. The method accepts any iterable:
a = {1, 2, 3}
print(a.issuperset([1, 2])) # TrueThis matters when the data you are checking arrives as a list from a database query, an API response, or a file parser. The method form avoids an explicit conversion step.
| Expression | Accepts any iterable | Allows equality | Returns True when |
|---|---|---|---|
a.issuperset(b) | Yes | Yes | Every element of b is in a |
a >= b | No, set only | Yes | Every element of b is in a |
a > b | No, set only | No | Every element of b is in a and a != b |
Strict vs Non-Strict Superset
The > operator tests for a proper superset. It requires that a contain every element of b and that the two sets not be equal.
a = {1, 2, 3}
b = {1, 2, 3}
c = {1, 2}
print(a.issuperset(b)) # True
print(a >= b) # True
print(a > b) # False, because a == b
print(a > c) # TrueUse > when equality must be excluded, for example when checking whether a new permission set strictly extends an existing one. For most containment checks, >= or issuperset() is the correct choice because they treat equal sets as a valid superset relationship.
Practical Use Cases
Permission and Access Checks
required_permissions = {'read', 'write'}
user_permissions = {'read', 'write', 'delete'}
if user_permissions.issuperset(required_permissions):
print('User can proceed')The check reads naturally: the user's permission set must be a superset of the required permissions.
Test Assertions
def test_response_contains_expected_fields():
response_fields = set(api_response.keys())
expected_fields = {'id', 'name', 'status'}
assert response_fields.issuperset(expected_fields)This assertion fails when the API omits a required field and does not fail when the response contains additional fields, which is usually the desired behavior for API contract tests.
Configuration Validation
def validate_config(provided, defaults):
if not provided.issuperset(defaults):
missing = defaults - provided
raise ValueError(f'Missing configuration keys: {missing}')Combining issuperset with set difference gives both the boolean check and the diagnostic information about what is missing.
Relationship with issubset
For two sets, a.issuperset(b) is logically identical to b.issubset(a). The two methods test the same relationship from opposite directions. Choose the one that matches how you think about the problem. If the sentence in your head is "all required elements are present in the candidate set," use issuperset. If it is "the candidate is fully contained in the reference set," use issubset. Both perform the same underlying hash lookups, so there is no performance reason to prefer one over the other.
Performance Characteristics
The average-case check is O(len(other)). Each element of the argument is looked up in the receiver's hash table, and hash lookups are constant time on average. The cost therefore scales with the size of the argument, not the size of the receiver.
Keep the direction of the check explicit:
# Checks whether large contains every element of small:
large.issuperset(small)
# Checks the opposite relationship:
small.issuperset(large)If the relationship you need is "does large contain every element of small?", pass small as the argument. That direction is also cheaper when small is much smaller than large, although the difference is usually negligible outside hot code paths.
Common Mistakes and Edge Cases
Empty Set Argument
print({1, 2, 3}.issuperset(set())) # TrueThe empty set is a subset of every set, so issuperset always returns True when the argument is empty. This is rarely a bug, but it can surprise developers who expect an empty argument to produce False.
Equal Sets
issuperset returns True when the two sets are equal. If your business logic requires a strict superset, the > operator is the correct tool.
Confusing issuperset with issubset
a = {1, 2, 3}
b = {1, 2}
print(a.issuperset(b)) # True - a contains all of b
print(a.issubset(b)) # False - a is not contained in bThe two methods are easy to mix up because both names describe the relationship in terms of the argument. Reading the method name as "this set is a superset of the argument" clarifies the direction.
When issuperset Is Not the Right Tool
issuperset answers a yes-or-no question. When you need more information, other set operations are more direct.
To find which elements are missing, use set difference:
missing = required - providedTo check whether two sets share at least one element, use isdisjoint:
has_overlap = not provided.isdisjoint(required)When the data cannot be converted to a set without losing order or duplicate information, a generator expression over the original container may be more appropriate:
all(x in container for x in required)This works on any container that supports membership tests and avoids converting either collection to a set, but it is O(len(required) * lookup_cost), where the lookup cost is O(1) for sets and O(n) for lists. For small inputs the difference rarely matters; for large lists, converting to a set first is usually faster.
Try matching browser tools
All toolsSmall utilities that fit Python work — they run entirely in this browser tab, so nothing you paste leaves your device.
Related Python guides
All Python guidesPython iter(): How the Built-in Function Works
Explains Python's iter() built-in: how it creates iterators, the two-argument sentinel form, custom iterator classes, and common edge cases.
Python Pika: Queues, Exchanges, Routing Keys, and Acknowledgements
Learn how to use Python's Pika client with RabbitMQ: declare queues and exchanges, publish with routing keys, consume messages, and handle acknowledgements reliably.
Python Kafka: kafka-python vs Confluent Client
python kafka python vs confluent kafka: Compare kafka-python and Confluent Kafka Python clients: API differences, performance, feature coverage, and when to choose eac...
Python Kafka Offsets, Partitions, and Manual Commits
Learn how Kafka offsets and partitions work and how to manually commit offsets in Python consumers with kafka-python and confluent-kafka. Covers sync vs async commits, rebalances, and seeking.
More in Python
All Python guidesThe guides filed next to this one in Python, in library order.