205. Immutable Data Structures in Python

🔹 1. Creating an Immutable Set with frozenset

• frozenset is an immutable version of set.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

Snippet	Description
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

---