Python Dictionaries — Silent Key Overwrites in Merges

product_prices = {
    "Laptop": 999.99,
    "Mouse": 29.99,
    "Keyboard": 79.99,
    "Monitor": 349.99
}

# --- Loop 1: Keys only ---
print("=== Product Names ===")
for product_name in product_prices:
    print("-", product_name)  # each iteration gives us one key

# --- Loop 2: Values only ---
print("\n=== All Prices ===")
total = 0
for price in product_prices.values():
    total += price           # accumulate a running total
print(f"Total inventory value: ${total:.2f}")

# --- Loop 3: Keys AND Values together (the most common pattern) ---
print("\n=== Full Price List ===")
for product_name, price in product_prices.items():  # unpacks each pair
    if price > 100:
        label = "Premium"   # flag expensive items
    else:
        label = "Budget"
    print(f"{product_name}: ${price:.2f} ({label})")

# --- Checking if a key exists before accessing it ---
search_term = "Webcam"
if search_term in product_prices:       # 'in' checks keys by default
    print(f"\nFound {search_term}: ${product_prices[search_term]}")
else:
    print(f"\n'{search_term}' is not in our catalogue.")

# A dictionary of users — each key is a user ID, each value is another dictionary
user_database = {
    "usr_001": {
        "username": "mariachen",
        "email": "maria@example.com",
        "address": {
            "street": "14 Elm Street",
            "city": "Austin",
            "postcode": "73301"
        },
        "is_premium": True
    },
    "usr_002": {
        "username": "jakethompson",
        "email": "jake@example.com",
        "address": {
            "street": "9 Oak Avenue",
            "city": "Denver",
            "postcode": "80201"
        },
        "is_premium": False
    }
}

# Access a top-level value
print(user_database["usr_001"]["username"])  # chain brackets to go deeper

# Access a deeply nested value
print(user_database["usr_001"]["address"]["city"])

# Safe access with .get() at each level — no crash if a key is missing
user = user_database.get("usr_003", {})          # returns empty dict if not found
city = user.get("address", {}).get("city", "Unknown")
print("City for usr_003:", city)                  # gracefully returns 'Unknown'

# Loop through all users and print a summary
print("\n=== User Summary ===")
for user_id, user_info in user_database.items():
    tier = "Premium" if user_info["is_premium"] else "Free"
    city = user_info["address"]["city"]
    print(f"{user_id} | @{user_info['username']} | {city} | {tier}")

# Basic: square each number from 1 to 5
squares = {x: x**2 for x in range(1, 6)}
print(squares)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Filter: only squares of even numbers
squares_even = {x: x**2 for x in range(1, 11) if x % 2 == 0}
print(squares_even)  # {2: 4, 4: 16, 6: 36, 8: 64, 10: 100}

# Transform a list of tuples into a dict
pairs = [("a", 1), ("b", 2), ("c", 3)]
my_dict = {k: v for k, v in pairs}
print(my_dict)  # {'a': 1, 'b': 2, 'c': 3}

# Swap keys and values (if values are unique)
original = {"x": 10, "y": 20}
swapped = {v: k for k, v in original.items()}
print(swapped)  # {10: 'x', 20: 'y'}

# Using a function: convert Celsius to Fahrenheit
celsius = {"Monday": 20, "Tuesday": 25, "Wednesday": 30}
fahrenheit = {day: (temp * 9/5) + 32 for day, temp in celsius.items()}
print(fahrenheit)  # {'Monday': 68.0, 'Tuesday': 77.0, 'Wednesday': 86.0}

# io.thecodeforge
def sigma(x):
    return sum(ord(c) for c in str(x))

# Simulating what dict sees: hash determines bucket
class BadKey:
    def __init__(self, val):
        self.val = val
    def __hash__(self):
        return sigma(self.val)
    def __eq__(self, other):
        return self.val == other.val

cache = {}
key = BadKey("order_42")
cache[key] = "pending"

# Changing the value after hashing — corrupts the bucket
key.val = "order_99"
print(cache.get(key, "MISS — key mutated after insertion"))

# io.thecodeforge
order_queue = {
    "ORD-1001": 4,
    "ORD-1002": 12,
    "ORD-1003": 7,
}

# Bad: del crashes on missing key
try:
    del order_queue["ORD-9999"]
except KeyError:
    pass  # swallowing errors — terrible pattern

# Good: pop with default
processed = order_queue.pop("ORD-1001", None)
if processed is not None:
    print(f"Shipped {processed} units from ORD-1001")

# Cleanup: drain remaining in insertion order
while order_queue:
    order_id, units = order_queue.popitem()
    print(f"Drained {order_id}: {units} units")

# io.thecodeforge
from collections import ChainMap

defaults = {"host": "localhost", "port": 5432, "debug": False}
overrides = {"port": 8080, "user": "admin"}

# Bad: update mutates and overwrites
config = defaults.copy()
config.update(overrides)  # port changed, debug lost forever if overrides had it

# Good: ChainMap preserves originals without copying
safe_config = ChainMap(overrides, defaults)  # overrides checked first
print(safe_config["host"])   # from defaults
print(safe_config["port"])   # from overrides (8080)
print(safe_config["debug"])  # from defaults (False)

# For merging nested dicts, write a recursive function
def deep_merge(base, overrides):
    merged = base.copy()
    for key, val in overrides.items():
        if key in merged and isinstance(merged[key], dict) and isinstance(val, dict):
            merged[key] = deep_merge(merged[key], val)
        else:
            merged[key] = val
    return merged

conflicting = {"database": {"host": "old", "port": 5432}}
with_overrides = {"database": {"host": "new", "pool": 10}}
print(deep_merge(conflicting, with_overrides))