← Back to Python Course | Chapter 6: Data Structures | Lesson 11 of 12

Python Frozenset

A regular Python set can be modified after creation -- items added or removed freely -- but sometimes you need a set-like collection that is guaranteed never to change, such as when using it as a dictionary key (which requires an immutable, hashable value) or simply protecting data from accidental modification. frozenset() creates exactly that: an immutable version of a set.

In this page:

  1. Creating a Frozenset
  2. Frozensets Are Immutable
  3. Frozensets as Dictionary Keys
  4. Set Operations on Frozensets
  5. When to Use frozenset vs set
Syntax
python 
frozen = frozenset(iterable)

Creating a Frozenset

frozenset(iterable) builds an immutable set from any iterable -- a list, a tuple, a regular set, or a string of characters -- producing a collection that behaves like a set for reading purposes, but permanently locks its contents at creation time.

Note: Pass any existing set, list, or tuple directly into frozenset() to create an immutable snapshot of it, without changing the original.
Warning: frozenset() with no arguments creates an empty frozenset, but there is no literal syntax shortcut for it the way {} would be ambiguous for an empty dictionary versus an empty set.

Example: Creating a Frozenset

python 
numbers = frozenset([1, 2, 2, 3])
print(numbers)

Frozensets Are Immutable

Once created, a frozenset cannot be changed in any way -- there is no add(), remove(), discard(), pop(), or clear() method available on it, since all of these would modify its contents, which directly contradicts the entire point of a frozenset.

Note: If you find yourself needing to modify a frozenset's contents, that is a strong signal you actually want a regular, mutable set instead.
Warning: Calling a mutating method (like .add()) on a frozenset raises an AttributeError immediately, since that method simply does not exist on the frozenset type.

Example: Frozensets Are Immutable

python 
numbers = frozenset([1, 2, 3])
try:
    numbers.add(4)  # frozenset has no add() method
except AttributeError as e:
    print("Error:", e)

Frozensets as Dictionary Keys

Because a frozenset is immutable and therefore hashable, it can be used as a dictionary key or stored as an element inside another set -- both operations that raise a TypeError with a regular, mutable set, since Python requires dictionary keys and set elements to never change after being added.

Note: Reach for a frozenset specifically when you need a set-like value to serve as a dictionary key or live inside another set.
Warning: Attempting to use a regular set (not a frozenset) as a dictionary key raises "TypeError: unhashable type: set" immediately.

Example: Frozensets as Dictionary Keys

python 
key = frozenset([1, 2])  # frozensets are hashable, so they can be dict keys
data = {key: "pair one-two"}
print(data[frozenset([1, 2])])  # an equal frozenset looks up the same entry

Set Operations on Frozensets

Frozensets support the exact same read-only set operations as regular sets -- union (|), intersection (&), difference (-), and membership testing (in) -- since none of these operations modify the frozenset itself, only combine it with something else to produce a new result.

Note: Use frozensets exactly like regular sets for any read-only operation (membership checks, unions, intersections) -- the immutability only restricts modification, not reading or combining.
Warning: A union or intersection between two frozensets produces a new frozenset, not a regular set -- the immutability propagates through these combining operations.

Example: Set Operations on Frozensets

python 
a = frozenset([1, 2, 3])
b = frozenset([2, 3, 4])
print(a | b)  # union, produces a new frozenset
print(a & b)  # intersection, also produces a new frozenset

When to Use frozenset vs set

Choose a regular set when the collection genuinely needs to grow or shrink over the program's lifetime; choose frozenset specifically when you need an immutable, hashable set-like value -- protecting a fixed collection of constants from accidental modification, or using it as a dictionary key or set element.

Note: Default to a regular set unless you have a specific reason (immutability, hashability) to reach for frozenset instead.
Warning: Using frozenset everywhere out of caution, even for collections that genuinely need to change over time, forces awkward "create a new frozenset every time" workarounds instead of simple in-place updates.

Example: When to Use frozenset vs set

python 
mutable_set = {1, 2, 3}
mutable_set.add(4)  # regular set can grow

immutable_set = frozenset([1, 2, 3])  # frozenset can't be changed after creation
print(mutable_set, immutable_set)
Related Topics

Python Nested Data Structures · Python Nested Dictionaries · Python Dict Comprehension · Python List Comprehension

{# common_mistakes/chapter_summary/browser_support: on Hindi pages the view already swaps in the hi_ translation fields (or blanks these out if untranslated), so this renders correctly for both languages without a lang_code check here. #}
Common Mistakes
  1. Trying to call .add() or .remove() on a frozenset, which raises an AttributeError since frozensets do not support any method that would modify their contents.
  2. Using a regular set as a dictionary key or as an element inside another set, which raises a TypeError since regular sets are unhashable -- frozenset solves exactly this problem.
  3. Assuming frozenset() creates a copy that automatically stays in sync with the original set it was built from -- it is actually an independent, frozen snapshot at the time of creation.
Chapter Summary
  • frozenset(iterable) creates an immutable set from any iterable, supporting the same read-only operations (membership tests, unions, intersections) as a regular set.
  • Because a frozenset is immutable and hashable, it can be used as a dictionary key or as an element inside another set, unlike a regular set.
  • Unlike a regular set, a frozenset has no methods that modify it in place -- no add(), remove(), or similar mutating methods exist.
Browser Support

frozenset has been part of core Python since Python 2.4, and works identically across every Python 3 version.

🔒

Chapter Quiz — Complete all 12 topics to unlock

0/12 topics done

Complete these topics first:

← Previous Lesson Python Set Methods Next Lesson → Python Dictionaries

Login to run this code

C/C++/Java/PHP execution requires a free account. Your code is saved — you'll land right back in the editor after logging in.