Python frozenset() Tutorial (With Examples)

In Python, the frozenset() is a built-in function that allows you to create an immutable version of a set. A set is a collection of unique elements, and a frozenset is a similar collection but with the key distinction that it cannot be modified after creation. This immutability makes frozensets useful in situations where you need a collection of items that should remain constant throughout the program’s execution. In this tutorial, we will explore the usage of frozenset() in detail, providing explanations and examples to help you grasp its concept effectively.

Table of Contents

1. Introduction to frozenset()
2. Creating frozenset Objects

• Using frozenset() constructor
• Creating from an iterable

1. Properties of frozenset()
2. Operations on frozenset()

• Accessing elements
• Mathematical operations
• Membership testing

1. Advantages of frozenset()
2. Examples of frozenset()

• Example 1: Creating and Using frozenset
• Example 2: Set Operations with frozenset

1. Conclusion

1. Introduction to frozenset()

A set in Python is an unordered collection of unique elements. It is denoted by curly braces {} and supports various set operations like union, intersection, and difference. However, sometimes you might need a set-like object that is immutable, meaning its contents cannot be changed once created. This is where frozenset() comes into play.

The frozenset() function returns an immutable frozenset object. Being immutable, a frozenset is hashable, which makes it suitable for use as a key in dictionaries and as an element in other sets.

2. Creating frozenset Objects

Using frozenset() Constructor

The primary way to create a frozenset is by using the frozenset() constructor. This constructor accepts an iterable (such as a list, tuple, or another set) as its argument and returns a new frozenset object containing the elements from the iterable.

# Creating a frozenset using the constructor
numbers = frozenset([1, 2, 3, 4, 5])
print(numbers)  # Output: frozenset({1, 2, 3, 4, 5})

Creating from an Iterable

You can also create a frozenset directly from an iterable without using the frozenset() constructor. This is possible because frozenset is an iterable itself.

# Creating a frozenset from an iterable
names = ['Alice', 'Bob', 'Charlie']
names_frozen = frozenset(names)
print(names_frozen)  # Output: frozenset({'Alice', 'Bob', 'Charlie'})

3. Properties of frozenset()

• Immutability: Once a frozenset is created, its elements cannot be added, removed, or modified. This makes it suitable for cases where you need a constant collection of items.
• Hashability: Frozensets are hashable, meaning they have a fixed hash value throughout their lifetime. This property makes them usable as keys in dictionaries and elements in other sets.

4. Operations on frozenset()

Accessing Elements

Since frozensets are similar to sets, you can access their elements using iteration or by checking for membership.

# Accessing elements in a frozenset
colors = frozenset(['red', 'green', 'blue'])
for color in colors:
    print(color)

print('red' in colors)  # Output: True
print('yellow' in colors)  # Output: False

Mathematical Operations

Frozensets support various mathematical operations like union, intersection, and difference, just like regular sets.

set1 = frozenset([1, 2, 3, 4])
set2 = frozenset([3, 4, 5, 6])

# Union of two frozensets
union = set1 | set2
print(union)  # Output: frozenset({1, 2, 3, 4, 5, 6})

# Intersection of two frozensets
intersection = set1 & set2
print(intersection)  # Output: frozenset({3, 4})

# Difference of two frozensets
difference = set1 - set2
print(difference)  # Output: frozenset({1, 2})

Membership Testing

You can use the in operator to check if an element is present in a frozenset.

languages = frozenset(['Python', 'Java', 'C++'])

print('Python' in languages)  # Output: True
print('Ruby' in languages)    # Output: False

5. Advantages of frozenset()

The use of frozensets offers several advantages:

• Immutability: Frozensets ensure that the data they contain remains constant throughout the program. This can be crucial in scenarios where you want to prevent accidental modifications.
• Hashability: The immutability and hashability of frozensets make them suitable for use as keys in dictionaries or as elements in other sets.
• Consistency: Since the elements of a frozenset cannot change, they maintain a consistent state during the program’s execution.

6. Examples of frozenset()

Example 1: Creating and Using frozenset

Let’s consider an example where we want to create a list of favorite foods for multiple users. Since these lists should remain constant, we’ll use frozensets.

# Creating frozensets for favorite foods
user1_favorites = frozenset(['pizza', 'pasta', 'ice cream'])
user2_favorites = frozenset(['sushi', 'ramen', 'tempura'])

# Storing the frozensets in a dictionary
favorite_foods = {
    'user1': user1_favorites,
    'user2': user2_favorites
}

# Accessing and printing favorite foods
for user, foods in favorite_foods.items():
    print(f"{user}'s favorite foods: {', '.join(foods)}")

Example 2: Set Operations with frozenset

In this example, we’ll demonstrate how to perform set operations using frozensets.

def common_elements(set1, set2):
    return set1 & set2

def unique_elements(set1, set2):
    return (set1 - set2) | (set2 - set1)

# Creating frozensets for two groups
group1 = frozenset([1, 2, 3, 4])
group2 = frozenset([3, 4, 5, 6])

# Finding common and unique elements
common = common_elements(group1, group2)
unique = unique_elements(group1, group2)

print("Common elements

:", common)
print("Unique elements:", unique)

7. Conclusion

In this tutorial, you’ve learned about the frozenset() function in Python, which allows you to create immutable sets. We discussed how to create frozensets using the constructor and from iterables, as well as explored their properties and various operations. Frozensets can be a powerful tool when you need collections that should not change after creation. They maintain immutability, hashability, and consistency, making them useful in various programming scenarios. By incorporating frozensets into your Python programs, you can ensure the integrity of your data and make your code more robust.