The previous lesson ended with a question: why is looking up catalog["Faust"] practically instantaneous? The answer lives in a sibling structure of the dictionary: the set. A set is a collection with no guaranteed order, no duplicates and no associated values — just elements, like a dictionary's keys without their values. In exchange for giving up order and repetition, it offers two superpowers: checking membership at full speed and operating with the logic of set theory (union, intersection, difference), which at Papyrus will answer questions like "which members bought this month but not last month?" in a single line.

1. Creating sets (and the empty {} trap)
2. Uniqueness: duplicates vanish
3. Adding and removing elements
4. Lightning-fast membership: why in flies
5. Set operations: union, intersection, differences
6. Subsets and supersets
7. frozenset: the immutable set
8. Set comprehensions

The {} trap is historical: dictionaries arrived in Python first and kept the empty braces. Memorize it: empty set = set(), always.

Elements must be immutable (hashable), like a dict's keys: strings, numbers and tuples yes; lists and dictionaries no. And there is no indexing: genres[0] is a TypeError, because a set has no positions.

Uniqueness is not an annoying restriction: it is the star feature. The most frequent real-world use case — removing duplicates from a list — is one line:

Careful: set() does not preserve the list's original order. If order of appearance matters, there is a dict idiom you will see in the exercises.

Sets are mutable (an immutable version exists: frozenset, below):

With a list, x in some_list forces Python to compare element by element, from the start: if the list has a million entries, the worst case means a million comparisons. With a set (or a dict's keys), Python computes the element's hash — a numeric fingerprint — and jumps straight to the internal slot where it would be if it existed. One check, whether the set holds ten elements or ten million.

This is also the answer to 04-03's question: catalog["Faust"] is instantaneous because a dictionary's keys use exactly the same hash mechanism. You do not need the formal complexity theory (it will come if you ever look it up as "O(1) vs O(n)"); keep the practical rule:

Lots of "is it there or not?" checks against the same collection → turn it into a set first.

Here sets shine in their own right. Each operation exists as an operator and as a method (the method accepts any iterable; the operator demands two sets):

With Papyrus data: Ana wants to analyze member loyalty by comparing June's and July's buyers:

Five business questions, five lines, zero loops. Difference is not commutative (a - b != b - a); union, intersection and symmetric difference are.

Another natural use: each book's genres as sets, to answer "which books share a genre?":

Useful for validations: "are all the titles in the order in the catalog?" is set(order) <= set(catalog) — and yes, set(catalog) on the 04-03 dict extracts its keys.

The same relationship as tuple/list: a frozenset is a frozen set. It accepts no add() or remove(), and in exchange it is hashable — it can be a dictionary key or an element of another set:

With a regular set as a key you would get TypeError: unhashable type: 'set'. Brief and occasional use, but when you need it, nothing else takes its place.

The third comprehension in the family (list → dict → set). Syntax: braces without a colon:

• {} is not an empty set: it is a dict. The mistake gives no message — trap.add(x) will simply fail later with an AttributeError. Empty set = set().
• Expecting order: sets guarantee no iteration order. If you print a set and it "comes out shuffled", it is not a bug. For display, sorted(my_set).
• Indexing a set: s[0] raises TypeError. Without order there are no positions; if you need "the first one", you are missing a list.
• Inserting mutable elements: {["a", "b"]} raises TypeError: unhashable type: 'list'. Convert to a tuple if you need grouping.
• Confusing remove() with discard(): if absence is normal, discard(); if it is a bug, remove() (let it fail early). The same criterion as brackets vs get() on dicts.
• Deduplicating with a set when order matters: set(some_list) loses the order of appearance. The idiom that preserves it: list(dict.fromkeys(some_list)) — dicts deduplicate keys and remember insertion order.
• Tip: if you catch yourself writing nested loops to compare two lists ("the ones here that aren't there"), it was almost certainly a set operation.

1. Order audit. From the list orders = ["Hamlet", "Faust", "Hamlet", "Dracula", "Don Quixote", "Faust"], obtain: (a) the set of distinct titles ordered; (b) how many duplicate orders there were (total orders minus distinct titles); (c) using the canonical catalog from 04-03 and a set difference, which ordered titles are not in the catalog.
2. Loyalty campaign. With june = {"Luis", "Marta", "Pau", "Julia"} and july = {"Luis", "Julia", "Omar"}, compute: the members to win back (bought in June but not in July), July's newcomers, and the loyal ones from both months. Then check with a subset operator whether all the loyal ones bought in June.
3. Available genres. With the lesson's book_genres dict (The Odyssey, Hamlet, Faust) and the available set computed over the canonical catalog, build via operations and/or a comprehension the set of genres actually available today (the genres of the books with stock > 0). Hint: the union of several sets can be done with set().union(...).

Tip: name the results with business vocabulary (win_back, loyal), not mathematical vocabulary (difference, intersection): the code explains itself.

Notice: the * unpacks the sets as arguments to union() (the same * from 03-02), and the if t in book_genres protects against books with no genres on file — "Don Quixote" is available but has no entry, and without that filter there would be a KeyError.

Sets complete the trio of "curly brace" collections: you know how to create them (remembering that set() is the only spelling of the empty one), exploit automatic deduplication, and express business logic with union, intersection and differences in one line where you would previously have nested loops. You also understand why in is lightning-fast on sets and dicts — the magic of the hash — and you know frozenset for when immutability matters. At Papyrus they now deduplicate orders, validate members and compare months of sales. But in almost every example an actor has kept peeking through, one we have been using since module 1 without ever studying it seriously: the string, with its strip(), lower() and friends. The next lesson finally treats it as what it is — a sequence with superpowers of its own — and systematizes the normalization of user input that find_book() and is_valid_member() have been doing halfway.