Introduction: frozenset in Python
Sometimes you may need a collection of unique values that should remain unchanged after creation. In such cases, Python frozenset is useful because it creates a fixed set of elements.
Definition: A frozenset is an immutable version of a normal set. Once created, its elements cannot be added, removed, or updated.
Like regular sets, frozensets store only unique values. They are commonly used when data should remain constant throughout the program.
You can see a quick example to understand how Python frozenset creates an immutable set from an iterable.
You can also explore the common use cases to learn where Python frozenset is used in real programs.
Before exploring practical examples and real-world use cases, it is important to understand the syntax and working behavior of the Python frozenset() function.
See how frozenset compares with regular sets in the Python Sets explained guide.
Syntax of Python frozenset
Before using frozenset in real programs, it is helpful to understand its basic syntax.
Syntax
frozenset(iterable)Parameters
| Parameter | Description |
|---|---|
| iterable | Any iterable object like list, tuple, string, or set |
Return Value
| Returns | Description |
|---|---|
| frozenset object | Returns an immutable set object containing unique values from the given iterable. |
Quick Example
The following example creates a frozenset from a list.
numbers = frozenset([1, 2, 3, 4])
print(numbers)
# Output (order may vary):
frozenset({1, 2, 3, 4})
The list values are converted into a frozenset. Once created, the elements cannot be added, removed, or modified.
How frozenset Works
- The
frozenset()function creates an immutable version of a set. - It accepts an iterable such as a list, tuple, string, or another set.
- Duplicate values are removed automatically, just like a normal set.
- After creation, elements cannot be added, removed, or updated.
- Because it is immutable, a frozenset can be used in situations where a regular set cannot.
Why Use frozenset in Python
Normal sets are mutable, which means they can be changed anytime. In some situations, this is not desirable.
Python frozenset is useful when:
- Values should not be modified accidentally
- A fixed set of constants is needed
- A set needs to be used as a dictionary key
- Nested sets are required
- Safer data handling is needed
Python frozenset Examples
The following examples show how frozenset works with numbers, strings, sets, and real-world data.
Note: The order of elements displayed in frozenset outputs is not guaranteed and may vary.
Simple Level Examples
Example 1: Create a Basic frozenset
numbers = frozenset([1, 2, 3, 4])
print(numbers)
# Output (order may vary):
frozenset({1, 2, 3, 4})Explanation: Creates an immutable frozenset containing four unique numbers.
Example 2: Remove Duplicate Values
values = frozenset([10, 10, 20, 30])
print(values)
# Output (order may vary):
frozenset({10, 20, 30})Explanation: Duplicate values are removed automatically.
Example 3: Create frozenset from a String
letters = frozenset("python")
print(letters)
# Output (order may vary):
frozenset({'p', 'y', 't', 'h', 'o', 'n'})Explanation: Each unique character becomes an element in the frozenset.
Example 4: Check Membership
colors = frozenset(["red", "blue", "green"])
print("red" in colors)
#Output:
TrueExplanation: Checks whether a value exists inside the frozenset.
Medium Level Examples
These examples show how frozenset behaves in slightly more practical situations.
Example 5: Attempt to Add an Element
numbers = frozenset([1, 2, 3])
numbers.add(4)
#Output:
AttributeError: 'frozenset' object has no attribute 'add'Explanation: frozenset cannot be modified after creation.
Example 6: Use frozenset as a Dictionary Key
data = {
frozenset([1, 2]): "Group A",
frozenset([3, 4]): "Group B"
}
print(data[frozenset([1, 2])])
#Output:
Group AExplanation: frozenset can be used as a dictionary key because it is immutable.
Example 7: Create Nested Sets Using frozenset
inner1 = frozenset([1, 2])
inner2 = frozenset([3, 4])
outer = {inner1, inner2}
print(outer)
# Output (order may vary):
{frozenset({3, 4}), frozenset({1, 2})}Explanation: Normal sets cannot be placed inside another set, but frozenset can.
Advanced Level Examples
The following examples demonstrate practical ways to use frozenset in real-world applications.
Example 8: Store Fixed User Roles
roles = frozenset(["admin", "editor", "viewer"])
print(roles)
# Output (order may vary):
frozenset({'admin', 'editor', 'viewer'})Explanation: Useful when user roles should remain unchanged throughout the program.
Example 9: Compare Two frozensets
a = frozenset([1, 2, 3])
b = frozenset([2, 3, 4])
print(a & b)
# Output (order may vary):
frozenset({2, 3})Explanation: frozenset supports set operations such as intersection while remaining immutable.
Example 10: Real-World Example – Unique Allowed File Extensions
allowed_extensions = frozenset(["jpg", "png", "gif", "webp"])
print("png" in allowed_extensions)
# Output:
TrueExplanation: Useful when a program should only allow a fixed set of file formats.
Use Cases: When to Use Python frozenset
Below are some common situations where frozenset can be useful:
- Creating fixed collections of values
- Using sets as dictionary keys
- Creating nested sets
- Preventing accidental data modification
- Storing constants like roles, permissions, or categories
- Performing safe set operations on unchangeable data
Key Takeaways: Python frozenset
Before wrapping up, here are the most important points to remember about Python frozenset:
- frozenset is an immutable version of a normal set
- Duplicate values are removed automatically
- Elements cannot be added or removed after creation
- frozenset can be used as a dictionary key
- Nested sets are possible with frozenset
- Most set operations like union and intersection still work