collections — Counter / defaultdict / deque / namedtuple

The collections module gathers specialized data structures that fill in the gaps left by list / dict / tuple. This article walks through the four you'll reach for most often in real projects: Counter / defaultdict / deque / namedtuple, in order.

What each of the four is for

Each one exists to simplify a case that's awkward to write with the plain built-ins. The table below gives you the bird's-eye view, then each section dives into how to use them.

Counter — tally occurrences in one line

Counter is a class that takes an iterable (a list, string, etc.) and returns a dict of how many times each element occurs. With a plain dict, you'd write a loop that checks if the key already exists, initializes it to 1 if not, or increments it if so — but Counter does the same job in one line: Counter(list).

The return value is a subclass of dict, so you can pull values out with counter["apple"] just like a normal dict. There's also .most_common(N), which returns a list of (element, count) tuples in descending order — perfect for ranking displays.

Tally six purchase records by product using Counter. Feel how a single line replaces a regular for loop.

① Import Counter from collections

② Define the purchase list ["apple", "banana", "apple", "cherry", "banana", "apple"]

③ Pass the list to Counter to build the tally and print it as Count: ◯

④ Print the count of apple as apple count: ◯ (you can use the same square-bracket access as dict)

⑤ Use most_common to grab the top 2 and print them as Top 2: ◯

(If your code runs correctly, the explanation will appear.)

defaultdict — auto-initialize missing keys

defaultdict is a dict that automatically inserts a default value when you access a key that doesn't exist yet. With a plain dict, you have to write the existence check + initialization dance every time, like if key not in d: d[key] = []. With defaultdict, you pass a function that produces the initial value when you create it, and it calls that function automatically the first time a missing key is touched.

The two patterns you'll see most are defaultdict(list) (empty list for missing keys) and defaultdict(int) (0 for missing keys). The argument is a function that returns the initial value when called with no arguments — list and int both qualify (they return [] and 0 respectively), so you pass them directly.

When to pick Counter vs. defaultdict

If you just want to count things, Counter is more concise (and you get most_common for free). If you're grouping into lists or sets — anything where the initial value is an empty container — defaultdict(list) / defaultdict(set) is the better fit.

Group fruits by color. With defaultdict(list), the first time you touch a color key, it auto-creates an empty list, so you can call .append without an existence check.

① Import defaultdict from collections

② Create a defaultdict whose default value is an empty list

③ Register these three entries in order:

- "red" → "apple"

- "yellow" → "banana"

- "red" → "cherry"

④ Convert to a regular dict and print as By color: ◯ (printing the defaultdict directly gives a less-readable repr)

deque — O(1) operations on both ends

deque (double-ended queue) is a list-like data structure that supports adding and removing from both ends. Plain list already handles right-end ops via append and pop, but list.insert(0, x) and list.pop(0) shift every element by one slot internally, so they end up O(n) (slower as the list grows).

deque is designed so both ends are O(1) (constant time regardless of length), making it the right pick for queues, history buffers, and keeping the most recent N entries — anywhere you need to push and pop from both sides. The maxlen argument is especially handy: set a max length, and adds beyond that limit silently drop the element on the opposite end, giving you a ring buffer for free.

Keep the last 3 access logs in a deque(maxlen=3). After 5 appends, only the last 3 survive.

① Import deque from collections

② Create an empty deque with max length 3

③ Append the integers 0 through 4 in order (5 total)

④ Print the result as Last 3: ◯ (the older 0 and 1 should have been pushed out)

Pop the head and tail of a task queue. Use popleft and pop to switch which end you pull from.

① Import deque from collections

② Build a deque from the four tasks ["Task A", "Task B", "Task C", "Task D"]

③ Use popleft() to grab the first task and print it as First task: ◯

④ Use pop() to grab the last task and print it as Last task: ◯

⑤ Print the remaining deque as Remaining: ◯

namedtuple — lightweight records that name tuple fields

namedtuple is a function that defines a named-field tuple in one line. A plain tuple like (3, 4) is only accessible by position (p[0] / p[1]), so the reader has to remember which slot is which. namedtuple lets you write p.x / p.y with meaningful names, which is a big readability win.

It also stays compatible with regular tuples — p[0] indexing and *p unpacking still work — so you can add names to existing tuple-based code without breaking anything. It's a lightweight extension.

namedtuple vs. dataclass

If you just need an immutable lightweight record, reach for namedtuple. If you want methods, default values, and detailed type hints, dataclass (covered two articles from now) is the right tool. namedtuple's strength is tuple compatibility — it's perfect for replacing existing return types like def f() -> tuple[int, int]: without breaking callers.

Define a Point namedtuple and read coordinates by name.

① Import namedtuple from collections and create one with class name "Point" and fields ["x", "y"]

② Build an instance p with x=3, y=4

③ Print as x: 3 y: 4 using named access p.x and p.y

namedtuple extras — repr / index / _asdict

On top of class-style named access, namedtuple gives you tuple-compatible index access, a readable repr, and a _asdict method for dict conversion. You'll use these for debugging, compatibility with existing APIs, and JSON serialization, among other things.

Take the p from Practice 1 and try the three extra access patterns.

① print("repr:", p) to print as repr: Point(x=3, y=4)

② Use p[0] and p[1] for index access and print as By index: 3 4

③ Use p._asdict() to print as As dict: {'x': 3, 'y': 4}