Python Dictionary Deep Dive: Hashing, Ordering, and Advanced Patterns

# Direct literal
person = {"name": "Alice", "age": 30, "role": "engineer"}

# dict() constructor — from keyword arguments
settings = dict(host="localhost", port=5432, debug=False)

# dict() from an iterable of key-value pairs
pairs = [("a", 1), ("b", 2), ("c", 3)]
from_pairs = dict(pairs)

# Dict comprehension
squares = {x: x**2 for x in range(1, 6)}
print(squares)   # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Filter with comprehension
high_scores = {k: v for k, v in {"Alice": 85, "Bob": 92, "Carol": 78}.items() if v >= 90}
print(high_scores)   # {'Bob': 92}

d = {}
d["third"] = 3
d["first"] = 1
d["second"] = 2

print(list(d.keys()))    # ['third', 'first', 'second'] — insertion order
print(list(d.values()))  # [3, 1, 2]
print(list(d.items()))   # [('third', 3), ('first', 1), ('second', 2)]

config = {"timeout": 30, "retries": 3, "debug": False}

# Access — raises KeyError if missing
print(config["timeout"])    # 30

# Safe access with default
print(config.get("host", "localhost"))   # "localhost" — no error

# setdefault — set and return default if key missing, otherwise return existing
config.setdefault("port", 5432)   # adds port=5432 if not present
print(config["port"])             # 5432

# Update from another dict
config.update({"timeout": 60, "log_level": "INFO"})
print(config)

defaults = {"color": "blue", "size": "medium", "weight": 1.0}
user_prefs = {"color": "red", "size": "large"}

# Python 3.9+ — creates a new merged dict, right side wins on conflicts
merged = defaults | user_prefs
print(merged)
# {'color': 'red', 'size': 'large', 'weight': 1.0}

# In-place update
defaults |= user_prefs   # modifies defaults in place

# Pre-3.9 equivalent
merged_old = {**defaults, **user_prefs}

from collections import defaultdict

transactions = [
    {"user": "Alice", "amount": 50},
    {"user": "Bob", "amount": 30},
    {"user": "Alice", "amount": 75},
    {"user": "Bob", "amount": 20},
]

by_user = defaultdict(list)
for t in transactions:
    by_user[t["user"]].append(t["amount"])

print(dict(by_user))
# {'Alice': [50, 75], 'Bob': [30, 20]}

# Totals per user
totals = {user: sum(amounts) for user, amounts in by_user.items()}
print(totals)   # {'Alice': 125, 'Bob': 50}

original = {"a": 1, "b": 2, "c": 3}
inverted = {v: k for k, v in original.items()}
print(inverted)   # {1: 'a', 2: 'b', 3: 'c'}
# Note: only works cleanly when values are unique and hashable

# Manual approach
data = {"user": {"profile": {"name": "Alice"}}}
name = data.get("user", {}).get("profile", {}).get("name", "Unknown")
print(name)   # "Alice"

# Using a helper
def safe_get(d, *keys, default=None):
    """Safely traverse a nested dict."""
    for key in keys:
        if not isinstance(d, dict):
            return default
        d = d.get(key, default)
    return d

print(safe_get(data, "user", "profile", "name"))     # "Alice"
print(safe_get(data, "user", "address", "city"))     # None

inventory = {"apple": 5, "banana": 3, "cherry": 12}

# Keys (default iteration)
for key in inventory:
    print(key)

# Values
for value in inventory.values():
    print(value)

# Key-value pairs — the most common pattern
for item, count in inventory.items():
    print(f"{item}: {count}")

# Do NOT modify a dict while iterating — raises RuntimeError
# Correct approach: iterate over a copy
for key in list(inventory.keys()):
    if inventory[key] < 5:
        del inventory[key]   # safe — iterating over a copy of keys

# Valid keys
d = {
    "string_key": 1,
    42: 2,
    (1, 2): 3,       # tuple of ints — hashable
    True: 4,         # bool is hashable (note: True == 1, so True and 1 are the same key)
}

# Invalid
try:
    bad = {[1, 2]: "value"}   # list is not hashable
except TypeError as e:
    print(f"Cannot use list as key: {e}")