In this lesson, we will be discussing the frozenset data type, which is used to represent an immutable collection of unique items.

A frozenset is similar to a set, but it is immutable, which means that its items cannot be changed once it has been created. This makes frozensets useful in situations where you need a set-like data type, but you don't want the items to be mutable. In Python, frozensets are represented using the frozenset data type.

Here's an example of how to create a frozenset:

# Create a frozenset of numbers
numbers = frozenset({1, 2, 3, 4, 5})

# Print the frozenset
print(numbers)

In this example, we create a frozenset of numbers and then print the frozenset to the console. As you can see, the frozenset contains the same items as the original set, but it is immutable, which means that we cannot add or remove items from it.

Frozenset Operations

Frozensets also support set operations, such as union, intersection, and difference. Here's an example of how to perform set operations on frozensets:

# Create two frozensets of numbers
set1 = frozenset({1, 2, 3, 4, 5})
set2 = frozenset({4, 5, 6, 7, 8})

# Perform set operations on the frozensets
union = set1.union(set2)
intersection = set1.intersection(set2)
difference = set1.difference(set2)

# Print the results
print(f"Union: {union}")
print(f"Intersection: {intersection}")
print(f"Difference: {difference}")

In this example, we create two frozensets of numbers and then perform several set operations on them. We use the union() method to compute the union of the two sets, the intersection() method to compute the intersection of the two sets, and the difference() method to compute the difference between the two sets. Finally, we print the results to the console.

Sounding familiar? Tuples vs Frozensets

Now you might be wondering... isn't literally the same thing as a Tuple? Well not quite. The main difference between tuples and frozensets is that tuples are ordered collections of items, while frozensets are unordered collections of unique items.

A tuple is a data type in Python that represents an ordered collection of items. This means that the items in a tuple are stored in a specific order, and this order is preserved when the tuple is accessed or modified. Tuples are represented using parentheses, and they can contain items of any data type, including other tuples.

On the other hand, a frozenset is a data type in Python that represents an unordered collection of unique items. This means that a frozenset cannot contain duplicate items, and the order of the items in a frozenset is not preserved. Frozensets are represented using the frozenset data type, and they can only contain items of a single data type.

Here is an example showing the differences:

# Create a tuple of numbers
tuple1 = (6, 1, 2, 1, 3, 4, 5)

# Create a frozenset of numbers
frozenset1 = frozenset({6, 1, 2, 1, 3, 4, 5})

# Print the tuple and frozenset
print(tuple1)     #           (6, 1, 2, 1, 3, 4, 5)
print(frozenset1) # frozenset({1, 2, 3, 4, 5, 6})

Here we are creating a tuple and frozen set with the exact same values, but the output is different.

Conclusion

Frozensets are an important data type to understand because they allow you to work with sets in a way that ensures that the items in the set cannot be changed.

Server Academy Members Only

Want to access this lesson? Just sign up for a free Server Academy account and you'll be on your way. Already have an account? Click the Sign Up Free button to get started..

Sign In Sign Up Free