Nested Data Structures

employees = [
    {"name": "Priya Nair", "department": "Engineering", "salary": 118000},
    {"name": "Wei Zhang", "department": "Engineering", "salary": 121000},
    {"name": "Alex Torres", "department": "Sales", "salary": 95000},
]

# This is exactly what a database query, or a JSON API response, typically looks like

employees_by_department = {
    "Engineering": ["Priya Nair", "Wei Zhang"],
    "Sales": ["Alex Torres"],
}

# The exact output shape you'd get from grouping the list above by department —
# using the defaultdict pattern from Module 11

user = {
    "name": "Maria Gomez",
    "address": {
        "city": "Portland",
        "state": "OR",
    },
}

print(user["address"]["zip"])
# KeyError: 'zip' — this key was simply never provided for this user

zip_code = user.get("address", {}).get("zip", "unknown")
print(zip_code)   # "unknown" — no crash

# Read this right to left in terms of what it protects against:
# .get("zip", "unknown")     -> if "zip" is missing, use "unknown"
# .get("address", {})        -> if "address" itself is missing, fall back to an empty dict,
#                                so the next .get() has something safe to call itself on

order = {"items": [{"sku": "A1"}, {"sku": "B2"}]}

# Naive — crashes if "items" has fewer than 3 entries
third_item = order["items"][2]   # IndexError

# Guarded
items = order.get("items", [])
third_item = items[2] if len(items) > 2 else None

orders = [
    {
        "order_id": "ORD-1001",
        "customer": {"name": "Maria Gomez", "city": "Portland", "state": "OR"},
        "items": [
            {"sku": "MUG-01", "qty": 2, "price": 12.00},
            {"sku": "SHIRT-04", "qty": 1, "price": 28.00},
        ],
    },
    {
        "order_id": "ORD-1002",
        "customer": {"name": "James Reilly", "city": "Boston", "state": "MA"},
        "items": [
            {"sku": "MUG-01", "qty": 1, "price": 12.00},
        ],
    },
    {
        "order_id": "ORD-1003",
        "customer": {"name": "Maria Gomez", "city": "Portland", "state": "OR"},
        "items": [
            {"sku": "HAT-02", "qty": 3, "price": 18.00},
            {"sku": "MUG-01", "qty": 1, "price": 12.00},
        ],
    },
]

for order in orders:
    total = sum(item["qty"] * item["price"] for item in order["items"])
    print(f"{order['order_id']}: ${total:.2f}")

# ORD-1001: $52.00
# ORD-1002: $12.00
# ORD-1003: $66.00

def order_total(order):
    return sum(item["qty"] * item["price"] for item in order["items"])

orders_by_total = sorted(orders, key=order_total, reverse=True)

for o in orders_by_total:
    print(o["order_id"], order_total(o))
# ORD-1003 66.0
# ORD-1001 52.0
# ORD-1002 12.0

from operator import itemgetter

customers_flat = [o["customer"] for o in orders]
by_city = sorted(customers_flat, key=itemgetter("city"))

for c in by_city:
    print(c["city"], c["name"])
# Boston James Reilly
# Portland Maria Gomez
# Portland Maria Gomez

# Equivalent lambda, for comparison:
by_city = sorted(customers_flat, key=lambda c: c["city"])

from collections import defaultdict

totals_by_customer = defaultdict(float)

for order in orders:
    name = order["customer"]["name"]
    order_total = sum(item["qty"] * item["price"] for item in order["items"])
    totals_by_customer[name] += order_total

print(dict(totals_by_customer))
# {"Maria Gomez": 118.0, "James Reilly": 12.0}
# Maria Gomez's two orders (ORD-1001 and ORD-1003) were automatically combined

unit_counts = defaultdict(int)

for order in orders:
    for item in order["items"]:
        unit_counts[item["sku"]] += item["qty"]

print(dict(unit_counts))
# {"MUG-01": 4, "SHIRT-04": 1, "HAT-02": 3}

orders_by_state = defaultdict(list)

for order in orders:
    state = order["customer"]["state"]
    orders_by_state[state].append(order["order_id"])

print(dict(orders_by_state))
# {"OR": ["ORD-1001", "ORD-1003"], "MA": ["ORD-1002"]}

flat_rows = []

for order in orders:
    for item in order["items"]:
        flat_rows.append({
            "order_id": order["order_id"],
            "customer_name": order["customer"]["name"],
            "customer_city": order["customer"]["city"],
            "sku": item["sku"],
            "qty": item["qty"],
            "price": item["price"],
        })

for row in flat_rows[:2]:
    print(row)
# {'order_id': 'ORD-1001', 'customer_name': 'Maria Gomez', 'customer_city': 'Portland', 'sku': 'MUG-01', 'qty': 2, 'price': 12.0}
# {'order_id': 'ORD-1001', 'customer_name': 'Maria Gomez', 'customer_city': 'Portland', 'sku': 'SHIRT-04', 'qty': 1, 'price': 28.0}

flat_rows = [
    {
        "order_id": order["order_id"],
        "customer_name": order["customer"]["name"],
        "sku": item["sku"],
        "qty": item["qty"],
    }
    for order in orders
    for item in order["items"]
]
# Same two-for-clause flattening pattern from Module 12 — genuinely readable here,
# since there's exactly one level of nesting and no additional filter or ternary.

response = {
    "data": {
        "customers": [
            {
                "id": 501,
                "orders": [
                    {"id": "ORD-1001", "items": [{"sku": "MUG-01", "discounts": [{"code": "WELCOME10"}]}]}
                ],
            }
        ]
    }
}

# Reaching six levels deep for one value is technically possible...
first_discount_code = response["data"]["customers"][0]["orders"][0]["items"][0]["discounts"][0]["code"]
# ...but it is fragile, unreadable, and will be the first thing to break the next time the API
# response shape changes even slightly.

def extract_discount_codes(api_response):
    codes = []
    for customer in api_response.get("data", {}).get("customers", []):
        for order in customer.get("orders", []):
            for item in order.get("items", []):
                for discount in item.get("discounts", []):
                    codes.append(discount.get("code"))
    return codes

# Every other function in the codebase now just works with a flat list of strings —
# no other function needs to know the original response was six levels deep.

A Minneapolis retailer's nightly job pulls order data from a fulfillment partner's API and emails a summary of revenue by state to the operations team every morning. It has run reliably for months. One Tuesday, the job crashes at 3 a.m. and no report goes out.

revenue_by_state = defaultdict(float)
for order in api_orders:
    state = order["customer"]["state"]
    total = sum(item["qty"] * item["price"] for item in order["items"])
    revenue_by_state[state] += total

# KeyError: 'state'

What the investigation finds

The fulfillment partner had shipped a change the day before: for a small number of orders placed through a new in-store kiosk, the customer object omitted state entirely when the customer checked out as a guest without providing a full address. Every order in the historical test data happened to include state, so the naive order["customer"]["state"] chain — exactly the fragile pattern from Part 02 — had simply never been exercised against a missing field until that one guest order came through in production.

The fix

The engineer rewrites the access using the safe .get() chaining pattern from Part 02, with an explicit fallback bucket for orders missing location data — so the report still runs completely, and the missing-data orders become visible as a line item instead of a silent crash.

revenue_by_state = defaultdict(float)
for order in api_orders:
    state = order.get("customer", {}).get("state", "UNKNOWN")
    total = sum(item["qty"] * item["price"] for item in order["items"])
    revenue_by_state[state] += total

# "UNKNOWN" now shows up as its own line in the report — visible and actionable,
# instead of crashing the entire job over a handful of orders.

The team also adds the normalize-at-the-boundary pattern from Part 07: a single parse_order() function that walks the raw API response once, fills in explicit defaults for every optional field, and hands the rest of the pipeline a clean, predictable structure — so the next time the partner's API shape shifts slightly, exactly one function needs to change, not every report that touches order data.