Nested Worlds — Dicts of Lists

By the end of this lesson you can:

• Build a dict-of-lists by hand: {"fruit": ["apple", "banana"], "drink": ["milo", "kopi"]}.
• Append a new item to one group with d[key].append(item).
• Group an unsorted list of pairs into a dict-of-lists with a tiny loop and the if-key-in pattern.
• Use .items() from PY-L2-06 to loop both the group name and its list at once.

Pak Cik Razif's menu has three stalls. Each stall has its own short list of items.

stalls = {
    "drinks":  ["milo", "kopi", "teh tarik"],
    "rice":    ["nasi lemak", "nasi goreng"],
    "noodles": ["char kway teow", "mee goreng"],
}

print(stalls["drinks"])
print(stalls["noodles"][1])
print(len(stalls))

['milo', 'kopi', 'teh tarik']
mee goreng
3

Compare the two shapes

Yesterday — list of dicts          Today — dict of lists

[                                  {
  {"item": "milo",  "stall": "D"},   "D": ["milo", "kopi", "teh"],
  {"item": "kopi",  "stall": "D"},   "R": ["nasi lemak", "nasi g."],
  {"item": "nasi",  "stall": "R"},   "N": ["char kway teow", "mee g."],
  ...                              }
]

Each row stands alone.             Each key holds many items.
Good when you need flexible        Good when you need every item
filters per row.                   of a category at once.

Same six menu items, two different shapes. The right shape depends on the question you ask the data.

Adding to a group

Append to the right list — same .append() from Level 1.

stalls["drinks"].append("horlicks")
print(stalls["drinks"])
# → ['milo', 'kopi', 'teh tarik', 'horlicks']

What if the group doesn't exist yet? Trying stalls["dessert"].append("cendol") would crash — there is no "dessert" key, so stalls["dessert"] blows up before .append can run.

The standard fix is the if-key-in pattern:

item  = "cendol"
group = "dessert"

if group not in stalls:
    stalls[group] = []      # create the empty list first
stalls[group].append(item)
print(stalls[group])
# → ['cendol']

Two lines: make the list if it isn't there, then append. We'll meet a one-line version of this trick (defaultdict) in Level 3.

Looping a dict-of-lists

Loop with .items() from PY-L2-06 — you get the group name and its list together.

for stall, items in stalls.items():
    print(stall, "(", len(items), "items )")
    for item in items:
        print("  -", item)

Two loops — the outer one over groups, the inner over items in each group. Indentation tells the eye that the inner is "inside" the outer.

Quick stats per group

The len() of each group's list is a count. The dict itself's len() is the number of groups.

print("Stalls:", len(stalls))
for stall, items in stalls.items():
    print(stall, ":", len(items), "items")

Grouping a flat list

Often you start with a flat list of (item, category) pairs and you want to bucket them yourself. This is the "group by" pattern — the bread and butter of every spreadsheet pivot table.

raw = [
    ("milo",       "drinks"),
    ("kopi",       "drinks"),
    ("nasi lemak", "rice"),
    ("teh tarik",  "drinks"),
    ("char kway teow", "noodles"),
    ("nasi goreng",    "rice"),
]

grouped = {}
for item, category in raw:
    if category not in grouped:
        grouped[category] = []
    grouped[category].append(item)

print(grouped)

{'drinks': ['milo', 'kopi', 'teh tarik'], 'rice': ['nasi lemak', 'nasi goreng'], 'noodles': ['char kway teow']}

Three lines do the "group by": the if-key-in check, the empty-list creation, and the append. The shape on the right is exactly the dict-of-lists you'd have built by hand.

The story

You've been given a flat list of seven library books, each as a (title, genre) tuple. The librarian wants to group them by genre, count each genre, and answer two follow-up questions.

Save as library_groups.py:

Code

# library_groups.py — group by genre, then report

raw = [
    ("Harry Potter",     "fantasy"),
    ("Percy Jackson",    "fantasy"),
    ("Wings of Fire",    "fantasy"),
    ("Diary of a Wimpy Kid", "humour"),
    ("Tom Gates",        "humour"),
    ("Charlotte's Web",  "classic"),
    ("The Hobbit",       "fantasy"),
]

# Step 1 — group by genre
by_genre = {}
for title, genre in raw:
    if genre not in by_genre:
        by_genre[genre] = []
    by_genre[genre].append(title)

# Step 2 — print every group
for genre, titles in by_genre.items():
    print(genre, "(", len(titles), "titles ):")
    for t in titles:
        print(" -", t)
    print()

# Step 3 — biggest genre
biggest_genre = ""
biggest_count = 0
for genre, titles in by_genre.items():
    if len(titles) > biggest_count:
        biggest_count = len(titles)
        biggest_genre = genre
print("Biggest genre:", biggest_genre, "(", biggest_count, "titles )")

# Step 4 — add a new book
title, genre = "Matilda", "classic"
if genre not in by_genre:
    by_genre[genre] = []
by_genre[genre].append(title)
print("After Matilda:", by_genre)

Output

fantasy ( 4 titles ):
 - Harry Potter
 - Percy Jackson
 - Wings of Fire
 - The Hobbit

humour ( 2 titles ):
 - Diary of a Wimpy Kid
 - Tom Gates

classic ( 1 titles ):
 - Charlotte's Web

Biggest genre: fantasy ( 4 titles )
After Matilda: {'fantasy': ['Harry Potter', 'Percy Jackson', 'Wings of Fire', 'The Hobbit'], 'humour': ['Diary of a Wimpy Kid', 'Tom Gates'], 'classic': ["Charlotte's Web", 'Matilda']}

Read the diff

Step 1 is the group-by recipe — three lines. Step 2 is the nested loop. Step 3 is yesterday's "biggest" scan, but applied to len(list) not a single number. Step 4 is the add-to-a-group recipe — the same three lines as step 1, but for one new item.

A dict-of-lists models buckets: one key per category, one list per bucket. Add an item by appending to the right list — checking first that the list exists. Loop with .items() to walk both the group name and the items together. The three-line "group by" recipe (check, create empty list, append) turns any flat list into buckets — and that's the same pattern every database's GROUP BY does under the hood.