Sets: Advanced

Use frozensets as keys and elements

Frozensets support all the same read operations as regular sets: membership testing with the in operator, getting the length with len(), iteration with for loops, and all set operations like union, intersection, difference, and symmetric difference. The only difference is that you cannot modify a frozenset after creation.

Attempting to add or remove elements from a frozenset raises an AttributeError. This is because frozensets simply do not have the add(), remove(), discard(), pop(), or clear() methods that regular sets have. This is by design, not a bug.

key = ___([1, 2, 2, 3])
data = {key: "found"}
print(data[key])
print(___(key))

Build sets with comprehension syntax

The general syntax is {expression for item in iterable if condition}. The expression is evaluated for each item that passes the optional condition, and all unique results are collected into a set. This is often more readable and efficient than building a set with explicit loops.

Add an if clause to filter which elements are included in the resulting set. Only items for which the condition evaluates to True contribute to the result. This is equivalent to wrapping the loop body in an if statement.

The expression before the for keyword can be any transformation of the loop variable. This allows you to extract, convert, or compute derived values in a single expression.

You can use multiple for clauses to iterate over nested structures. This is useful for flattening lists of lists, processing matrices, or generating combinations. The for clauses are processed left to right, like nested loops.

Set comprehensions are ideal when you need unique values from a transformation. If duplicates might exist in your input or result, and you want each value only once, a set comprehension is cleaner than a list comprehension followed by a set() conversion.

nums = [1, 2, 2, 3, 3, 3]
result = ___{[x * 2 for x in nums___}]
print(type(result), result)

The bracket type is the only syntactic difference between a set comprehension and a list comprehension. Curly braces {} produce a set with automatic deduplication; square brackets [] produce a list that preserves every element including duplicates.

Choose sets vs lists for performance

The in operator behaves very differently for sets versus lists. This difference becomes dramatic as collection size grows.

Order matters

Lists preserve insertion order; sets do not guarantee it

Duplicates are meaningful

Lists keep all occurrences; sets eliminate duplicates

Index access needed

list[0], list[-1], list[5:10] all require ordered access

Unhashable elements

Lists can hold other lists; sets cannot hold mutable types

Append/pop from ends

Lists are optimized for stack and queue style operations

Uniqueness required

Duplicates should be automatically eliminated on insertion

Frequent membership tests

Checking "is X in the collection?" happens often in your code

Set operations needed

Union, intersection, difference operations are central to the task

Order does not matter

No need for indexing or position-based access to elements

Large collection lookups

Performance gains from O(1) lookup are significant at scale

allowed = ___(["A01", "A02", "A03"])
request = "A02"
print(request ___ allowed)
print(len(allowed))

Never modify a set while iterating over it. Adding or removing elements during iteration causes undefined behavior, typically raising a RuntimeError. This applies to all mutable collections in Python.

The comprehension approach is often cleaner because it creates a new set with the desired elements rather than modifying in place. Use .copy() when you specifically need to modify the original set.

The curly brace syntax {} creates an empty dictionary, not an empty set. To create an empty set, you must use set(). This is a common source of confusion and bugs.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

key = frozenset(set(["a", "b"]))
data = {key: 42}
print(data[key])

When creating custom classes for use in sets, you must properly implement both __hash__ and __eq__. If two objects are equal (according to __eq__), they must have the same hash value. Violating this contract causes unpredictable behavior.

The set contains only 2 users because User(1, "Alice") and User(1, "Alicia") are considered equal (same user_id). The one added later replaces the earlier one in the set.