Python Set Comprehension — Missing __hash__ Doubles Memory

Every real-world dataset is messy. Log files repeat the same IP address hundreds of times. A sales spreadsheet lists the same product SKU on every transaction. A user database stores the same city name for thousands of accounts. The moment you need to answer 'what unique values exist here?', you're reaching for a set — and if you want to build that set with some filtering or transformation baked in, a set comprehension is the cleanest tool Python gives you.

Before set comprehensions existed as a first-class feature, developers either converted a list comprehension to a set after the fact (set([...])) or wrote a multi-line loop with a .add() call. Both approaches work, but they force you to split your intent across multiple lines or data structures. A set comprehension collapses that intent into one readable expression that signals to anyone reading your code: 'I want a collection of transformed, unique values — and I want it right now.'

By the end of this article you'll know exactly when a set comprehension beats a list comprehension (and when it doesn't), how to write them with filtering conditions, how to handle nested data, and the subtle bugs that trip up even experienced developers. You'll also walk away with the vocabulary to answer set-comprehension questions confidently in a technical interview.

Set Comprehension: The Hidden Memory Trap

Set comprehension in Python is a concise syntax for constructing sets: {expr for item in iterable if condition}. It mirrors list comprehension but produces a set, meaning each element must be hashable and unique. The core mechanic is that Python builds the set by hashing each computed element and inserting it into a hash table, deduplicating automatically.

Under the hood, set comprehension uses the same __hash__ and __eq__ protocol as regular sets. If your elements are mutable (e.g., lists, dicts) or custom objects without proper __hash__, Python raises a TypeError. Even with hashable types, if __hash__ returns identical values for distinct objects (collisions), performance degrades from O(1) to O(n) per insertion. The set's memory footprint is roughly 8 bytes per entry plus overhead, but if you accidentally create many duplicate hashes, memory can spike as the table resizes to maintain load factor.

Use set comprehension when you need a deduplicated collection from an iterable and order doesn't matter. It's ideal for removing duplicates from a list ({x for x in items}) or computing unique transformations. In production, it often replaces explicit loops with set() calls, reducing lines of code and improving readability. But beware: if your elements are large objects, the set stores references, not copies — memory savings from dedup can be offset by retaining references to entire objects.

The Core Syntax — What You're Actually Writing and Why

A set comprehension looks almost identical to a list comprehension — the only visual difference is curly braces instead of square brackets. But that small change carries a big semantic shift: you're now telling Python to deduplicate automatically as it builds the collection.

The general shape is {expression for item in iterable if condition}. The if condition part is optional. Python evaluates the expression for every item that passes the condition and inserts the result into a set — meaning if the same result appears ten times, it only ends up in the collection once.

This is worth internalising: the deduplication isn't something you do afterwards. It happens during construction. That's what makes set comprehensions feel elegant — the data structure's core property (uniqueness) is enforced at the moment of creation, not as a cleanup step.

Use a set comprehension when you care about membership ('does this value exist?') more than you care about order or count. The moment you need to preserve duplicates or maintain insertion order, you're back in list-comprehension territory.

# Scenario: we have server log entries and want to know
# which unique HTTP status codes were returned today.

log_entries = [
    {"path": "/home",    "status": 200},
    {"path": "/about",   "status": 200},
    {"path": "/contact", "status": 404},
    {"path": "/api/v1",  "status": 500},
    {"path": "/home",    "status": 200},  # duplicate — same status as first entry
    {"path": "/api/v2",  "status": 404},  # duplicate — same status as third entry
]

# Without a set comprehension you'd write:
# unique_statuses = set()
# for entry in log_entries:
#     unique_statuses.add(entry["status"])

# With a set comprehension — same result, one line, intention is crystal clear:
unique_statuses = {entry["status"] for entry in log_entries}

print("Unique HTTP status codes:", unique_statuses)
print("Total log entries:", len(log_entries))   # 6 raw entries ...
print("Unique statuses found:", len(unique_statuses))  # ... but only 3 unique values

# Sets are unordered, so the print order may vary between Python runs.
# What matters is that 200, 404, and 500 each appear exactly once.

Filtering Inside the Comprehension — Doing Real Work in One Line

The optional if clause is where set comprehensions go from 'neat trick' to 'genuinely useful'. You can filter the source data, transform it, and deduplicate — all in one expression.

Think about an e-commerce platform extracting the distinct countries of customers who placed orders over $100. You have a list of order dictionaries. With a set comprehension you scan, filter, extract, and deduplicate in one pass. Without it, you'd write a loop, an if block, and a .add() call — four to six lines that say the same thing.

The filter condition is evaluated before the expression, so Python never does unnecessary work. If an item fails the if test, the expression is never evaluated for it. That's efficient and clean.

You can also chain multiple conditions with and / or. Just be mindful of readability: if your condition is longer than about 60 characters, consider extracting it into a named helper function. A set comprehension that wraps across four lines is a sign you've pushed the idiom too far.

# Scenario: an e-commerce app needs to find all unique product
# categories that have at least one discounted item in stock.

product_catalog = [
    {"name": "Wireless Headphones", "category": "Electronics",  "discounted": True,  "stock": 42},
    {"name": "USB-C Hub",           "category": "Electronics",  "discounted": False, "stock": 15},
    {"name": "Yoga Mat",            "category": "Sports",       "discounted": True,  "stock": 0},
    {"name": "Running Shoes",       "category": "Sports",       "discounted": True,  "stock": 8},
    {"name": "Coffee Maker",        "category": "Kitchen",      "discounted": False, "stock": 3},
    {"name": "Blender",             "category": "Kitchen",      "discounted": True,  "stock": 5},
    {"name": "Desk Lamp",           "category": "Office",       "discounted": False, "stock": 20},
]

# We only want categories where the product IS discounted AND IS in stock.
# The set automatically collapses "Electronics" and "Sports" duplicates.
categories_with_deals = {
    product["category"]
    for product in product_catalog
    if product["discounted"] and product["stock"] > 0  # both conditions must be true
}

print("Categories currently on sale:", categories_with_deals)

# Note: 'Sports' → Yoga Mat passes 'discounted' but fails 'stock > 0',
#                   Running Shoes passes both — so Sports makes the cut.
# Note: 'Electronics' → USB-C Hub fails 'discounted' — Headphones passes both.
# Note: 'Office' → Desk Lamp fails 'discounted' — never appears.

# Membership test — the primary reason you'd choose a set over a list:
if "Kitchen" in categories_with_deals:
    print("Show 'Kitchen deals' banner on homepage")
else:
    print("Hide kitchen deals banner — nothing to show")

Nested Data and Expression Transforms — Going Beyond Simple Extraction

Set comprehensions aren't limited to pulling a field out of a dict unchanged. The expression — the part before for — can be any valid Python expression: a method call, a calculation, a conditional expression (ternary), even a function call.

A common real-world pattern is normalising data during collection. Email addresses from a sign-up form arrive in inconsistent casing. Domain names from scraped URLs need the protocol stripped. Usernames have trailing whitespace. You can clean all of this inside the expression so the resulting set contains only normalised, unique values — no second pass required.

Nested for clauses also work, letting you flatten a list-of-lists into a unique flat set. Be careful here: the inner for is evaluated left-to-right, same as nested loops, and the comprehension can become hard to read quickly. Use it for one level of nesting; beyond that, a regular loop is clearer.

# Scenario 1: Normalise email addresses collected from multiple sign-up forms.
# Users typed their emails with inconsistent capitalisation and whitespace.

raw_email_submissions = [
    "  Alice@Gmail.COM  ",
    "bob@outlook.com",
    "ALICE@GMAIL.COM",        # same as first entry after normalisation
    "carol@yahoo.com",
    "Bob@Outlook.Com",        # same as second entry after normalisation
    "dave@company.io",
]

# .strip() removes whitespace, .lower() normalises casing.
# The set automatically removes the now-identical duplicates.
normalised_emails = {email.strip().lower() for email in raw_email_submissions}

print("Unique normalised emails:")
for email in sorted(normalised_emails):  # sorted() just for readable output
    print(" ", email)
print(f"Received {len(raw_email_submissions)} submissions, {len(normalised_emails)} unique addresses.")

print()

# Scenario 2: Flatten a nested list of tags from multiple blog posts
# and collect only the unique tags across all posts.

blog_posts = [
    {"title": "Python Basics",       "tags": ["python", "beginner", "programming"]},
    {"title": "Advanced Generators", "tags": ["python", "advanced", "generators"]},
    {"title": "SQL for Developers",  "tags": ["sql", "databases", "beginner"]},
]

# The nested 'for' flattens posts → tags, and the set removes duplicates like
# 'python' (appears in post 1 and 2) and 'beginner' (appears in post 1 and 3).
all_unique_tags = {
    tag
    for post in blog_posts       # outer loop: iterate over posts
    for tag in post["tags"]      # inner loop: iterate over each post's tag list
}

print("All unique tags across the blog:", sorted(all_unique_tags))

Set Comprehension vs List Comprehension vs set() — Choosing the Right Tool

These three approaches can often produce similar results, but they signal very different intentions and have real performance differences worth understanding.

set(list_comprehension) — builds a full list in memory first, then converts it to a set. You pay the memory cost of the intermediate list before deduplication happens. This is the anti-pattern to retire.

A set comprehension {expr for item in iterable} — builds the set directly, deduplicating on the fly. No intermediate list. For large datasets this matters.

set(iterable) without any expression or filter — the fastest option when you don't need to transform the data. Just wrapping an existing iterable in set() is perfectly idiomatic. Don't reach for a comprehension when a plain set() call is sufficient.

The decision rule is simple: if you need to transform or filter during collection, use a set comprehension. If you're just deduplicating an existing iterable unchanged, use set(). If you need duplicates or order, use a list comprehension.

import tracemalloc  # built-in module for tracking memory allocations
import time

# Large dataset: 1 million integers with lots of repetition
import random
random.seed(42)
large_dataset = [random.randint(1, 1000) for _ in range(1_000_000)]

# ── Approach 1: set() wrapping a list comprehension (anti-pattern) ──
tracemalloc.start()
start = time.perf_counter()
unique_via_list_then_set = set([num * 2 for num in large_dataset if num % 3 == 0])
elapsed_1 = time.perf_counter() - start
mem_1 = tracemalloc.get_traced_memory()[1]  # peak memory in bytes
tracemalloc.stop()

# ── Approach 2: Set comprehension (recommended) ──
tracemalloc.start()
start = time.perf_counter()
unique_via_set_comprehension = {num * 2 for num in large_dataset if num % 3 == 0}
elapsed_2 = time.perf_counter() - start
mem_2 = tracemalloc.get_traced_memory()[1]
tracemalloc.stop()

# ── Approach 3: plain set() — only valid if no transformation needed ──
tracemalloc.start()
start = time.perf_counter()
unique_via_plain_set = set(large_dataset)   # no transform, no filter
elapsed_3 = time.perf_counter() - start
mem_3 = tracemalloc.get_traced_memory()[1]
tracemalloc.stop()

print(f"Results match (1 vs 2): {unique_via_list_then_set == unique_via_set_comprehension}")
print()
print(f"Approach 1 — set(list comp):   {elapsed_1:.4f}s  |  peak memory: {mem_1 / 1024:.1f} KB")
print(f"Approach 2 — set comprehension:{elapsed_2:.4f}s  |  peak memory: {mem_2 / 1024:.1f} KB")
print(f"Approach 3 — plain set():      {elapsed_3:.4f}s  |  peak memory: {mem_3 / 1024:.1f} KB")
print()
print(f"Unique values (approach 2): {len(unique_via_set_comprehension)} distinct numbers")

Hashing, Hashability and Performance: What Makes Set Comprehension Fast (or Slow)

The magic behind set comprehension is the hash table. Every element you put into a set must have a valid hash value computed by its __hash__ method. Python uses that hash to place the element in a bucket. If two elements have the same hash (collision), Python checks equality via __eq__ to decide if they are duplicates.

Understanding this mechanism explains most gotchas:

• Hash consistency: If you define __eq__ without __hash__, Python sets __hash__ to None, making the object unhashable. This is deliberate — it prevents storing objects that compare equal but have different hashes.
• Hash collisions: When many objects share the same hash (e.g., all integers in a small range), lookups degrade from O(1) toward O(n) for that bucket. Python's hash function is designed to spread well, but custom types can have poor hash functions.
• Hash performance: Computing a hash for simple types like int is trivial. For large strings or tuples, the hash cost is proportional to length. In a set comprehension building millions of elements, hash computation time dominates.

To optimise performance, consider using integers or short strings as set elements, and avoid deep nested structures as hash keys.

# Demonstrate how hash collisions affect set performance
import time

# Create 10,000 integers — hash is fast, collisions rare
ints = range(10000)
start = time.perf_counter()
set_of_ints = {i for i in ints}
print(f"Integer set built in {time.perf_counter() - start:.5f}s")

# Create 10,000 tuples of length 1000 — each tuple hash is O(len)
long_tuples = [tuple(range(1000)) for _ in range(10000)]
start = time.perf_counter()
set_of_tuples = {t for t in long_tuples}
print(f"Large tuple set built in {time.perf_counter() - start:.5f}s")

# Create custom objects with poor hash (constant hash → collisions)
class BadHash:
    def __init__(self, val):
        self.val = val
    def __hash__(self):
        return 42  # all same hash → massive collisions
    def __eq__(self, other):
        return self.val == other.val

bad_items = [BadHash(i) for i in range(10000)]
start = time.perf_counter()
try:
    set_of_bad = {item for item in bad_items}
    print(f"BadHash set built in {time.perf_counter() - start:.5f}s")
except Exception as e:
    print(f"BadHash set failed: {e}")

Generators vs Sets: When Your Set Comprehension Eats Memory for Breakfast

A set comprehension creates the entire set in memory at once. That's fine for 10k elements. For 10 million? You're about to hit swap and watch your deploys fail.

Senior engineers use generator expressions for lazy evaluation. No memory allocation until you actually need the element. The syntax swap is trivial: replace {x2 for x in huge_iterable} with (x2 for x in huge_iterable).

The key difference is simple: set comprehensions ensure uniqueness on creation. Generators don't. But if you only need to iterate once and check membership by hash? That's a set. If you're streaming logs, building intermediate working sets, or processing data that can't fit in RAM, reach for a generator.

Production reality check: your 16GB box doesn't care about syntax elegance. It cares about resident memory. I've seen teams rewrite set comprehensions as generators and cut memory usage by 90%. The generator starts yielding immediately. The set comprehension blocks until the whole batch is hashed.

// io.thecodeforge — python tutorial

import tracemalloc

# Set comprehension - builds entire set in memory
# Simulates processing 1 million unique IDs
tracemalloc.start()
early_results = {hash(str(x)) for x in range(1_000_000)}
current, peak = tracemalloc.get_traced_memory()
print(f"Set Comprehension: {peak / 1024 / 1024:.2f} MB peak")
tracemalloc.stop()

# Generator expression - lazy, no preallocation
tracemalloc.start()
early_results_gen = (hash(str(x)) for x in range(1_000_000))
# Generator hasn't consumed anything yet
current, peak = tracemalloc.get_traced_memory()
print(f"Generator: {peak / 1024 / 1024:.2f} MB peak")
tracemalloc.stop()

Nested Set Comprehensions: The Junior Hallucination That Burns CPU Cycles

I've seen juniors write nested comprehensions thinking they look clever. { (x, y) for x in range(1000) for y in range(1000) } generates a million-element set. Does it work? Yes. Should you do it? Only if you hate your team's cloud bill.

Here's the reality check: every element must be hashable. Every element must be unique. Every cross-product element goes through hash calculation and collision resolution. That's O(n m) memory and O(n m) compute, where n and m are your loops.

Most of the time, you don't need a cartesian product as a set. You need a structure that represents the actual relationship, not every possible combination. Use a dict of sets, or process with itertools.product and yield as a generator.

If you absolutely must nest, think about the cardinality first. Two loops of 10k elements? That's 100 million hash operations. Python will do it, but your CPU fan will scream. Your production incident review will not be kind.

// io.thecodeforge — python tutorial

import time

# The junior special: nested set comprehension
start = time.perf_counter()
bad_set = { (a, b) for a in range(1000) for b in range(1000) }
end = time.perf_counter()
print(f"Nested set comp: {len(bad_set)} elements in {end-start:.3f}s")

# The senior approach: generator with condition
# Only care about pairs where a and b are co-prime
import math
start = time.perf_counter()
efficient_work = (
    (a, b) 
    for a in range(1000) 
    for b in range(1000) 
    if math.gcd(a, b) == 1
)
# Process as needed, no memory allocation
end = time.perf_counter()
print(f"Generator setup: data ready in {end-start:.6f}s")

# Actually materialize only what you need
coprime_pairs = set(efficient_work)
print(f"Co-prime pairs: {len(coprime_pairs)} elements")

Creating Sets With Literals and set()

Most Python developers type {} for an empty set. That gives you a dict. Set literal syntax only works with elements: {1, 2, 3}. For an empty set, you must call set(). The performance difference matters: a set literal compiles to a single LOAD_SET bytecode, while set() calls a function. When building a set from an existing iterable, set(iterable) is the idiomatic choice and avoids the hidden memory overhead of a list comprehension wrapped in set(). The literal form {x for x in items} is actually a set comprehension, not a literal — distinct bytecode path. Know the three forms: {1,2,3} (literal, const), set([1,2,3]) (constructor from iterable), and {x for x in items} (comprehension, generator-based). Each serves a different purpose. Use the literal for static data, set() for dynamic conversion, and comprehensions for filtered transforms.

// io.thecodeforge — python tutorial

// Set literal — compiles to LOAD_SET
unique_pages = {"/home", "/blog", "/about"}

// Empty set — must use set(), NOT {}
visited_pages = set()

// From iterable — direct constructor
active_users = set(users_db.filter(status="active"))

// Common mistake: dict, not set
bad = {}  # type: dict
print(type(bad))  # <class 'dict'>

Exploring Common Bad Practices

The worst pattern is set([x for x in items]) — building an intermediate list just to throw it away. This doubles memory: the list lives until the set consumes it. Use a set comprehension directly: {x for x in items}. Another trap: modifying a set while iterating over it. Sets are unordered, so you can't delete by index; using remove() during iteration raises RuntimeError. Collect deletions in a separate set instead. Overusing in checks on large sets inside loops — set membership is O(1), but the lookup overhead of repeated hashing still adds up. Prefer structured queries when possible. Finally, relying on iteration order. Sets are unordered before Python 3.7, and even after insertion-order preservation is implementation detail. Never write code that depends on set ordering across versions.

// io.thecodeforge — python tutorial

// Bad: list intermediary doubles memory
bad_set = set([x.upper() for x in names])

// Good: set comprehension, no copy
good_set = {x.upper() for x in names}

// Bad: modifying set while iterating
s = {1, 2, 3}
for x in s:
    if x == 2:
        s.remove(x)  # RuntimeError

// Correct: collect to remove outside
remove_these = {x for x in s if x == 2}
s -= remove_these

Set Comprehensions with Conditional Logic

Set comprehensions can include conditional logic to filter elements or transform data based on conditions. The syntax extends the basic comprehension by adding an if clause after the loop, or even multiple if clauses and if-else expressions in the output expression. This allows for concise creation of sets that meet specific criteria.

Basic filtering: {x for x in range(10) if x % 2 == 0} creates a set of even numbers from 0 to 9. The condition is evaluated for each element, and only those satisfying it are included.

Multiple conditions: You can chain conditions with and, or, etc. For example, {x for x in range(20) if x % 2 == 0 if x % 3 == 0} is equivalent to if x % 2 == 0 and x % 3 == 0, yielding multiples of 6.

Conditional expression (if-else): You can apply a transformation based on a condition using a ternary expression in the output part. For instance, {x if x % 2 == 0 else x*2 for x in range(5)} produces {0, 2, 4, 6, 8} (odd numbers doubled). Note that this does not filter; it transforms every element.

Practical example: Extracting unique email domains from a list of emails, but only for domains that are not 'example.com': {email.split('@')[1] for email in emails if 'example.com' not in email}.

Conditional logic makes set comprehensions powerful for data cleaning and preprocessing, but be cautious with complex conditions that reduce readability. In production, consider breaking down very complex comprehensions into helper functions or multiple steps for clarity and maintainability.

# Basic filtering: even numbers
evens = {x for x in range(10) if x % 2 == 0}
print(evens)  # {0, 2, 4, 6, 8}

# Multiple conditions: multiples of 6
multiples_of_6 = {x for x in range(20) if x % 2 == 0 if x % 3 == 0}
print(multiples_of_6)  # {0, 6, 12, 18}

# Conditional expression: double odd numbers
transformed = {x if x % 2 == 0 else x*2 for x in range(5)}
print(transformed)  # {0, 2, 4, 6, 8}

# Real-world: unique email domains excluding example.com
emails = ['a@example.com', 'b@test.com', 'c@example.com', 'd@test.com']
domains = {email.split('@')[1] for email in emails if 'example.com' not in email}
print(domains)  # {'test.com'}

Set Comprehensions vs Generator with set()

Both set comprehensions and generator expressions passed to set() create a set, but they differ in memory usage and performance. Understanding when to use each can optimize your code.

Set comprehension: {x for x in iterable} builds the set directly in memory. It is generally faster because it avoids the overhead of creating a generator object and then iterating over it to populate the set. The entire set is constructed in one pass.

Generator with set(): set(x for x in iterable) first creates a generator expression (a lazy iterator) and then passes it to set(), which iterates over the generator to build the set. This involves two layers: generator creation and iteration. The generator itself is memory-efficient (yields items one by one), but the final set still holds all unique items.

Performance comparison: For small to medium-sized iterables, set comprehensions are typically faster due to lower overhead. For very large iterables where memory is a concern, the generator approach might be slightly more memory-friendly during construction (though the final set size is the same). However, in practice, the difference is often negligible.

Memory usage: Both produce a set of the same size. The generator expression does not store intermediate results, but the set comprehension also builds the set incrementally. The key memory difference is that the generator expression itself is a small object, while the set comprehension's internal machinery is similar.

Example: {x2 for x in range(1000)} vs set(x2 for x in range(1000)). The former is slightly faster and more idiomatic.

In summary, set comprehensions are the preferred choice for clarity and speed. Reserve generator+set() for cases where you need to reuse the generator or when the comprehension would be unwieldy.

import timeit

# Set comprehension
comp_time = timeit.timeit(
    '{x**2 for x in range(1000)}',
    number=10000
)

# Generator with set()
gen_time = timeit.timeit(
    'set(x**2 for x in range(1000))',
    number=10000
)

print(f"Set comprehension: {comp_time:.4f}s")
print(f"Generator + set(): {gen_time:.4f}s")

# Output typically shows comprehension is faster
# Example output:
# Set comprehension: 0.3456s
# Generator + set(): 0.4123s

Frozenset Comprehensions: Python 3.9+

Python 3.9 introduced frozenset comprehensions via the frozenset() constructor with a generator expression, but there is no dedicated frozenset comprehension syntax like {x for x in ...} (which creates a set). However, you can achieve similar conciseness using frozenset({x for x in ...}) or frozenset(x for x in ...). The latter is more memory-efficient as it avoids creating an intermediate set.

Syntax: frozenset(x for x in iterable) creates a frozenset directly from a generator expression. This is the recommended way for frozenset comprehensions.

Why frozenset? Frozensets are immutable and hashable, making them usable as dictionary keys or elements of other sets. They are useful when you need a set that should not change, e.g., for configuration, caching, or as a key in a dictionary.

Example: Creating a frozenset of unique squares: frozenset(x**2 for x in range(10)).

Performance: Using a generator expression with frozenset() avoids building an intermediate mutable set, saving memory. For large iterables, this is beneficial.

Comparison with set comprehension: frozenset({x for x in range(10)}) first builds a set, then copies it into a frozenset. This doubles memory usage temporarily. Prefer frozenset(x for x in range(10)).

Practical use case: Storing a frozenset of allowed status codes as a dictionary key: valid_statuses = frozenset({200, 201, 304}) then cache[valid_statuses] = ....

Note: Frozenset comprehensions are not a separate syntax but a pattern. Python 3.9+ does not have {x for x in ...} for frozensets; that syntax always produces a set. Use frozenset() with a generator.

In summary, for immutable sets, use frozenset() with a generator expression to avoid unnecessary intermediate sets and ensure hashability.

# Frozenset from generator (recommended)
fs1 = frozenset(x**2 for x in range(5))
print(fs1)  # frozenset({0, 1, 4, 9, 16})

# Frozenset from set comprehension (less efficient)
fs2 = frozenset({x**2 for x in range(5)})
print(fs2)  # frozenset({0, 1, 4, 9, 16})

# Using frozenset as dictionary key
status_groups = {
    frozenset({200, 201}): "success",
    frozenset({404, 500}): "error"
}
print(status_groups[frozenset({200, 201})])  # "success"

# Conditional frozenset
fs3 = frozenset(x for x in range(10) if x % 2 == 0)
print(fs3)  # frozenset({0, 2, 4, 6, 8})