Key Properties of Frozen Sets

• Immutable: Cannot be modified after creation
• Hashable: Can be used as dictionary keys and set elements
• Unordered: Elements have no defined order (like regular sets)
• Unique elements: No duplicates allowed
• Unindexed: Elements cannot be accessed by index

Creating a Frozen Set

Frozen sets are created using the frozenset() constructor, which takes an iterable:

1
# From a list
2
fs = frozenset([1, 2, 3])
3
print(fs)  # frozenset({1, 2, 3})
4

5
# From a string
6
chars = frozenset("hello")  # frozenset({'h', 'e', 'l', 'o'})
7

8
# From a range
9
numbers = frozenset(range(5))  # frozenset({0, 1, 2, 3, 4})
10

11
# Empty frozen set
12
empty = frozenset()
13
print(empty)  # frozenset()

Note

Like regular sets, frozen sets automatically remove duplicates and are unordered. The order of elements when printing may vary.

Immutability and Hashability

The key advantage of frozen sets is their immutability, which makes them hashable:

1
fs = frozenset([1, 2, 3])
2

3
# Frozen sets are hashable
4
print(hash(fs))  # Some hash value
5

6
# Can be used as dictionary keys
7
d = {fs: "value"}
8
print(d[fs])  # value
9

10
# Can be used as set elements
11
set_of_frozen_sets = {frozenset([1, 2]), frozenset([3, 4])}
12
print(set_of_frozen_sets)  # {frozenset({1, 2}), frozenset({3, 4})}

Tip

Regular sets cannot be used as dictionary keys or set elements because they are mutable and therefore unhashable. Frozen sets solve this limitation.

Checking Membership

Elements can be checked for existence in a frozen set using the in and not in operators:

1
fs = frozenset([1, 2, 3, 4, 5])
2

3
print(3 in fs)  # True
4
print(10 in fs)  # False
5
print(2 not in fs)  # False

Looping Over a Frozen Set

Frozen sets can be iterated over using a for loop:

1
fs = frozenset([1, 2, 3, 4, 5])
2

3
for element in fs:
4
    print(element)

Frozen Set Operations

Frozen sets support all set operations that return new sets (since they cannot be modified in place):

• union(iterable1, iterable2, ...): Returns a new frozen set containing all elements from the frozen set and all given iterables $X \cup S \cup T \cup \ldots$.
• intersection(iterable1, iterable2, ...): Returns a new frozen set containing only elements that are common to the frozen set and all given iterables $X \cap S \cap T \cap \ldots$.
• difference(iterable1, iterable2, ...): Returns a new frozen set containing elements that are in the frozen set but not in any of the given iterables $X - S - T - ...$.
• symmetric_difference(iterable): Returns a new frozen set containing elements that are in either the frozen set or the iterable, but not in both $X \triangle S$.
• issubset(iterable): Returns True if all elements of the frozen set are in the given iterable.
• issuperset(iterable): Returns True if all elements of the given iterable are in the frozen set.
• isdisjoint(iterable): Returns True if the frozen set and the given iterable have no elements in common (their intersection is empty).

1
fs1 = frozenset([1, 2, 3])
2
fs2 = frozenset([3, 4, 5])
3
result = fs1.union(fs2)
4
print(result)  # frozenset({1, 2, 3, 4, 5})
5

6
# Can also use the | operator
7
result = fs1 | fs2  # frozenset({1, 2, 3, 4, 5})

1
fs1 = frozenset([1, 2, 3, 4])
2
fs2 = frozenset([3, 4, 5, 6])
3
result = fs1.intersection(fs2)
4
print(result)  # frozenset({3, 4})
5

6
# Can also use the & operator
7
result = fs1 & fs2  # frozenset({3, 4})

1
fs1 = frozenset([1, 2, 3, 4, 5])
2
fs2 = frozenset([3, 4])
3
result = fs1.difference(fs2)
4
print(result)  # frozenset({1, 2, 5})
5

6
# Can also use the - operator
7
result = fs1 - fs2  # frozenset({1, 2, 5})

1
fs1 = frozenset([1, 2, 3, 4])
2
fs2 = frozenset([3, 4, 5, 6])
3
result = fs1.symmetric_difference(fs2)
4
print(result)  # frozenset({1, 2, 5, 6})
5

6
# Can also use the ^ operator
7
result = fs1 ^ fs2  # frozenset({1, 2, 5, 6})

1
fs1 = frozenset([1, 2, 3])
2
fs2 = frozenset([1, 2, 3, 4, 5])
3
print(fs1.issubset(fs2))  # True
4

5
# Can also use the <= operator
6
print(fs1 <= fs2)  # True

1
fs1 = frozenset([1, 2, 3, 4, 5])
2
fs2 = frozenset([1, 2, 3])
3
print(fs1.issuperset(fs2))  # True
4

5
# Can also use the >= operator
6
print(fs1 >= fs2)  # True

1
fs1 = frozenset([1, 2, 3])
2
fs2 = frozenset([4, 5, 6])
3
print(fs1.isdisjoint(fs2))  # True
4

5
fs3 = frozenset([3, 4, 5])
6
print(fs1.isdisjoint(fs3))  # False (they share element 3)

Why Use Frozen Sets?

1
# Representing edges in a graph
2
edges = {
3
    frozenset([1, 2]): "edge_1_2",
4
    frozenset([2, 4]): "edge_2_4",
5
    frozenset([1, 3]): "edge_1_3"
6
}
7

8
print(edges[frozenset([1, 2])])  # edge_1_2

1
# Graph representation: set of edges (each edge is a frozen set)
2
graph = {
3
    frozenset([1, 2]),
4
    frozenset([2, 4]),
5
    frozenset([1, 3])
6
}
7

8
print(graph)  # {frozenset({1, 2}), frozenset({2, 4}), frozenset({1, 3})}

Exercises

1
n = int(input())
2
elements = []
3
for i in range(n):
4
    elements.append(input())
5
fs = frozenset(elements)
6
print(fs)

1
d = {
2
    frozenset([1, 2]): "pair_1_2",
3
    frozenset([2, 3]): "pair_2_3",
4
    frozenset([1, 3]): "pair_1_3"
5
}
6
print(d)

1
graph = {
2
    frozenset([1, 2]),
3
    frozenset([2, 3]),
4
    frozenset([3, 4]),
5
    frozenset([1, 4])
6
}
7
print(graph)

1
n = int(input())
2
d = {}
3
for i in range(n):
4
    first = int(input())
5
    second = int(input())
6
    key = frozenset([first, second])
7
    d[key] = f"edge_{first}_{second}"
8
print(d)

1
n = int(input())
2
unique_pairs = set()
3
for i in range(n):
4
    first = int(input())
5
    second = int(input())
6
    pair = frozenset([first, second])
7
    unique_pairs.add(pair)
8
print(len(unique_pairs))

1
n = int(input())
2
graph = set()
3
for i in range(n):
4
    v1 = int(input())
5
    v2 = int(input())
6
    edge = frozenset([v1, v2])
7
    graph.add(edge)
8

9
print(graph)
10

11
edge_to_check = frozenset([1, 2])
12
if edge_to_check in graph:
13
    print("Yes")
14
else:
15
    print("No")