Advanced Sets in Python

# Creating sets — several ways
tags   = {"python", "data", "python", "code", "data"}
print("From literal:", tags)          # duplicates removed

nums   = set([1, 2, 2, 3, 3, 3, 4])  # from a list
print("From list:", nums)

letters = set("mississippi")          # from a string — unique chars only
print("From string:", letters)

empty  = set()                        # correct — {} creates an empty dict
print("Empty:", empty, type(empty))

fruits = {"apple", "banana", "cherry"}

fruits.add("mango")              # add one item
fruits.update(["kiwi", "pear"]) # add multiple items from any iterable
print("After add:", fruits)

fruits.remove("banana")          # raises KeyError if not found
fruits.discard("grape")          # silent — no error if not found
print("After remove:", fruits)

# pop() removes and returns an arbitrary element (sets are unordered)
item = fruits.pop()
print("Popped:", item)

fruits.clear()
print("After clear:", fruits)

a = {"python", "sql", "excel"}
b = {"python", "tableau", "power bi"}

# Method and operator — identical results
print(a.union(b))
print(a | b)

# Union of three sets at once
c = {"spark", "sql"}
print(a | b | c)
print(a.union(b, c))

# Real-world: merge email subscriber lists from two campaigns
campaign1 = {"alice@x.com", "bob@x.com", "carol@x.com"}
campaign2 = {"bob@x.com",   "dave@x.com", "eve@x.com"}
master    = campaign1 | campaign2
print("Master list:", len(master), "unique addresses")

skills_needed   = {"python", "sql", "machine learning", "excel"}
skills_you_have = {"python", "excel", "power bi", "tableau"}

# What skills match the job?
match = skills_needed & skills_you_have
print("Matching skills:", match)

# Intersection update — modify in place
test_set = {"python", "sql", "excel"}
test_set.intersection_update({"sql", "excel", "r"})
print("After intersection_update:", test_set)

# Real-world: find users who are in both a free and paid plan
free_users = {"u1", "u2", "u3", "u4", "u5"}
paid_users = {"u3", "u4", "u6", "u7"}
dual       = free_users & paid_users
print("On both plans:", dual)

skills_needed   = {"python", "sql", "machine learning", "excel"}
skills_you_have = {"python", "excel", "power bi", "tableau"}

# Skills you still need to learn
gaps   = skills_needed - skills_you_have
print("Skills to learn:", gaps)

# Skills you have that the job doesn't require
extras = skills_you_have - skills_needed
print("Extra skills:", extras)

# Real-world: find new users this month (this month minus last month)
last_month = {"u1", "u2", "u3", "u4"}
this_month = {"u1", "u2", "u3", "u4", "u5", "u6"}
new_users  = this_month - last_month
print("New users:", new_users)

# Churned users (were here last month but not this month)
lost_month = {"u1", "u2", "u3"}
churned    = last_month - lost_month
print("Churned:", churned)

store_a = {"apple", "banana", "cherry", "mango"}
store_b = {"banana", "mango", "grape", "peach"}

# Items exclusive to one store (not stocked by both)
unique = store_a ^ store_b
print("Store-exclusive items:", unique)

# Commutative — order does not matter
print("Reversed:", store_b ^ store_a)
print("Same result:", (store_a ^ store_b) == (store_b ^ store_a))

# Relationship to union and intersection
print("Via union/intersection:", (store_a | store_b) - (store_a & store_b))

basics   = {"html", "css"}
frontend = {"html", "css", "javascript", "react", "typescript"}
backend  = {"python", "sql", "django", "postgres"}

# Subset — is basics inside frontend?
print(basics.issubset(frontend))      # True
print(basics <= frontend)             # True — operator form

# Proper subset — subset but not equal (strictly inside)
print(basics < frontend)              # True  — basics != frontend
print(frontend < frontend)            # False — a set is not a proper subset of itself

# Superset — does frontend contain basics?
print(frontend.issuperset(basics))    # True
print(frontend >= basics)             # True

# Disjoint — do they share nothing at all?
print(frontend.isdisjoint(backend))   # True — no overlap between front and back
print(basics.isdisjoint(backend))     # True

import time

# Build a large dataset — 1 million items
data    = list(range(1_000_000))
data_set = set(data)

target = 999_999    # near the end — worst case for list

# List membership test
start = time.time()
for _ in range(1000):
    _ = target in data
list_time = time.time() - start

# Set membership test
start = time.time()
for _ in range(1000):
    _ = target in data_set
set_time = time.time() - start

print(f"List : {list_time:.4f}s")
print(f"Set  : {set_time:.6f}s")
print(f"Set is ~{list_time / set_time:.0f}x faster")

# Real-world: spam domain filter
blocked = {"spam.com", "junk.net", "phish.io", "malware.org"}
emails  = ["user@gmail.com", "admin@spam.com", "hello@dataplexa.com", "test@junk.net"]

clean   = [e for e in emails if e.split("@")[1] not in blocked]
print("Safe emails:", clean)

# Set comprehension — unique squares
nums = [1, 2, 2, 3, 3, 3, 4]
unique_squares = {n ** 2 for n in nums}
print("Unique squares:", unique_squares)

# Unique first letters
words = ["apple", "avocado", "banana", "blueberry", "cherry", "apricot"]
first_letters = {w[0] for w in words}
print("First letters:", first_letters)

# Filter while building — unique even numbers only
data   = [1, 2, 2, 3, 4, 4, 5, 6, 6]
unique_evens = {n for n in data if n % 2 == 0}
print("Unique evens:", unique_evens)

# Clean and deduplicate tags from user input
raw_tags = ["  Python  ", "DATA SCIENCE", "python", " ai ", "Data Science", "AI"]
clean_tags = {t.lower().strip() for t in raw_tags}
print("Unique tags:", clean_tags)

# frozenset — all set operations, no mutation
roles_admin = frozenset({"read", "write", "delete", "admin"})
roles_guest = frozenset({"read"})
roles_editor = frozenset({"read", "write"})

# Use frozensets as dictionary keys — not possible with regular sets
permissions = {
    roles_admin:  "full access",
    roles_guest:  "read only",
    roles_editor: "read-write",
}
print(permissions[roles_admin])
print(permissions[roles_guest])

# All set math still works — frozenset supports all read operations
overlap = roles_admin & roles_editor
print("Shared permissions:", overlap)

print("Is editor subset of admin?", roles_editor <= roles_admin)

# frozensets can be stored inside a regular set
access_levels = {roles_guest, roles_editor}   # set of frozensets
print("Access levels defined:", len(access_levels))

# Track daily active users across three days
day1 = {"u1", "u2", "u3", "u4", "u5"}
day2 = {"u2", "u3", "u4", "u6", "u7"}
day3 = {"u1", "u3", "u5", "u6", "u8"}

# Users active all 3 days (intersection)
loyal = day1 & day2 & day3
print("Active all 3 days:", loyal)

# Users active on any day (union)
total_unique = day1 | day2 | day3
print("Total unique users:", len(total_unique), total_unique)

# Users who appeared on day 1 but NOT day 3 (churned)
churned = day1 - day3
print("Churned (day1→day3):", churned)

# New users on day 3 (not seen on day 1 or 2)
new_day3 = day3 - (day1 | day2)
print("New on day 3:", new_day3)

# Users active on exactly one day (symmetric difference of all)
one_day_only = (day1 ^ day2 ^ day3) - (day1 & day2) - (day1 & day3) - (day2 & day3)
print("One-day only:", one_day_only)