Python Immutable Data Structures – Tuples, frozenset, and More

Introduction – Why Use Immutable Data Structures?

In Python, most built-in data types are mutable (e.g., lists, dictionaries, sets). This means their contents can be modified after creation—which can lead to:

• Unexpected side effects
• Hard-to-debug state changes
• Unsafe concurrent behavior

Immutable data structures, on the other hand:

• Cannot be changed after creation
• Are hashable and usable as dictionary keys or set elements
• Improve predictability, thread safety, and functional purity

In this guide, you’ll learn:

• What immutability means in Python
• Built-in immutable types
• How to create custom immutable data structures
• Third-party tools like namedtuple and pyrsistent
• Best practices and use cases

What Does Immutable Mean in Python?

An immutable object is one whose state cannot change after it is created.

Built-in Immutable Types

Example: Immutable tuple

data = (1, 2, 3)
data[0] = 10  #  TypeError: 'tuple' object does not support item assignment

Tuples prevent accidental mutation.

Immutable vs Mutable – Table Comparison

frozenset – Immutable Set

fset = frozenset([1, 2, 3])
fset.add(4)  #  AttributeError: 'frozenset' object has no attribute 'add'

Use frozenset when you need a set but don’t want it modified.

Creating Custom Immutable Structures

Using namedtuple

from collections import namedtuple

Point = namedtuple("Point", "x y")
p = Point(10, 20)
print(p.x)  # 10

p.x = 5  #  AttributeError: can't set attribute

Lightweight and immutable—perfect for read-only objects.

Using @dataclass(frozen=True) in Python 3.7+

from dataclasses import dataclass

@dataclass(frozen=True)
class Config:
    host: str
    port: int

c = Config("localhost", 8080)
# c.port = 80  #  FrozenInstanceError

Enforces immutability with a frozen dataclass.

Third-Party Immutable Libraries

pyrsistent – Persistent/Immutable Data Structures

pip install pyrsistent

from pyrsistent import pvector

v = pvector([1, 2, 3])
v2 = v.append(4)

print(v)   # pvector([1, 2, 3])
print(v2)  # pvector([1, 2, 3, 4])

Functional style: original structure is untouched.

immutables (by MagicStack)

pip install immutables

import immutables

mapping = immutables.Map({"a": 1})
new_map = mapping.set("b", 2)

print(mapping)   # immutables.Map({'a': 1})
print(new_map)   # immutables.Map({'a': 1, 'b': 2})

Efficient and safe mapping for concurrent programs.

Benefits of Immutability

Real-World Use Case – Safe Function Parameters

def process_data(data: tuple[int, int]):
    return data[0] + data[1]

result = process_data((10, 20))  #  Immutable input

Functions that accept immutable inputs are safe from mutation bugs.

Best Practices

Summary – Recap & Next Steps

Immutable data structures provide stability, safety, and performance benefits in Python. They prevent side effects and make your code easier to understand and test.

Key Takeaways:

• Tuples, strings, frozensets, and frozen dataclasses are immutable
• Use namedtuple and dataclass(frozen=True) for simple records
• Use libraries like pyrsistent and immutables for advanced needs
• Immutability improves safety, hashability, and concurrency

Real-World Relevance:
Used in config systems, functional programming, safe APIs, data pipelines, and thread-safe code.

FAQ – Immutable Data Structures in Python

Is a Python list immutable?

No. Lists are mutable and can be changed after creation.

Are tuples always safe?

Yes, as long as they don’t contain mutable objects inside.

What is the difference between frozenset and set?

• frozenset is immutable
• set is mutable and can change at runtime

Can I create immutable dictionaries?

Yes. Use third-party libraries like immutables or custom MappingProxyType.

Why is immutability useful in concurrency?

Immutable objects are inherently thread-safe—they can’t be changed, so no locking is required.