Python Set Comprehensions Explained — Syntax, Use Cases and Pitfalls

# 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.

# 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")

# 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))

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")