Python collections Module

The manual pattern counts = {}, then counts[word] = counts.get(word, 0) + 1 for every item, is common enough that collections.Counter exists specifically to replace it: Counter(words) (given any iterable of hashable items) builds the exact same frequency mapping in one call, as a dict subclass with a few extra conveniences layered on top. .most_common(n) returns the n most frequent items as (item, count) tuples, sorted descending by count — a sort-and-slice operation you'd otherwise write by hand every time.

Counter also supports arithmetic between counters — counter_a + counter_b adds corresponding counts together, counter_a - counter_b subtracts them (dropping any resulting non-positive counts) — which is genuinely useful for comparing two frequency distributions, like word counts across two different documents, without writing a manual merge loop.

Accessing a key that was never counted returns 0 rather than raising KeyError, exactly like a defaultdict(int) would — Counter()["never_seen"] is 0, not an exception, which is precisely the right default behavior for a running count that might legitimately be zero for many possible keys.

Grouping items by some key — building a dict mapping each department to a list of employee names, in the scene's example — traditionally requires checking whether the key already exists before appending: if dept not in groups: groups[dept] = [], then groups[dept].append(name). defaultdict(list) removes that check entirely: accessing (or assigning to) any key that doesn't yet exist automatically calls the factory function passed to defaultdict — here, list() — to create a default value for that key first, then proceeds with the operation as normal.

The factory can be any zero-argument callable: defaultdict(list) for grouping into lists, defaultdict(int) for counting (functionally overlapping with what Counter provides, though Counter is more purpose-built for pure counting), defaultdict(set) for grouping into sets when duplicates should be automatically eliminated, or even a custom function for more elaborate default construction logic.

One behavior worth knowing precisely: defaultdict only creates the default value on access — reading groups["NewDept"] (even without assigning anything) *does* create an empty list for "NewDept" as a side effect, which can be surprising if you're just checking membership. Use dept in groups (which does not trigger default creation) rather than groups[dept] when you genuinely just want to check presence without mutating the dict.

namedtuple("Point", ["x", "y"]) creates a new tuple subclass whose elements are accessible both positionally (p[0]) and by name (p.x), combining a plain tuple's memory efficiency and immutability with dramatically better readability than remembering 'index 0 is x, index 1 is y.' It predates @dataclass (covered in Modern Python) and remains useful specifically when you want tuple semantics — unpacking (x, y = p), equality by value, hashability, immutability — without the extra weight or __init__ boilerplate of even a @dataclass. typing.NamedTuple is the modern, type-annotated variant (class Point(NamedTuple): x: float; y: float), combining namedtuple's tuple-based lightness with proper type hints.

deque ("deck", double-ended queue) is a sequence type specifically optimized for adding and removing items from *either* end in constant time — .append()/.pop() on the right, .appendleft()/.popleft() on the left, all O(1). A plain list is a contiguous array under the hood, so while appending/popping from the *end* is O(1), inserting or removing from the *front* (list.insert(0, x) or list.pop(0)) requires shifting every other element down, making it O(n) — a real, measurable difference at scale for anything implementing a queue, a sliding window, or breadth-first search's frontier.

deque also accepts an optional maxlen parameter, turning it into a fixed-size, automatically-evicting circular buffer — appending past maxlen silently drops the oldest item from the opposite end, a convenient built-in mechanism for 'keep only the last N items' patterns like a rolling log tail or a recent-history buffer, without manual trimming logic.

If you've ever written 'if key not in dict: dict[key] = []' — collections has a structure that eliminates that check entirely. Let's meet it and three others.

Counter counts hashable items in one line -- no manual dict-plus-if-not-in-check loop needed.

defaultdict eliminates the 'if key not in dict' check entirely -- missing keys get a default value automatically.

Checkpoint: What does groups[dept].append(name) do when dept is not yet a key in a defaultdict(list)?

• →defaultdict automatically creates an empty list for that key, then appends to it
• →It raises a KeyError, same as a plain dict would

namedtuple (and its modern typed cousin) gives you a lightweight, immutable record with named fields -- more readable than a plain tuple, lighter than a full class.

deque gives O(1) appends/pops from BOTH ends -- a plain list is O(n) for operations at the front.

Checkpoint: Why is deque preferred over a plain list for a queue where items are added and removed from the front frequently?

• →deque provides O(1) operations at both ends, while list.pop(0) and list.insert(0, x) are O(n)
• →deque uses less memory per item than a list

collections gives you specialized containers; itertools gives you specialized ways to combine and transform them without materializing intermediate lists.

Group Real Data with defaultdict. Finish group_by_department(): defaultdict eliminates the 'if key not in dict' check.