Python Sets - Deduplication Lost Order, Corrupted Report

# ── Way 1: curly-brace literal ──────────────────────────────────────────
favourite_fruits = {"apple", "mango", "banana", "apple", "mango"}
# Notice: "apple" and "mango" appear twice above — watch what Python keeps
print("Favourite fruits:", favourite_fruits)

# ── Way 2: set() constructor converts a list into a set ──────────────────
raw_signups = ["alice@mail.com", "bob@mail.com", "alice@mail.com", "carol@mail.com"]
unique_signups = set(raw_signups)   # duplicates dropped automatically
print("Unique signups:", unique_signups)
print("Total unique:", len(unique_signups))   # 3, not 4

# ── set() on a string splits it into unique CHARACTERS ──────────────────
letters_in_word = set("mississippi")   # only unique letters survive
print("Unique letters in 'mississippi':", letters_in_word)

# ── An empty set MUST use set(), NOT {} ─────────────────────────────────
empty_set = set()         # correct — this is an empty set
empty_dict = {}           # WRONG for a set — this creates an empty dictionary!
print("Type of set():", type(empty_set))    # <class 'set'>
print("Type of {}:  ", type(empty_dict))    # <class 'dict'>  ← gotcha!

# Starting set of confirmed attendees at an event
attendees = {"Alice", "Bob", "Carol"}

# ── Adding items ──────────────────────────────────────────────────────────
attendees.add("David")          # add one person
attendees.add("Alice")          # Alice is already there — nothing changes
print("After adding Alice again:", attendees)   # still only one Alice

attendees.update(["Eve", "Frank", "Grace"])   # add several people at once
print("After batch add:", attendees)

# ── Removing items ────────────────────────────────────────────────────────
attendees.remove("Bob")          # Bob cancelled — we're sure he's in the set
print("After removing Bob:", attendees)

attendees.discard("Zara")        # Zara was never there — discard won't crash
print("After discarding Zara (who wasn't there):", attendees)

# attendees.remove("Zara")       # ← this WOULD raise KeyError — commented out

# ── Membership testing — the fastest way to check ─────────────────────────
print("Is Alice attending?", "Alice" in attendees)    # True
print("Is Bob attending? ", "Bob" in attendees)       # False — we removed him

# ── Practical example: deduplicating user IDs from two data sources ────────
app_logins   = [101, 102, 103, 102, 104, 101]   # raw log with repeats
unique_users = set(app_logins)                  # instant deduplication
print("Unique user IDs:", unique_users)
print("Count:", len(unique_users))              # 4 unique users

# Two streaming platforms and their exclusive shows
netflix_shows  = {"Stranger Things", "Ozark", "The Crown", "Dark", "Squid Game"}
disney_shows   = {"The Mandalorian", "WandaVision", "Squid Game", "The Crown", "Loki"}
# Note: "Squid Game" and "The Crown" are on both (hypothetically)

# ── UNION — everything available on either platform ───────────────────────
all_shows = netflix_shows | disney_shows
print("All shows across both platforms:")
print(all_shows)
print(f"Total unique titles: {len(all_shows)}\n")

# ── INTERSECTION — shows available on BOTH platforms ─────────────────────
shared_shows = netflix_shows & disney_shows
print("Shows on BOTH platforms (overlaps):")
print(shared_shows)   # {'Squid Game', 'The Crown'}
print()

# ── DIFFERENCE — shows ONLY on Netflix (not on Disney) ───────────────────
netflix_only = netflix_shows - disney_shows
print("Shows exclusive to Netflix:")
print(netflix_only)
print()

# ── SYMMETRIC DIFFERENCE — exclusives on each side ───────────────────────
exclusive_to_one_platform = netflix_shows ^ disney_shows
print("Shows exclusive to exactly one platform (not shared):")
print(exclusive_to_one_platform)
print()

# ── Real-world use case: which users are new today? ──────────────────────
users_yesterday = {"alice", "bob", "carol", "david"}
users_today     = {"alice", "carol", "eve", "frank"}

new_users     = users_today - users_yesterday    # signed up since yesterday
lost_users    = users_yesterday - users_today    # didn't return today
loyal_users   = users_today & users_yesterday    # came back both days

print("New users today:  ", new_users)
print("Users who left:   ", lost_users)
print("Loyal returning:  ", loyal_users)

# Regular set — mutable, cannot be used as a dictionary key
read_write_permissions = {"read", "write", "delete"}

# Frozenset — immutable, CAN be used as a dictionary key
admin_permissions    = frozenset({"read", "write", "delete", "admin"})
viewer_permissions   = frozenset({"read"})
editor_permissions   = frozenset({"read", "write"})

# Using frozensets as dictionary KEYS — impossible with regular sets
permission_to_role = {
    admin_permissions  : "Administrator",
    editor_permissions : "Editor",
    viewer_permissions : "Viewer",
}

# Look up what role a set of permissions maps to
user_perms = frozenset({"read", "write"})
print("User role:", permission_to_role[user_perms])   # Editor

# Frozensets support all the same math as regular sets
common = admin_permissions & editor_permissions
print("Shared permissions (admin & editor):", common)

# Attempting to modify a frozenset raises AttributeError
try:
    viewer_permissions.add("write")    # this will fail
except AttributeError as error:
    print(f"Cannot modify frozenset: {error}")

# You CAN put a frozenset inside a regular set
all_roles = {admin_permissions, editor_permissions, viewer_permissions}
print("Number of distinct roles:", len(all_roles))   # 3

# ── Basic set comprehension ──────────────────────────────────────────────
# Get unique squares of numbers 0-9
squares = {x**2 for x in range(10)}
print("Unique squares:", squares)   # {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}

# ── With condition ─────────────────────────────────────────────────────────
# Get unique lengths of words with length > 3
words = ["hello", "world", "hi", "python", "set", "comprehension"]
lengths = {len(w) for w in words if len(w) > 3}
print("Unique lengths > 3:", lengths)   # {5, 6, 13}

# ── Real-world: unique user domains from email list ───────────────────────
emails = ["alice@example.com", "bob@test.org", "carol@example.com", "dave@test.org"]
domains = {email.split('@')[1] for email in emails}
print("Unique domains:", domains)   # {'test.org', 'example.com'}

# ── set() with generator is similar but less readable ─────────────────────
same_domains = set(email.split('@')[1] for email in emails)
print("Same with generator:", same_domains)

# ── Hash collision can degrade performance ────────────────────────────────
class BadHash:
    def __hash__(self):
        return 42  # terrible idea — all objects collide
    def __eq__(self, other):
        return self is other

elements = [BadHash() for _ in range(1000)]
s = set(elements)
# Membership check is O(n) in the worst case — each call goes through full chain
import timeit
# (Example only — actual slowdown varies)

# ── Memory overhead comparison ─────────────────────────────────────────────
import sys
items_list = list(range(100_000))
items_set = set(items_list)
print(f"List size: {sys.getsizeof(items_list)} bytes")
print(f"Set size:  {sys.getsizeof(items_set)} bytes")   # set is ~4x larger

# ── Mutation after insertion — the silent bug ───────────────────────────
class MutableKey:
    def __init__(self, val):
        self.val = val
    def __hash__(self):
        return hash(self.val)
    def __eq__(self, other):
        return self.val == other.val

k = MutableKey(10)
s = set([k])
k.val = 20                  # mutation changes hash
print("10 in set:", MutableKey(10) in s)   # False — item is lost!
print("20 in set:", MutableKey(20) in s)   # False — hash changed
# Lesson: never mutate objects after adding them to a set