{"title":"defaultdict","description":"","content":"`defaultdict` is a dictionary subclass from the `collections` module that removes the \"check if the key exists, and if not, create an empty value\" boilerplate that shows up every time you group, count, or index data. You tell it what the default should be, and it builds the entry for you the first time a missing key is touched. This lesson covers the factory functions, the common patterns, and the pitfalls.\n\n---\n\n# The Problem `defaultdict` Solves\n\nPicture this. You have a list of orders, each tagged with a customer ID, and you want to group them so you can see every order a given customer placed. With a plain dict, the natural code looks like this:\n\n\n```python\norders = [\n (\"alice\", \"Wireless Mouse\"),\n (\"bob\", \"USB Cable\"),\n (\"alice\", \"HDMI Cable\"),\n (\"carol\", \"Webcam\"),\n (\"bob\", \"Mechanical Keyboard\"),\n (\"alice\", \"Monitor Stand\"),\n]\n\norders_by_customer = {}\nfor customer, product in orders:\n if customer not in orders_by_customer:\n orders_by_customer[customer] = []\n orders_by_customer[customer].append(product)\n\nprint(orders_by_customer)\n```\n\n\nThe logic works, but those three lines in the middle (`if customer not in ...`, create the list, append) are pure boilerplate. The interesting work is just `append`. Every grouping, counting, or indexing job repeats this dance.\n\n`dict.setdefault` is the first cleanup you might reach for:\n\n\n```python\norders_by_customer = {}\nfor customer, product in orders:\n orders_by_customer.setdefault(customer, []).append(product)\n```\n\n\nBetter. The `if` is gone. But `setdefault` has a subtle cost: the default value (`[]` here) is constructed on **every** call, whether the key is missing or not. For a list it's cheap, but if the default were something heavier, you'd be allocating a new object on every iteration just to throw it away.\n\n`defaultdict` removes both the boilerplate and the wasted construction:\n\n\n```python\nfrom collections import defaultdict\n\norders_by_customer = defaultdict(list)\nfor customer, product in orders:\n orders_by_customer[customer].append(product)\n\nprint(dict(orders_by_customer))\n```\n\n\nThe grouping loop is now one line of logic. When `orders_by_customer[\"alice\"]` is accessed for the first time, `defaultdict` calls `list()`, stores the empty list under `\"alice\"`, and returns it. The `.append(\"Wireless Mouse\")` then runs on that fresh list. The second time `orders_by_customer[\"alice\"]` is touched, the list is already there, so no construction happens.\n\n---\n\n# How `defaultdict` Actually Works\n\n`defaultdict` is a subclass of `dict`. Everything you know about dictionaries (`get`, `pop`, `keys`, `values`, iteration, comprehensions) carries over. The only thing it adds is a hook for missing keys.\n\nYou construct it with a **factory**: a zero-argument callable that produces the default value. `list`, `int`, `set`, `dict`, and any custom function or lambda all qualify.\n\n\n```python\nfrom collections import defaultdict\n\ncart_counts = defaultdict(int)\nprint(cart_counts[\"wireless mouse\"])\nprint(cart_counts)\n```\n\n\nThree things to notice. First, `cart_counts[\"wireless mouse\"]` didn't raise `KeyError` even though the key was never set. Second, it returned `0`, which is what `int()` produces. Third, the key now exists in the dictionary. `defaultdict` didn't just give you a default value on the fly; it actually inserted the entry.\n\n\n```mermaid\nflowchart TD\n Access[\"d[key] access\"]:::cyan\n Check{\"Key in dict?\"}:::orange\n Return[\"Return existing
value\"]:::green\n Factory[\"Call default_factory()\"]:::teal\n Insert[\"Insert factory result
under key\"]:::teal\n ReturnNew[\"Return new value\"]:::green\n\n Access --> Check\n Check -->|\"yes\"| Return\n Check -->|\"no\"| Factory\n Factory --> Insert\n Insert --> ReturnNew\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n```\n\n\nThe flow on the right (the orange \"no\" branch) is the whole reason `defaultdict` exists. It's a small piece of machinery, but it's the difference between writing the grouping loop in three lines and writing it in one.\n\nThe factory is called with **no arguments**. That's why you pass `list` and not `list()`. You're handing `defaultdict` the function itself, and `defaultdict` calls it later, only when it needs to.\n\n\n```python\nfrom collections import defaultdict\n\n# Pass the function, not a call.\ngood = defaultdict(list)\n\n# This is wrong. list() is an empty list, and you can't call a list.\nbad = defaultdict(list())\nbad[\"alice\"]\n```\n\n\nThe error fires the moment you access a missing key, not at construction. The fix is to drop the parentheses: the factory has to be callable.\n\n---\n\n# Grouping: `defaultdict(list)` and `.append`\n\nGrouping is the single most common use of `defaultdict`. Anywhere you have records tagged by a category and want a list of records per category, `defaultdict(list)` is the right tool.\n\n\n```python\nfrom collections import defaultdict\n\nproducts = [\n (\"Wireless Mouse\", \"Electronics\"),\n (\"USB Cable\", \"Cables\"),\n (\"HDMI Cable\", \"Cables\"),\n (\"Webcam\", \"Electronics\"),\n (\"Coffee Mug\", \"Kitchen\"),\n (\"Mechanical Keyboard\", \"Electronics\"),\n (\"Power Strip\", \"Cables\"),\n]\n\nby_category = defaultdict(list)\nfor name, category in products:\n by_category[category].append(name)\n\nfor category, names in by_category.items():\n print(f\"{category}: {names}\")\n```\n\n\nThe first time a category is seen, `defaultdict` calls `list()` to build an empty list and stores it under that category key. From that point on, the key exists and `append` just adds to the existing list. The whole grouping is one loop body line.\n\nThis pattern works for any \"many records per key\" shape. Group orders by customer, reviews by product, employees by department, deliveries by date, refunds by reason. The factory stays `list`, only the iteration changes.\n\n\n> **INFO**\n>\n> **Cost:** `defaultdict(list)` and the equivalent `setdefault(key, []).append(...)` both end up with the same final dict, but `setdefault` calls `list()` on every iteration (even when the key already exists). For tight loops over millions of items, the difference matters; for typical code, both are fine.\n\n\n---\n\n# Counting: `defaultdict(int)` and `+= 1`\n\nThe second most common pattern is counting. If the factory is `int`, the default value is `0` (because `int()` returns `0`), and `+=` on a missing key works out naturally.\n\n\n```python\nfrom collections import defaultdict\n\ncart = [\"Wireless Mouse\", \"USB Cable\", \"USB Cable\", \"HDMI Cable\", \"Wireless Mouse\", \"USB Cable\"]\n\nquantities = defaultdict(int)\nfor item in cart:\n quantities[item] += 1\n\nprint(dict(quantities))\n```\n\n\nWhen `quantities[\"Wireless Mouse\"]` is touched for the first time, the factory produces `0`, the entry is inserted, and `+= 1` makes it `1`. Subsequent appearances of `\"Wireless Mouse\"` find the existing entry and bump it.\n\nThis works for any aggregation that starts at zero: totals, counts, running sums. The factory `int` is doing more than counting; it's shorthand for \"the additive identity, which is 0\".\n\n\n```python\nfrom collections import defaultdict\n\norders = [\n (\"alice\", 29.99),\n (\"bob\", 14.99),\n (\"alice\", 4.99),\n (\"carol\", 89.99),\n (\"bob\", 19.99),\n (\"alice\", 9.99),\n]\n\ntotal_per_customer = defaultdict(float)\nfor customer, amount in orders:\n total_per_customer[customer] += amount\n\nfor customer, total in total_per_customer.items():\n print(f\"{customer}: ${total:.2f}\")\n```\n\n\nSame shape, different factory (`float` instead of `int`), different operation (`+= amount` instead of `+= 1`). Both rely on the same idea: the factory produces the identity value for the operation you're going to perform.\n\n### A note on `Counter`\n\nIf you're doing pure counting (incrementing by 1 per occurrence), the standard library has a more specialized tool: `collections.Counter`. It's a `defaultdict(int)` cousin with extras like `.most_common(n)`, addition/subtraction of counts, and built-in handling of any iterable.\n\n\n```python\nfrom collections import Counter\n\ncart = [\"Wireless Mouse\", \"USB Cable\", \"USB Cable\", \"HDMI Cable\", \"Wireless Mouse\", \"USB Cable\"]\nprint(Counter(cart))\nprint(Counter(cart).most_common(2))\n```\n\n\nFor straight counting, prefer `Counter`. Reach for `defaultdict(int)` when you're incrementing by varying amounts (totals, weighted sums) or when you want a single structure that mixes counts with other operations.\n\n---\n\n# Building a Multi-Value Index: `defaultdict(set)`\n\nSometimes you want to group items, but with duplicates removed and membership tests in O(1). That's what `set` is for, and `defaultdict(set)` plus `.add` gives you a clean way to build a multi-value index.\n\nA tag-to-products index is the textbook example. Every product can have multiple tags, and you want to look up \"all products with the tag `bestseller`\" without scanning the whole catalog.\n\n\n```python\nfrom collections import defaultdict\n\nproducts = [\n (\"Wireless Mouse\", [\"electronics\", \"bestseller\", \"sale\"]),\n (\"USB Cable\", [\"cables\", \"bestseller\"]),\n (\"HDMI Cable\", [\"cables\", \"sale\"]),\n (\"Webcam\", [\"electronics\", \"new\"]),\n (\"Mechanical Keyboard\", [\"electronics\", \"bestseller\"]),\n]\n\nproducts_by_tag = defaultdict(set)\nfor name, tags in products:\n for tag in tags:\n products_by_tag[tag].add(name)\n\nfor tag in sorted(products_by_tag):\n print(f\"{tag}: {sorted(products_by_tag[tag])}\")\n```\n\n\nTwo things are happening that `set` does for you. First, if the same `(product, tag)` pair somehow appears twice in the source data, the set guarantees the product only shows up once under that tag. Second, lookups like `\"Wireless Mouse\" in products_by_tag[\"bestseller\"]` are O(1) instead of O(n) with a list. For an index that's queried often, that matters.\n\n\n> **INFO**\n>\n> **Cost:** `set.add` is O(1) on average; `list.append` is also O(1). The difference shows up at lookup time: `x in some_set` is O(1), `x in some_list` is O(n). If you're going to test membership repeatedly, the set is worth the slightly different shape.\n\n\nThe reverse index (product to tags) is the same pattern with the roles swapped:\n\n\n```python\nfrom collections import defaultdict\n\nproducts = [\n (\"Wireless Mouse\", [\"electronics\", \"bestseller\", \"sale\"]),\n (\"USB Cable\", [\"cables\", \"bestseller\"]),\n (\"HDMI Cable\", [\"cables\", \"sale\"]),\n]\n\ntags_by_product = defaultdict(set)\nfor name, tags in products:\n tags_by_product[name].update(tags)\n\nfor product, tags in tags_by_product.items():\n print(f\"{product}: {sorted(tags)}\")\n```\n\n\n`set.update(iterable)` is the bulk version of `add`; it's the right call when the value coming in is already a collection.\n\n---\n\n# Nested Defaults With Lambdas\n\nSometimes the default needs to be something other than the five built-in factory types. Maybe you want `defaultdict(int)` nested inside another `defaultdict`, so you can do `counts[customer][product] += 1` without thinking about either level. A `lambda` lets you build any zero-argument factory.\n\n\n```python\nfrom collections import defaultdict\n\norders = [\n (\"alice\", \"Wireless Mouse\"),\n (\"alice\", \"USB Cable\"),\n (\"alice\", \"Wireless Mouse\"),\n (\"bob\", \"HDMI Cable\"),\n (\"bob\", \"USB Cable\"),\n (\"bob\", \"USB Cable\"),\n]\n\ncounts_per_customer = defaultdict(lambda: defaultdict(int))\nfor customer, product in orders:\n counts_per_customer[customer][product] += 1\n\nfor customer, items in counts_per_customer.items():\n print(f\"{customer}: {dict(items)}\")\n```\n\n\nThe outer factory is `lambda: defaultdict(int)`. Each time a missing customer is touched, the lambda runs and produces a **fresh** inner `defaultdict(int)`. That inner dict in turn defaults to `0` for any missing product. Two layers of \"auto-create on access\", composed cleanly.\n\nWhy a lambda? Because `defaultdict(defaultdict(int))` would call `defaultdict(int)` **once**, at construction time, and share that same inner dictionary across every outer key. That's almost never what you want. The lambda defers construction, so each outer key gets its own inner dictionary.\n\n\n```python\nfrom collections import defaultdict\n\n# Wrong: every outer key shares the same inner dict.\nshared = defaultdict(defaultdict(int))\nshared[\"alice\"][\"Wireless Mouse\"] += 1\nshared[\"bob\"][\"Wireless Mouse\"] += 1\nprint(shared[\"alice\"])\nprint(shared[\"bob\"])\n```\n\n\nBoth customers see the same count, because both are reading and writing the same inner dictionary. The lambda form is the fix.\n\nLambdas also handle other custom defaults: a list of zeros, a tuple with sensible starting values, or any small object.\n\n\n```python\nfrom collections import defaultdict\n\n# Default to a list of zeros (e.g., counts across four cart statuses).\nstatus_counts = defaultdict(lambda: [0, 0, 0, 0])\n\nevents = [\n (\"alice\", 0), # placed\n (\"alice\", 2), # delivered\n (\"bob\", 0), # placed\n (\"alice\", 1), # shipped\n (\"carol\", 3), # cancelled\n (\"bob\", 0), # placed\n]\n\nfor customer, status_index in events:\n status_counts[customer][status_index] += 1\n\nprint(dict(status_counts))\n```\n\n\nThe lambda creates a fresh four-zero list for each new customer. Each customer's counts are independent because each access produces a new list.\n\n\n> **INFO**\n>\n> **Cost:** A `lambda` factory is slightly slower than a built-in factory like `list` or `int` because Python has to call back into Python code to run it. For most code this is invisible, but in tight loops over very large data you might prefer a regular function (defined with `def`) over a lambda for clarity, even though the speed is the same.\n\n\n---\n\n# `defaultdict` vs `dict.setdefault`\n\nBoth `defaultdict` and `dict.setdefault` solve the same surface problem: returning a default when a key is missing. The differences are in when the default is constructed and what gets inserted.\n\n\n| Behavior | `defaultdict(factory)` | `dict.setdefault(key, default)` |\n| --- | --- | --- |\n| When is the default value created? | Only when the key is missing | On every call (the value is the argument) |\n| What if the factory is expensive? | Called only when needed | Allocated every call, even on hits |\n| Where is the default policy defined? | Once, at construction | Repeated at every call site |\n| Returns | The (possibly newly inserted) value | The (possibly newly inserted) value |\n| Modifies the dict on missing key? | Yes (inserts and returns) | Yes (inserts and returns) |\n| Modifies the dict on existing key? | No (returns existing value) | No (returns existing value) |\n\n\nThe \"expensive default\" line is the one that bites people. Consider:\n\n\n```python\nfrom collections import defaultdict\n\ndef make_empty_report():\n print(\"building empty report...\")\n return {\"orders\": [], \"refunds\": [], \"total\": 0.0}\n\n# defaultdict: factory runs only on the misses.\ndd = defaultdict(make_empty_report)\ndd[\"alice\"]\ndd[\"alice\"]\ndd[\"alice\"]\n```\n\n\nOnly one \"building empty report...\" line, because the factory ran only on the first access. The next two reads found the existing entry.\n\nCompare to `setdefault`:\n\n\n```python\nreports = {}\nreports.setdefault(\"alice\", make_empty_report())\nreports.setdefault(\"alice\", make_empty_report())\nreports.setdefault(\"alice\", make_empty_report())\n```\n\n\nThe `make_empty_report()` call evaluates **before** Python calls `setdefault`, so it runs every time, even though only the first call's result is actually inserted. The other two reports are built and immediately discarded.\n\nFor cheap defaults like `[]` or `0`, this doesn't matter. For expensive ones, it does. `setdefault` is still useful when you need the lazy-create behavior at one or two spots and want to keep the type as a plain `dict`. For a loop that does grouping or counting, `defaultdict` wins.\n\n---\n\n# The Silent Key Creation Pitfall\n\nThis is the part most people get wrong on their first `defaultdict` bug. **Reading a missing key inserts it.** Not just `d[k] = ...`, but also `d[k]` and `d[k].append(...)` and even `if d[k]:`.\n\n\n```python\nfrom collections import defaultdict\n\nquantities = defaultdict(int)\nquantities[\"Wireless Mouse\"] = 2\nquantities[\"USB Cable\"] = 3\n\n# This looks like a read, but it's actually a write.\nif quantities[\"HDMI Cable\"]:\n print(\"HDMI Cable in cart\")\n\nprint(dict(quantities))\nprint(list(quantities.keys()))\n```\n\n\n`\"HDMI Cable\"` is now in the dictionary with a value of `0`, even though it was never explicitly added. The `if quantities[\"HDMI Cable\"]:` looked innocent, but the access went through `defaultdict`'s missing-key machinery, which both produced the default **and inserted it**. If you later iterate the keys to find products that were actually ordered, you'll see ghosts.\n\nTo safely check for a key without inserting, use `in` or `get`:\n\n\n```python\nfrom collections import defaultdict\n\nquantities = defaultdict(int)\nquantities[\"Wireless Mouse\"] = 2\n\n# Safe: doesn't insert.\nprint(\"HDMI Cable\" in quantities)\nprint(quantities.get(\"HDMI Cable\"))\nprint(quantities.get(\"HDMI Cable\", 0))\n\nprint(dict(quantities))\n```\n\n\n`in` returns a bool without touching the missing-key path. `get` returns `None` (or the default you pass) without inserting either.\n\nThe rule of thumb: **only use bracket notation (`d[key]`) when you actually want the auto-create behavior**. For any read that should be free of side effects, use `get` or `in`. Once that distinction is internal, the rest of the `defaultdict` API is simple.\n\n---\n\n# Converting Back to a Regular Dict\n\nOnce you've finished building a `defaultdict`, you often want to freeze it into a plain `dict`. Reasons include: serializing to JSON (which doesn't care, but plain dicts are easier to reason about), passing to code that expects exactly `dict`, or just preventing accidental auto-create from any later reader.\n\n\n```python\nfrom collections import defaultdict\n\norders_by_customer = defaultdict(list)\norders_by_customer[\"alice\"].append(\"Wireless Mouse\")\norders_by_customer[\"bob\"].append(\"USB Cable\")\n\n# It's still a defaultdict.\nprint(type(orders_by_customer))\n\n# Convert to plain dict.\nfrozen = dict(orders_by_customer)\nprint(type(frozen))\nprint(frozen)\n```\n\n\n`dict(some_defaultdict)` is a shallow conversion. It copies the top-level mapping into a new plain dict, but the values (lists, sets, inner dicts) are the same objects. For a single-level `defaultdict`, that's all you need. For a nested `defaultdict`, you have to convert each level.\n\n\n```python\nfrom collections import defaultdict\n\ncounts = defaultdict(lambda: defaultdict(int))\ncounts[\"alice\"][\"Wireless Mouse\"] = 2\ncounts[\"alice\"][\"USB Cable\"] = 1\n\n# Shallow: inner dicts are still defaultdicts.\nshallow = dict(counts)\nprint(type(shallow[\"alice\"]))\n\n# Deep: convert inner level too.\ndeep = {customer: dict(items) for customer, items in counts.items()}\nprint(type(deep[\"alice\"]))\n```\n\n\nThe dict comprehension is the standard fix for nested cases. There's no built-in \"deep convert\" for `defaultdict`; you write the one level of recursion you need.\n\nA common alternative if you want to keep the same object but disable auto-create from now on, is to set `default_factory` to `None`. The next section covers that.\n\n---\n\n# The `default_factory` Attribute\n\nThe factory you passed to the constructor is stored on the instance as `default_factory`. You can read it, change it, or disable it entirely by setting it to `None`.\n\n\n```python\nfrom collections import defaultdict\n\nd = defaultdict(list)\nprint(d.default_factory)\n\nd[\"alice\"].append(\"Wireless Mouse\")\n\n# Disable auto-create. Missing keys now raise KeyError.\nd.default_factory = None\n\ntry:\n d[\"bob\"].append(\"USB Cable\")\nexcept KeyError as e:\n print(f\"KeyError: {e}\")\n\n# Existing keys still work normally.\nd[\"alice\"].append(\"USB Cable\")\nprint(dict(d))\n```\n\n\nSetting `default_factory = None` is the \"freeze\" knob. The object stays a `defaultdict`, but reads of missing keys now behave like a plain `dict`: `KeyError`. This is a way to switch from \"build phase\" to \"read phase\" within the same object, without converting to a plain dict.\n\nYou can also swap factories partway through, although doing so is unusual and can confuse readers. If you find yourself reaching for that, it's often a sign you want two different dictionaries.\n\n\n```python\nfrom collections import defaultdict\n\nd = defaultdict(list)\nd[\"alice\"].append(\"Wireless Mouse\")\n\n# Switch the factory. Existing keys are unaffected.\nd.default_factory = set\nd[\"bob\"].add(\"USB Cable\")\n\nprint(dict(d))\n```\n\n\nNow `alice`'s value is a list (created before the swap), and `bob`'s value is a set (created after). The container types are mixed, which is exactly the kind of inconsistency that breaks downstream code expecting one shape. Use this sparingly.\n\nThe most useful pattern with `default_factory` is the freeze: build with auto-create, then set the factory to `None` to lock the dictionary against accidental new keys for the rest of its life.\n\n---\n\n# Real-World Patterns\n\nA few patterns combine the pieces above into the shapes you'll see in actual code.\n\n\n```python\nfrom collections import defaultdict\n\n# 1. Building a customer-to-orders index from raw rows.\norder_rows = [\n (1001, \"alice\", 29.99, \"Wireless Mouse\"),\n (1002, \"bob\", 14.99, \"USB Cable\"),\n (1003, \"alice\", 4.99, \"HDMI Cable\"),\n (1004, \"carol\", 89.99, \"Webcam\"),\n (1005, \"bob\", 19.99, \"Power Strip\"),\n]\n\norders_by_customer = defaultdict(list)\nfor order_id, customer, amount, product in order_rows:\n orders_by_customer[customer].append((order_id, amount, product))\n\nfor customer, orders in orders_by_customer.items():\n total = sum(amount for _, amount, _ in orders)\n print(f\"{customer}: {len(orders)} orders, ${total:.2f} total\")\n```\n\n\nThe grouping is one line; the aggregation that follows is just plain Python over the grouped data. This separation is the whole appeal: `defaultdict` does the dull part, your loop does the interesting part.\n\n\n```python\nfrom collections import defaultdict\n\n# 2. Counting cart items with int factory.\ncart_history = [\n (\"Wireless Mouse\", \"add\"),\n (\"USB Cable\", \"add\"),\n (\"USB Cable\", \"add\"),\n (\"Wireless Mouse\", \"remove\"),\n (\"HDMI Cable\", \"add\"),\n (\"USB Cable\", \"remove\"),\n]\n\ncart = defaultdict(int)\nfor product, action in cart_history:\n if action == \"add\":\n cart[product] += 1\n else:\n cart[product] -= 1\n\n# Drop items that ended at zero or below.\nfinal_cart = {p: q for p, q in cart.items() if q > 0}\nprint(final_cart)\n```\n\n\nThe `defaultdict(int)` handles both adds and removes uniformly. The cleanup step (dict comprehension) drops any item whose net quantity ended at zero.\n\n\n```python\nfrom collections import defaultdict\n\n# 3. Tag index from product reviews, with set deduplication.\nreviews = [\n (\"Wireless Mouse\", \"alice\"),\n (\"USB Cable\", \"bob\"),\n (\"Wireless Mouse\", \"alice\"), # duplicate\n (\"Wireless Mouse\", \"carol\"),\n (\"USB Cable\", \"alice\"),\n]\n\nreviewers_per_product = defaultdict(set)\nfor product, reviewer in reviews:\n reviewers_per_product[product].add(reviewer)\n\nfor product, reviewers in reviewers_per_product.items():\n print(f\"{product}: {sorted(reviewers)}\")\n```\n\n\nAlice reviewed the mouse twice in the source data, but the set keeps a single entry per reviewer per product. If you'd used `defaultdict(list)`, you'd have to deduplicate afterwards. The factory choice does the work for you.\n\n\n```python\nfrom collections import defaultdict\n\n# 4. Nested counts: orders per customer per category.\norders = [\n (\"alice\", \"Electronics\"),\n (\"alice\", \"Cables\"),\n (\"bob\", \"Electronics\"),\n (\"alice\", \"Electronics\"),\n (\"bob\", \"Cables\"),\n (\"bob\", \"Cables\"),\n]\n\ncounts = defaultdict(lambda: defaultdict(int))\nfor customer, category in orders:\n counts[customer][category] += 1\n\nfor customer, cats in counts.items():\n print(f\"{customer}: {dict(cats)}\")\n```\n\n\nThe two-level `defaultdict` keeps the loop body short. Converting inner dicts at print time gives clean output without changing the underlying structure.","pageType":"python"}

defaultdict

Get Premium