What is frozenset?
frozenset is an immutable collection type in Python. It has most of the characteristics of a normal set, but cannot be modified once created. This immutability allows frozenset to act as a key to a dictionary or element of other collections.
The main differences between frozenset vs set
Variability:
- set is mutable (mutable)
- Frozenset is immutable (immutable)
Supported operations:
- Set supports modification operations such as adding, deleting, etc.
- frozenset only supports non-modified operations (such as query, calculation intersection, etc.)
As a container element:
- set cannot be used as a key to a dictionary or as an element of another collection
- frozenset can be used as a key to a dictionary or as an element of another collection
Create a frozenset
1. Basic creation method
# Create from the listfs1 = frozenset([1, 2, 3, 4, 5])
print(fs1) # Output: frozenset({1, 2, 3, 4, 5})
# Create from a tuplefs2 = frozenset((1, 2, 3))
print(fs2) # Output: frozenset({1, 2, 3})
# Create from a stringfs3 = frozenset('hello')
print(fs3) # Output: frozenset({'h', 'e', 'l', 'o'})
# Create an empty frozensetfs4 = frozenset()
print(fs4) # Output: frozenset()2. Create from other collections
# Create from setregular_set = {1, 2, 3}
fs = frozenset(regular_set)
print(fs) # Output: frozenset({1, 2, 3})
# Create from a dictionary (using only keys)dict_keys = frozenset({'a': 1, 'b': 2}.keys())
print(dict_keys) # Output: frozenset({'a', 'b'})Operation of frozenset
1. Supported operations
# Create two frozensetsfs1 = frozenset([1, 2, 3, 4])
fs2 = frozenset([3, 4, 5, 6])
# Calculate intersectionintersection = fs1 & fs2
print(f"Intersection: {intersection}") # Output: frozenset({3, 4})
# Calculate convergenceunion = fs1 | fs2
print(f"Collect: {union}") # Output: frozenset({1, 2, 3, 4, 5, 6})
# Calculate the difference setdifference = fs1 - fs2
print(f"Difference set: {difference}") # Output: frozenset({1, 2})
# Calculate symmetric difference setssymmetric_diff = fs1 ^ fs2
print(f"对称Difference set: {symmetric_diff}") # Output: frozenset({1, 2, 5, 6})
# Check if the element existsprint(1 in fs1) # Output: Trueprint(5 in fs1) # Output: False
# Get the number of elementsprint(len(fs1)) # Output: 42. Unsupported operations
fs = frozenset([1, 2, 3])
try:
(4) #Error: Frozenset has no add methodexcept AttributeError as e:
print(f"mistake：{e}")
try:
(1) #Error: frozenset has no remove methodexcept AttributeError as e:
print(f"mistake：{e}")
try:
() #Error: Frozenset has no clear methodexcept AttributeError as e:
print(f"mistake：{e}")
Practical application scenarios
1. As a dictionary key
# Use frozenset as dictionary key to store combinationsdef store_combinations():
combinations = {}
#Storing scores for different combinations combinations[frozenset(['apple', 'orange'])] = 85
combinations[frozenset(['banana', 'grape'])] = 92
combinations[frozenset(['apple', 'banana'])] = 78
return combinations
#User Examplecombinations = store_combinations()
# Find the scores for a specific combinationsearch_combination = frozenset(['apple', 'orange'])
print(f"combination {search_combination} Score: {combinations[search_combination]}")
2. Cache immutable data
class DataProcessor:
def __init__(self):
= {}
def process_data(self, data_set):
# Convert input to frozenset to use as cache key frozen_data = frozenset(data_set)
# Check whether there are any results in the cache if frozen_data in :
print("Get results from cache")
return [frozen_data]
# Calculate new results print("Calculate new results")
result = sum(frozen_data) # Example calculation [frozen_data] = result
return result
#User Exampleprocessor = DataProcessor()
print(processor.process_data([1, 2, 3])) # Calculate new resultsprint(processor.process_data([3, 2, 1])) # Get the result from the cache (because the collection elements are the same)3. Immutable configuration set
class Configuration:
def __init__(self, settings):
self._settings = frozenset(settings)
@property
def settings(self):
return self._settings
def has_setting(self, setting):
return setting in self._settings
def is_compatible_with(self, other_config):
return bool(self._settings & other_config.settings)
#User Exampleconfig1 = Configuration(['debug', 'logging', 'cache'])
config2 = Configuration(['logging', 'security', 'api'])
print(f"Config1set up: {}")
print(f"Whether to enabledebug: {config1.has_setting('debug')}")
print(f"Is the configuration compatible?: {config1.is_compatible_with(config2)}")
Performance considerations
1. Memory usage
import sys
# Compare the memory usage of set and frozensetdata = list(range(1000))
regular_set = set(data)
frozen_set = frozenset(data)
print(f"setMemory usage: {(regular_set)} bytes")
print(f"frozensetMemory usage: {(frozen_set)} bytes")
2. Operating performance
import timeit
# Compare the creation performance of set and frozensetset_creation = ('set(range(100))', number=10000)
frozenset_creation = ('frozenset(range(100))', number=10000)
print(f"setCreation time: {set_creation:.6f}Second")
print(f"frozensetCreation time: {frozenset_creation:.6f}Second")
Best Practices
Scenarios using frozenset:
- When an immutable set is needed as a dictionary key
- When you need to ensure that the data is not modified
- When sharing data in a multi-threaded environment
- When as a read-only property of a class
Avoid using frozenset scenarios:
- When you need to modify the collection content frequently
- When the data volume changes frequently
- When only temporary storage and modification of data is required
Performance optimization suggestions:
# Good practice: Create a frozenset directlyfs = frozenset([1, 2, 3]) # Avoid: Create set first and then converts = set([1, 2, 3]) fs = frozenset(s) # Additional conversion steps
Error handling:
def safe_create_frozenset(data):
try:
return frozenset(data)
except TypeError as e:
print(f"mistake：The input data cannot be hashed - {e}")
return frozenset() # Return to empty frozenset
#User Examplevalid_data = [1, 2, 3]
invalid_data = [1, [2, 3], 4] # Contains list, not hashable
print(safe_create_frozenset(valid_data))
print(safe_create_frozenset(invalid_data))
Things to note
Immutability:
- Frozenset cannot be modified after creation
- All operations that attempt to modify frozenset will raise an AttributeError
Element requirements:
- The element of frozenset must be hashable
- Cannot contain mutable types such as lists, dictionaries, ordinary collections, etc.
Equality comparison:
#The equality comparison of frozenset is based on its elementsfs1 = frozenset([1, 2, 3]) fs2 = frozenset([3, 2, 1]) print(fs1 == fs2) # Output: True
Hash value:
# frozenset can calculate hash valuefs = frozenset([1, 2, 3])
print(f"Hash value: {hash(fs)}")
By using frozenset, you can get better code security and reliability in scenarios where immutable collections are needed. Remember, choosing to use frozenset or normalset should be based on your specific needs, especially when considering data variability and usage scenarios.
This is the end of this article about the implementation of Python frozenset collection. For more related contents of Python frozenset collections, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!