user = {"name": "Ada", "role": "engineer", "active": True}

# Basic access
user["name"]                      # "Ada"              O(1)
user.get("email")                 # None               O(1) — safe, no KeyError
user.get("email", "unknown")      # "unknown"          O(1) — with default
"role" in user                    # True               O(1) key membership
"salary" in user                  # False

# Mutation
user["email"] = "ada@x.io"        # insert or overwrite   O(1)
del user["active"]                # delete by key          O(1)
user.pop("role", None)            # delete + return, safe if missing

# Iteration — dicts preserve insertion order (Python 3.7+)
for key in user:                  # iterates keys
    print(key)
for key, val in user.items():     # iterates (key, value) pairs
    print(f"{key}: {val}")
list(user.keys())                 # ['name', 'email']
list(user.values())               # ['Ada', 'ada@x.io']

# Merge and update (Python 3.9+)
defaults = {"timeout": 30, "retries": 3}
config   = {"timeout": 60, "debug": True}
merged = defaults | config        # {'timeout': 60, 'retries': 3, 'debug': True}
# right side wins on collision

# dict comprehension
squares = {n: n**2 for n in range(6)}
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Invert a dict (assuming unique values)
inv = {v: k for k, v in squares.items()}

from collections import defaultdict

# PATTERN 1: Frequency counting
events = ["click", "view", "click", "purchase", "view", "click"]

# Manual with .get()
freq = {}
for e in events:
    freq[e] = freq.get(e, 0) + 1
# {"click": 3, "view": 2, "purchase": 1}

# Idiomatic with defaultdict
freq2 = defaultdict(int)
for e in events:
    freq2[e] += 1   # missing key auto-initializes to int() = 0

# Best: Counter (covered in 5.4)
from collections import Counter
Counter(events)     # Counter({'click': 3, 'view': 2, 'purchase': 1})

# PATTERN 2: Grouping (one-to-many)
orders = [
    {"id": 1, "region": "EU", "amount": 120},
    {"id": 2, "region": "US", "amount": 85},
    {"id": 3, "region": "EU", "amount": 200},
    {"id": 4, "region": "US", "amount": 310},
]

by_region = defaultdict(list)
for order in orders:
    by_region[order["region"]].append(order["amount"])
# {"EU": [120, 200], "US": [85, 310]}

# PATTERN 3: Replacing an O(n) loop with an O(1) dict lookup
# Two-sum: find two indices whose values sum to target
def two_sum(nums, target):
    seen = {}                        # value -> index
    for i, n in enumerate(nums):
        complement = target - n
        if complement in seen:       # O(1) lookup
            return [seen[complement], i]
        seen[n] = i
    return []

two_sum([2, 7, 11, 15], 9)   # [0, 1]  — O(n) total, not O(n²)

# Set creation
active_users = {"alice", "bob", "carol"}    # literal syntax
ids = set([1, 2, 2, 3, 3, 3])              # deduplication: {1, 2, 3}
empty = set()                               # NOT {} — that's an empty dict!

# Membership — O(1)
"alice" in active_users    # True
"dave"  in active_users    # False

# Modification
active_users.add("dave")
active_users.discard("bob")    # remove if present, no error if missing
active_users.remove("bob")     # removes; raises KeyError if missing

# Set algebra — real-world: user overlap analysis
paying     = {"alice", "carol", "eve"}
trial      = {"bob", "carol", "frank"}

paying & trial          # intersection: {"carol"}       — both groups
paying | trial          # union: all users in either
paying - trial          # difference: paying but NOT trial: {"alice", "eve"}
trial  - paying         # trial but NOT paying: {"bob", "frank"}
paying ^ trial          # symmetric difference: in one but not both

# Subset / superset checks
{"alice"} <= paying     # True  — issubset
paying >= {"alice"}     # True  — issuperset

# Frozenset: immutable set (hashable — can be a dict key or set member)
cache_key = frozenset(["read", "write"])
permissions = {cache_key: True}