205. Immutable Data Structures in Python

🔹 1. Creating an Immutable Set with frozenset

• frozenset is an immutable version of set.

Copy

fs = frozenset([1, 2, 3, 4])
print(fs)  # Output: frozenset({1, 2, 3, 4})

# Trying to modify will raise an error
fs.add(5)  # AttributeError: 'frozenset' object has no attribute 'add'

🔍 How it works:

• Unlike set, frozenset cannot be modified after creation.

---

🔹 2. Using frozenset as a Dictionary Key

• Since frozenset is hashable, it can be used as a dictionary key.

Copy

my_dict = {frozenset([1, 2, 3]): "Immutable Key"}
print(my_dict[frozenset([1, 2, 3])])  # Output: Immutable Key

🔍 How it works:

• Normal sets (set) can’t be dictionary keys, but frozenset can because it's hashable.

---

🔹 3. Eliminating Duplicate Sets in a List

• Use frozenset to remove duplicate sets.

Copy

sets = [{1, 2, 3}, {3, 2, 1}, {4, 5, 6}]
unique_sets = set(map(frozenset, sets))
print(unique_sets)  # Output: {frozenset({1, 2, 3}), frozenset({4, 5, 6})}

🔍 How it works:

• set treats frozenset({1,2,3}) and frozenset({3,2,1}) as the same object, removing duplicates.

---

🔹 4. Using frozenset for Fast Membership Testing

• Checking membership in a frozenset is faster than a list.

Copy

fs = frozenset(range(10000))

print(9999 in fs)  # Fast lookup, Output: True
print(10001 in fs)  # Output: False

🔍 How it works:

• Lookups in frozenset are O(1) (constant time) compared to O(n) for lists.

---

🔹 5. Creating an Immutable Dictionary (Using types.MappingProxyType)

• Python doesn’t have a built-in immutable dictionary, but MappingProxyType makes it read-only.

Copy

from types import MappingProxyType

mutable_dict = {"name": "Alice", "age": 25}
immutable_dict = MappingProxyType(mutable_dict)

print(immutable_dict["name"])  # Output: Alice
immutable_dict["name"] = "Bob"  # TypeError: 'mappingproxy' object does not support item assignment

🔍 How it works:

• MappingProxyType makes a dictionary read-only, preventing modifications.

---

🔹 6. Preventing Modification of a Dictionary at Runtime

• Use MappingProxyType to protect a dictionary after creation.

Copy

from types import MappingProxyType

config = {"host": "localhost", "port": 8080}
config_proxy = MappingProxyType(config)

config["port"] = 9090  # Allowed (modifies the original)
config_proxy["port"] = 9090  # TypeError: 'mappingproxy' object does not support item assignment

🔍 How it works:

• The original dictionary can be changed, but the proxy cannot be modified directly.

---

🔹 7. Hashing frozenset for Use in Caching

• frozenset can be used as a cache key because it's hashable.

Copy

cache = {}

def expensive_computation(inputs):
    key = frozenset(inputs)
    if key in cache:
        return cache[key]
    result = sum(inputs)  # Simulating a complex computation
    cache[key] = result
    return result

print(expensive_computation([1, 2, 3]))  # Output: 6
print(expensive_computation([3, 2, 1]))  # Output: 6 (Cached)

🔍 How it works:

• frozenset ensures that {1,2,3} and {3,2,1} are treated as the same cache key.

---

🔹 8. Using frozenset in Function Arguments to Ensure Immutability

• Prevent accidental modifications to function arguments.

Copy

def process_items(items: frozenset):
    print(f"Processing: {items}")

fs = frozenset([1, 2, 3])
process_items(fs)  # Output: Processing: frozenset({1, 2, 3})

🔍 How it works:

• This ensures that items cannot be modified inside process_items().

---

🔹 9. Immutable Nested Dictionaries

• Use frozenset inside a dictionary to make nested data immutable.

Copy

data = {
    "students": frozenset(["Alice", "Bob", "Charlie"]),
    "grades": MappingProxyType({"Alice": "A", "Bob": "B"})
}

print(data["students"])  # Output: frozenset({'Alice', 'Charlie', 'Bob'})

data["students"].add("David")  # AttributeError: 'frozenset' object has no attribute 'add'
data["grades"]["Alice"] = "B+"  # TypeError: 'mappingproxy' object does not support item assignment

🔍 How it works:

• Ensures that both lists and dictionaries inside are immutable.

---

🔹 10. Protecting Global Constants with Immutable Structures

• Prevents accidental modifications in large programs.

Copy

from types import MappingProxyType

CONFIG = MappingProxyType({
    "API_URL": "https://api.example.com",
    "TIMEOUT": 30,
    "DEBUG": False
})

print(CONFIG["API_URL"])  # Output: https://api.example.com
CONFIG["DEBUG"] = True  # TypeError: 'mappingproxy' object does not support item assignment

🔍 How it works:

• The dictionary holding configuration settings cannot be modified after creation.

---

Summary of Immutable Data Structures in Python

SnippetDescription

1️⃣

Creating frozenset

2️⃣

Using frozenset as a dictionary key

3️⃣

Removing duplicate sets using frozenset

4️⃣

Fast membership testing with frozenset

5️⃣

Creating an immutable dictionary with MappingProxyType

6️⃣

Protecting dictionary values at runtime

7️⃣

Hashing frozenset for caching

8️⃣

Using frozenset as function arguments

9️⃣

Making nested data structures immutable

🔟

Protecting global constants

---