2.10. Sets#

A set is an unordered collection of unique items. Adding a value that is already present has no effect; iteration yields each value exactly once. Sets are the right tool when membership and de-duplication matter, and ordering does not.

2.10.1. Creating a set#

Use curly braces for a non-empty set, or set() for an empty one:

colours = {"red", "green", "blue"}
empty = set()

The braces look like a dict literal; {} on its own is an empty dict, not an empty set – one of Python’s historical accidents. Use set() for the empty case.

set() also builds a set from any iterable, which is the standard way to drop duplicates from a sequence:

nums = [1, 2, 2, 3, 1, 4]
unique = set(nums)
print(unique)

Output:

{1, 2, 3, 4}

The print order may vary – sets do not promise to iterate in any particular order.

2.10.2. Set vs dict#

Sets and dicts both store unique items in a hash table. What each item carries with it is the difference:

  • A dict stores key-value pairs. Looking up a key returns its value.

  • A set stores just the items. Looking up an item tells you whether it is there.

The choice between the two is about whether the value alongside each item means anything:

  • Reach for a set when no value belongs next to each item – you only care whether the item is present, or you are combining groups of unique items with union / intersection.

  • Reach for a dict when each item is paired with data the lookup is meant to retrieve – a config map, a cache, a counter keyed by name.

The two types share a lot of surface syntax, which is where most of the confusion comes from. The differences in one block:

set

dict

holds

unique items

unique keys, each with a value

populated literal

{1, 2, 3}

{"a": 1, "b": 2}

empty literal

set()

{}

membership test

x in s

k in d (keys only)

fetch a value

n/a

d[k]

add an item

s.add(x)

d[k] = v

iterate

yields items

yields keys (use d.items() for pairs)

The asymmetry between the populated and empty literals is the gotcha worth calling out:

  • Braces with items in them – {1, 2, 3} – are a set literal; braces with key-value pairs – {"a": 1} – are a dict literal. The parser tells them apart by what is inside.

  • Braces with nothing inside – {} – are an empty dict, not an empty set. Dicts came first; the empty literal belongs to them. An empty set has no braces literal at all and must be written set().

A common pattern when only the keys of a dict are ever read is to switch to a set – it makes the intent obvious and trims the unused values out of memory.

2.10.3. Adding and removing#

s = {1, 2, 3}
s.add(4)
s.discard(99)            # silent: 99 not in s
s.remove(2)
print(s)

Output:

{1, 3, 4}

2.10.4. Membership#

The in operator tests for membership. On a set it is roughly constant time regardless of size – which is the main reason to choose a set over a list when you only need to ask “is this value in there”:

if "red" in colours:
    print("colour is allowed")

A list with the same contents would scan from the start each time, which is fine for ten items but slow for ten thousand.

2.10.5. Set operations#

Two sets can be combined with the usual mathematical operations. Each has both an operator form and a method form:

  • a | b or a.union(b) – everything in either set.

  • a & b or a.intersection(b) – only what appears in both.

  • a - b or a.difference(b) – in a but not in b.

  • a ^ b or a.symmetric_difference(b) – in one but not both.

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
print(a | b)
print(a & b)
print(a - b)
print(a ^ b)

Output:

{1, 2, 3, 4, 5, 6}
{3, 4}
{1, 2}
{1, 2, 5, 6}

The operator forms are read-only; the method forms accept any iterable on the right, not just another set (a.union([5, 6])). Pick whichever reads better in context.

2.10.6. What can go in a set#

Set elements must be hashable – the same constraint as dict keys. int, float, str, bool, bytes, and tuple (when its contents are themselves hashable) all work. list and dict do not; trying to add one raises TypeError.

2.10.7. frozenset#

A regular set is mutable: every call to add / remove / discard changes the object in place. That mutability disqualifies it from being hashable, so a set cannot be used as a dict key or as a member of another set.

frozenset is the immutable counterpart. It has the same lookups and operators (in, |, &, -, ^) as set, but no add / remove and no methods that mutate. Because nothing can ever change its contents, the hash of a frozenset is well-defined – so it is hashable:

primary = frozenset({"red", "green", "blue"})
secondary = frozenset({"yellow", "purple", "orange"})

palettes = {
    primary: "RGB",
    secondary: "mixed",
}

print(palettes[primary])

Output:

RGB

Construct a frozenset from any iterable – frozenset() for the empty case, frozenset(some_set) to take an immutable snapshot of an existing set:

snapshot = frozenset(s)         # immutable copy of s
s.add("new")                    # snapshot does not change

Two common reasons to reach for it:

  • Use as a dict key or set member. Anywhere a single value cannot capture what you need, a frozenset of values can – “the set of features supported by this driver”, “the set of pins this profile uses”.

  • Lock down a constant. A module-level frozenset of allowed names cannot be accidentally mutated by a caller; a regular set can. Prefer frozenset for anything that is meant to be read-only after construction.