Dictionaries

Make a day08 folder for today’s files, open it in your editor, and run each script from its terminal, as on earlier days.

On Day 6 you stored many values in a list, and on Day 7 you met tuples and sets. All three find a value either by its position (index 0, 1, 2, …) or not at all (a set has no positions). But much of the information in real life is looked up by name: the price of “tea”, the phone number of “Ana”, the capital of “Japan”. Today you learn the collection Python made for exactly that: the dictionary.

Suppose a café wants to store its prices. With Day 6’s tools you might keep two lists side by side:

items = ["tea", "coffee", "muffin"]
prices = [2.50, 3.00, 2.75]

To find the price of a muffin, you would search items for "muffin", note its index (2), and then read prices[2]. That works, but it is fragile. Add an item to one list and forget the other, and every price after it belongs to the wrong item. And every lookup needs a search.

A paper dictionary solves the same problem for words: you look up a word and find its meaning next to it. You never ask for “the 4,512th word”. Python’s dictionary works the same way.

A dictionary (type dict) stores key-value pairs. The key is what you look things up by, such as "muffin". The value is what is stored with it, such as 2.75. Each pair is called an entry. You write a dictionary with curly braces, a colon between each key and its value, and commas between the entries:

prices = {"tea": 2.50, "coffee": 3.00, "muffin": 2.75}

• { and } start and end the dictionary.
• "tea": 2.50 is one entry: the key "tea", a colon, then its value 2.50.
• Commas separate the entries, as they separate the items of a list.

To read a value, put its key in square brackets after the dictionary, the same brackets you used for indexes on Days 3 and 6: prices["muffin"] means “the value stored with the key "muffin"”. This is called looking up a key.

>>> ages = {"Ana": 15, "Ben": 16, "Chloe": 15}
>>> ages["Ben"]
16
>>> ages["Chloe"]
15
>>> len(ages)
3
>>> ages
{'Ana': 15, 'Ben': 16, 'Chloe': 15}
>>> type(ages)
<class 'dict'>
>>> empty = {}
>>> len(empty)
0

• ages["Ben"] gives 16, the value paired with "Ben".
• len() counts the entries (the pairs), so len(ages) is 3, not 6.
• The REPL shows the dictionary in the same form you type it, with single quotes as it does for strings.
• type(ages) is dict, Python’s short name for dictionary.
• {} with nothing inside is an empty dictionary. That is why Day 7 made an empty set with set(): the empty braces were already taken by dict.

A dictionary remembers the order in which entries were added, so it prints and loops in that order. But that order is only for display. There is no “first entry” to ask for by number, because you always look up by key.

prices = {"tea": 2.50, "coffee": 3.00, "muffin": 2.75}
print(prices)
print("Tea costs", prices["tea"])
total = prices["coffee"] + prices["muffin"]
print(f"Coffee and a muffin: ${total:.2f}")

{'tea': 2.5, 'coffee': 3.0, 'muffin': 2.75}
Tea costs 2.5
Coffee and a muffin: $5.75

The key inside the brackets does not have to be typed into the code. It can be any expression that gives a key, such as a variable holding what the user typed. This run types Muffin, with a space before it and a capital M:

prices = {"tea": 2.50, "coffee": 3.00, "muffin": 2.75}
item = input("Item: ").strip().lower()
print(f"One {item} costs ${prices[item]:.2f}")

Item:  Muffin
One muffin costs $2.75

strip() and lower() (Day 3) turn Muffin into muffin, which matches the key exactly. Keys are compared like == compares strings: "Muffin" and "muffin" are different keys. Cleaning typed text before you use it as a key is a habit worth forming.

A dictionary’s keys are unique: each key appears at most once. If you write the same key twice, the later value wins:

>>> ages = {"Ana": 15, "Ben": 16, "Ana": 17}
>>> ages
{'Ana': 17, 'Ben': 16}
>>> len(ages)
2

There is only one "Ana" entry, holding 17. That makes sense: if one key could have two values, ages["Ana"] would not know which one to give back. Values, on the other hand, can repeat freely; Ana and Chloe were both 15 earlier.

prices = {"tea": 2.50, "coffee": 3.00, "muffin": 2.75}
print(prices[0])

Traceback (most recent call last):
  File ".../day08/by_position.py", line 2, in <module>
    print(prices[0])
          ~~~~~~^^^
KeyError: 0

rooms = {"math": "B12", "art": "A3", "science": "C7"}
subject = "art"
print(rooms[subject], len(rooms))
print(rooms["science"] + rooms["math"])

A3 3
C7B12

So far every key has been a string. Keys can be other types too, but not every type, and the reason is the same one you met with sets on Day 7.

A set finds a value fast by working out its hash, a number computed from the value, and looking straight in the one place that number points to. A dictionary does exactly this with its keys. When you store an entry, Python computes the key’s hash and keeps the entry in the place it points to. When you look the key up later, Python computes the same hash and goes straight there. That is why a lookup is fast even in a dictionary with a million entries: there is no searching.

The plan only works if a key’s hash never changes. If a key could change after it was stored, its hash would point to the wrong place, and the entry would be lost. So, as with sets, a key must be hashable: a value that cannot change.

Strings and numbers cannot be changed (Days 2 and 3), so they make good keys. Lists, sets, and dictionaries can change, so they cannot. A tuple cannot change (Day 7), so it can be a key as long as everything inside it is also unchangeable.

>>> medals = {1: "gold", 2: "silver", 3: "bronze"}
>>> medals[2]
'silver'
>>> board = {(0, 0): "rook", (0, 1): "knight"}
>>> board[(0, 1)]
'knight'
>>> readings = {9.5: "low", 12.0: "high"}
>>> readings[12.0]
'high'

• medals uses whole numbers as keys. medals[2] looks like a list index but is not one: 2 is a key, and there is no index 0 here at all.
• board uses tuples as keys, a natural way to name a square by its (row, column) position. To look one up, write the same tuple: board[(0, 1)].
• Floats can be keys too, though whole numbers and strings are far more common.

The rule is only about keys. A value can be anything at all, including a list or another dictionary; 8.7 makes good use of that.

seats = {}
seats[["row A", 3]] = "Ana"
print(seats)

Traceback (most recent call last):
  File ".../day08/list_key.py", line 2, in <module>
    seats[["row A", 3]] = "Ana"
    ~~~~~^^^^^^^^^^^^^^
TypeError: cannot use 'list' as a dict key (unhashable type: 'list')

seats = {}
seats[("row A", 3)] = "Ana"
seats[("row B", 1)] = "Ben"
print(seats)
print(seats[("row A", 3)])

{('row A', 3): 'Ana', ('row B', 1): 'Ben'}
Ana

A shop’s stock changes all day: new products arrive, counts go up and down, and products are dropped. Like a list (Day 6), a dictionary is mutable: you can change it after it is made, and it stays the same dictionary.

Adding and updating use the same line. Assign to a key in brackets:

stock["plums"] = 8

• If "plums" is not a key yet, Python adds a new entry.
• If "plums" is a key already, Python updates it: the old value is replaced. Keys are unique, so there is never a second "plums" entry.

You do not need append or any method to add an entry. Since the key says where the value goes, the assignment is enough.

Deleting has two forms:

• del stock["plums"] removes the entry with that key. del is a keyword (a word Python reserves), not a function, so there are no parentheses around the target.
• stock.pop("plums") also removes the entry, and returns the value it removed, so you can store it. Day 6’s pop did the same for a list, using an index instead of a key.

stock = {"apples": 12, "pears": 5}
print("Start:", stock)

stock["plums"] = 8
print("Add plums:", stock)

stock["pears"] = 9
print("Update pears:", stock)

stock["apples"] -= 3
print("Sell 3 apples:", stock)

del stock["plums"]
print("Delete plums:", stock)

sold_out = stock.pop("pears")
print("Popped pears:", sold_out)
print("End:", stock)

Start: {'apples': 12, 'pears': 5}
Add plums: {'apples': 12, 'pears': 5, 'plums': 8}
Update pears: {'apples': 12, 'pears': 9, 'plums': 8}
Sell 3 apples: {'apples': 9, 'pears': 9, 'plums': 8}
Delete plums: {'apples': 9, 'pears': 9}
Popped pears: 9
End: {'apples': 9}

Now vary it. Here an update and an add look identical, and two more tools appear:

>>> colors = {"sky": "blue"}
>>> colors["grass"] = "green"
>>> colors["sky"] = "gray"
>>> colors
{'sky': 'gray', 'grass': 'green'}
>>> colors.pop("lemon", "not here")
'not here'
>>> colors.clear()
>>> colors
{}

• colors["grass"] = "green" adds, because "grass" was new. colors["sky"] = "gray" updates, because "sky" existed. The line alone does not tell you which will happen; the dictionary’s current keys decide.
• pop with a second argument gives that value back when the key is missing, instead of stopping with an error. "lemon" is not a key, so you get 'not here' and nothing is removed.
• clear() removes every entry and leaves an empty dictionary, {}, just as it empties a list.

prices = {"tea": 2.50, "coffee": 3.00}
old_prices = prices
prices["tea"] = 2.75
print("Now:", prices)
print("Before:", old_prices)

Now: {'tea': 2.75, 'coffee': 3.0}
Before: {'tea': 2.75, 'coffee': 3.0}

prices = {"tea": 2.50, "coffee": 3.00}
old_prices = prices.copy()
prices["tea"] = 2.75
print("Now:", prices)
print("Before:", old_prices)

Now: {'tea': 2.75, 'coffee': 3.0}
Before: {'tea': 2.5, 'coffee': 3.0}

books = {"Dune": 2, "Emma": 1}
books["Holes"] = 4
books["Dune"] -= 1
books["Emma"] = books["Emma"] + books["Dune"]
removed = books.pop("Holes")
print(books, removed)

{'Dune': 1, 'Emma': 2} 4

Programs often look up keys that might not be there: a product nobody sells, a name nobody has saved yet, a word not counted yet. You saw in 8.1 that brackets with a missing key stop the program. You need a way to ask safely.

Here is that error again, in a program that gets as far as line 3:

prices = {"tea": 2.50, "coffee": 3.00, "muffin": 2.75}
print("Tea:", prices["tea"])
print("Juice:", prices["juice"])
print("Done")

Tea: 2.5
Traceback (most recent call last):
  File ".../day08/missing_key.py", line 3, in <module>
    print("Juice:", prices["juice"])
                    ~~~~~~^^^^^^^^^
KeyError: 'juice'

Read it the way you learned on Day 1: the last line names the error and the missing key, 'juice', and the lines above point at line 3. Line 2 ran and printed. Line 4 never ran, because the program stopped. A KeyError is Python refusing to guess: it does not know what the price of juice should be, so it will not make one up.

When a missing key is normal, not a mistake, use the get() method instead. prices.get(key) gives back the value if the key is there, and None if it is not. Day 2’s None means “no value here”, which is exactly the answer. You can also give get a second argument, the default: the value to give back when the key is missing.

>>> prices = {"tea": 2.50, "coffee": 3.00, "muffin": 2.75}
>>> prices.get("tea")
2.5
>>> prices.get("juice")
>>> print(prices.get("juice"))
None
>>> prices.get("juice", 0)
0
>>> prices.get("tea", 0)
2.5
>>> prices
{'tea': 2.5, 'coffee': 3.0, 'muffin': 2.75}

• prices.get("tea") finds the key and gives 2.5, just like prices["tea"].
• prices.get("juice") gives None. The REPL shows nothing for None (as you saw on Day 2), so the next line prints it to make it visible.
• prices.get("juice", 0) gives the default, 0.
• prices.get("tea", 0) gives 2.5: the default is used only when the key is missing.
• The last line shows get never adds an entry. It only reads.

Which should you use? Brackets, when the key must be there and a missing key means a bug you want to hear about. get, when a missing key is an ordinary situation your program should handle.

prices = {"tea": 2.50, "coffee": 3.00, "muffin": 2.75}
item = input("Item: ").strip().lower()
price = prices.get(item)
if price is None:
    print(f"Sorry, we do not sell {item}.")
else:
    print(f"One {item} costs ${price:.2f}")

Item: juice
Sorry, we do not sell juice.

points = {"Ana": 3}
points["Ben"] = points.get("Ben") + 1
print(points)

Traceback (most recent call last):
  File ".../day08/get_no_default.py", line 2, in <module>
    points["Ben"] = points.get("Ben") + 1
                    ~~~~~~~~~~~~~~~~~~^~~
TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

points = {"Ana": 3}
points["Ben"] = points.get("Ben", 0) + 1
points["Ana"] = points.get("Ana", 0) + 1
print(points)

{'Ana': 4, 'Ben': 1}

>>> sizes = {"S": 10, "M": 0, "L": 4}
>>> sizes.get("M", 5)
>>> sizes.get("XL", 5)
>>> sizes.get("s", "none")
>>> print(sizes.get("XL"))

>>> sizes = {"S": 10, "M": 0, "L": 4}
>>> sizes.get("M", 5)
0
>>> sizes.get("XL", 5)
5
>>> sizes.get("s", "none")
'none'
>>> print(sizes.get("XL"))
None

A report card prints every subject and its grade; a receipt prints every item and its price. On Day 5 you looped over each character of a string, and on Day 6 over each item of a list. Now you need to loop over each entry of a dictionary.

A for loop over a dictionary gives you its keys, one per pass, in the order they were added:

ages = {"Ana": 15, "Ben": 16, "Chloe": 15}
for name in ages:
    print(name, "is", ages[name])

Ana is 15
Ben is 16
Chloe is 15

The loop variable name holds "Ana", then "Ben", then "Chloe". Inside the body, ages[name] looks up the value for the current key. The lookup is safe, because every key the loop hands you is in the dictionary.

Dictionaries also have three methods that let you choose what to loop over:

>>> ages = {"Ana": 15, "Ben": 16, "Chloe": 15}
>>> ages.keys()
dict_keys(['Ana', 'Ben', 'Chloe'])
>>> ages.values()
dict_values([15, 16, 15])
>>> ages.items()
dict_items([('Ana', 15), ('Ben', 16), ('Chloe', 15)])
>>> list(ages.keys())
['Ana', 'Ben', 'Chloe']
>>> sorted(ages)
['Ana', 'Ben', 'Chloe']
>>> sum(ages.values())
46

The results look like lists wrapped in a label, such as dict_keys([...]). They are not lists, but you can loop over them, test them with in, and pass them to list() (which makes a new list from them), sorted(), sum(), min(), and max() (Day 6). items() gives tuples, the pairs you met on Day 7. sorted(ages) gives a new list of the keys in sorted order.

When only the values matter, loop over values(). Day 5’s accumulator works as usual:

ages = {"Ana": 15, "Ben": 16, "Chloe": 15}
total = 0
for age in ages.values():
    total += age
print("Total:", total)
print(f"Average: {total / len(ages):.1f}")
print("Oldest:", max(ages.values()))

Total: 46
Average: 15.3
Oldest: 16

total starts at 0 and adds 15, 16, and 15. len(ages) counts three entries, so the average is 46 / 3. max() from Day 6 finds the largest value directly.

prices = {"tea": 2.50, "coffee": 3.00, "muffin": 2.75}
for item, price in prices.items():
    print(f"{item}: ${price:.2f}")

tea: $2.50
coffee: $3.00
muffin: $2.75

To go through the entries in sorted order of their keys instead of the order they were added, loop over sorted(scores):

scores = {"Zoe": 88, "Ana": 92, "Max": 75}
for name in sorted(scores):
    print(name, scores[name])

Ana 92
Max 75
Zoe 88

sorted(scores) is the list ['Ana', 'Max', 'Zoe']. The loop goes through that list, and the body looks each name up. The dictionary itself is not changed.

stock = {"apples": 12, "pears": 0, "plums": 0, "figs": 4}
for fruit in stock:
    if stock[fruit] == 0:
        del stock[fruit]
print(stock)

Traceback (most recent call last):
  File ".../day08/remove_while_looping.py", line 2, in <module>
    for fruit in stock:
                 ^^^^^
RuntimeError: dictionary changed size during iteration

stock = {"apples": 12, "pears": 0, "plums": 0, "figs": 4}
for fruit in list(stock):
    if stock[fruit] == 0:
        del stock[fruit]
print(stock)

{'apples': 12, 'figs': 4}

rain = {"Mon": 4, "Tue": 0, "Wed": 12, "Thu": 3}
dry = 0
for day, mm in rain.items():
    if mm == 0:
        dry += 1
    elif mm > 10:
        print(day, "was wet")
print(dry, sum(rain.values()))

Wed was wet
1 19

8.4 used get to deal with a missing key. Often you want to ask the question directly, as an if condition: “is this key in the dictionary?” Day 3’s in asked whether one string is inside another, and Day 6’s in asked whether a list holds a value. With a dictionary, in asks about the keys.

>>> ages = {"Ana": 15, "Ben": 16, "Chloe": 15}
>>> "Ana" in ages
True
>>> "Dev" in ages
False
>>> "Dev" not in ages
True
>>> 15 in ages
False
>>> 15 in ages.values()
True
>>> "ana" in ages
False

• "Ana" in ages is True: "Ana" is a key.
• "Dev" not in ages is True, because "Dev" is not a key. not in is the opposite of in, as with strings.
• 15 in ages is False, even though 15 is right there in the dictionary. It is a value, and in checks only keys.
• To ask about the values, check values(): 15 in ages.values() is True.
• "ana" in ages is False, because keys match exactly.

Why only keys? Because checking a key uses the hash from 8.2, so it is instant. Checking the values means looking at every one of them in turn, which is slower in a big dictionary, so Python makes you ask for it on purpose.

capitals = {"france": "Paris", "japan": "Tokyo", "kenya": "Nairobi"}
while True:
    country = input("Country (or quit): ").strip().lower()
    if country == "quit":
        break
    if country in capitals:
        print("The capital is", capitals[country])
    else:
        print("Sorry, I do not know", country)
print("Goodbye!")

Country (or quit): Japan
The capital is Tokyo
Country (or quit): peru
Sorry, I do not know peru
Country (or quit): quit
Goodbye!

in with brackets and get do the same job in two styles. Use in when the “missing” case needs different code, as here. Use get with a default when a missing key simply means a default value, as in the points example from 8.4.

capitals = {"france": "Paris", "japan": "Tokyo", "kenya": "Nairobi"}
city = "Tokyo"
if city in capitals:
    print(city, "is a capital")
else:
    print(city, "is not a capital")

Tokyo is not a capital

capitals = {"france": "Paris", "japan": "Tokyo", "kenya": "Nairobi"}
city = "Tokyo"
if city in capitals.values():
    print(city, "is a capital")
else:
    print(city, "is not a capital")

Tokyo is a capital

>>> codes = {"red": 1, "green": 2, 3: "blue"}
>>> "red" in codes
>>> 1 in codes
>>> 3 in codes
>>> "blue" in codes.values()
>>> "Green" in codes

>>> codes = {"red": 1, "green": 2, 3: "blue"}
>>> "red" in codes
True
>>> 1 in codes
False
>>> 3 in codes
True
>>> "blue" in codes.values()
True
>>> "Green" in codes
False

A record is all the information about one thing, kept together: a student’s name, grade, test scores, and address. A dictionary is a natural record, because each piece gets a name (the key) instead of a position you must remember. student["grade"] says what it means; student[1] would not.

But some pieces are themselves collections. A student has several scores (a list) and an address with its own parts (city, zip code). Since values can be anything (8.2), a value can be a list or another dictionary. A dictionary inside another dictionary is called a nested dictionary.

To reach inside, chain the brackets. Python works left to right: student["address"]["city"] first looks up "address" in student, which gives the inner dictionary, then looks up "city" in that.

student = {
    "name": "Ana Silva",
    "grade": 10,
    "scores": [88, 92, 79],
    "address": {"city": "Springfield", "zip": "12345"},
}
print(student["name"], "is in grade", student["grade"])
print("Second score:", student["scores"][1])
print("City:", student["address"]["city"])

student["scores"].append(95)
student["address"]["zip"] = "12399"
print(student["scores"])
print(student["address"])

Ana Silva is in grade 10
Second score: 92
City: Springfield
[88, 92, 79, 95]
{'city': 'Springfield', 'zip': '12399'}

The pattern also works the other way round: a dictionary whose every value is a list. A gradebook maps each student’s name to their scores:

gradebook = {
    "Ana": [88, 92, 79],
    "Ben": [70, 85],
    "Chloe": [95, 91, 98, 90],
}
for name, scores in gradebook.items():
    average = sum(scores) / len(scores)
    print(f"{name}: {len(scores)} scores, average {average:.1f}")
gradebook["Ben"].append(100)
print("Ben now:", gradebook["Ben"])

Ana: 3 scores, average 86.3
Ben: 2 scores, average 77.5
Chloe: 4 scores, average 93.5
Ben now: [70, 85, 100]

items() hands over each name with its whole list of scores. sum() and len() from Day 6 work on that list as on any other. After the loop, gradebook["Ben"].append(100) adds a score to Ben’s list only.

To work out what a chain of brackets gives, read it one bracket at a time and ask, “what kind of value do I have now?” A dictionary needs a key next; a list needs an index.

student = {"name": "Ana Silva", "address": {"city": "Springfield", "zip": "12345"}}
print(student["city"])

Traceback (most recent call last):
  File ".../day08/nested_wrong_order.py", line 2, in <module>
    print(student["city"])
          ~~~~~~~^^^^^^^^
KeyError: 'city'

team = {
    "name": "Hawks",
    "players": ["Ana", "Ben", "Raj"],
    "coach": {"name": "Ms. Lee", "years": 4},
}
team["players"].remove("Ben")
team["coach"]["years"] += 1
print(team["players"][-1], len(team["players"]))
print(team["coach"]["name"], team["coach"]["years"])

Raj 2
Ms. Lee 5

One record is a dictionary. But a to-do app has many tasks, a library has many books, and a class has many students. Each one is a record with the same keys, and you want to keep them in order, add new ones, and go through them all. That is a job for a list (Day 6), where each item is a dictionary: a list of dictionaries.

tasks = [
    {"title": "Buy milk", "done": False},
    {"title": "Walk the dog", "done": True},
]

Reading it uses the same chaining as 8.7, but now the index comes first, because the outer collection is a list: tasks[0] is the first task’s dictionary, and tasks[0]["title"] is its title.

tasks = [
    {"title": "Buy milk", "done": False},
    {"title": "Walk the dog", "done": True},
    {"title": "Read Day 8", "done": False},
]
tasks[0]["done"] = True
tasks.append({"title": "Call Grandma", "done": False})

for number, task in enumerate(tasks, 1):
    mark = "x" if task["done"] else " "
    print(f"{number}. [{mark}] {task['title']}")

1. [x] Buy milk
2. [x] Walk the dog
3. [ ] Read Day 8
4. [ ] Call Grandma

Going through a list of dictionaries with a for loop gives one record per pass, and Day 5’s patterns work across the records. This one adds up the pages and picks out the cheaper books:

books = [
    {"title": "Holes", "pages": 233, "price": 7.99},
    {"title": "Dune", "pages": 412, "price": 10.99},
    {"title": "Wonder", "pages": 310, "price": 8.50},
]
total_pages = 0
for book in books:
    total_pages += book["pages"]
    if book["price"] < 9:
        print(f"{book['title']} is under $9")
print("Total pages:", total_pages)

Holes is under $9
Wonder is under $9
Total pages: 955

book is one dictionary on each pass, so book["pages"] and book["price"] read that book’s values. The running total adds 233 + 412 + 310 = 955. Every book has the same keys, which is what makes one loop body work for all of them.

tasks = [
    {"title": "Buy milk", "done": False},
    {"title": "Walk the dog", "done": True},
]
print(tasks["title"])

Traceback (most recent call last):
  File ".../day08/list_by_key.py", line 5, in <module>
    print(tasks["title"])
          ~~~~~^^^^^^^^^
TypeError: list indices must be integers or slices, not str

tasks = [
    {"title": "Buy milk", "done": False},
    {"title": "Walk the dog", "done": True},
]
print(tasks[0]["title"])
for task in tasks:
    print(task["title"])

Buy milk
Buy milk
Walk the dog

pets = [
    {"name": "Rex", "kind": "dog", "age": 3},
    {"name": "Tom", "kind": "cat", "age": 7},
    {"name": "Bo", "kind": "dog", "age": 5},
]
pets[2]["age"] += 1
oldest = None
for pet in pets:
    if pet["kind"] == "dog":
        if oldest is None or pet["age"] > oldest["age"]:
            oldest = pet
print(oldest["name"], oldest["age"])

A class votes for its lunch: pizza, tacos, pizza, sushi, and so on. How many votes did each food get? On Day 5 you counted with one counter variable. But here you do not know the foods in advance, so you cannot make one variable per food. You need one counter per different value, made as each new value turns up. A dictionary does exactly that: the key is the thing being counted, and the value is its count.

The pattern, for each item:

• If the item is not a key yet, this is its first time: add it with a count of 1.
• Otherwise, add 1 to its count.

votes = ["pizza", "tacos", "pizza", "sushi", "pizza", "tacos"]
counts = {}
for food in votes:
    if food in counts:
        counts[food] += 1
    else:
        counts[food] = 1
print(counts)

{'pizza': 3, 'tacos': 2, 'sushi': 1}

The if/else can be shortened to one line with get and a default of 0, the line you met in 8.4’s Watch Out: “the count so far, or 0 if there is none, plus 1”. Once the counts are in, Day 5’s maximum pattern finds the winner:

votes = ["pizza", "tacos", "pizza", "sushi", "pizza", "tacos"]
counts = {}
for food in votes:
    counts[food] = counts.get(food, 0) + 1
print(counts)

winner = None
for food, count in counts.items():
    if winner is None or count > counts[winner]:
        winner = food
print("Winner:", winner, "with", counts[winner], "votes")

{'pizza': 3, 'tacos': 2, 'sushi': 1}
Winner: pizza with 3 votes

• Line 4 does the whole count: for a new food, get gives 0, so the count becomes 1; for a food already seen, it gives the count so far.
• Lines 7–10 go through the (food, count) pairs. winner starts at None (Day 5) and holds the food with the most votes so far, so counts[winner] is the best count so far.

A close cousin of counting is totaling by category: instead of adding 1, add an amount. Here each purchase is a (category, amount) tuple, unpacked in the loop:

purchases = [
    ("food", 12.50),
    ("games", 20.00),
    ("food", 8.25),
    ("books", 9.99),
    ("food", 4.00),
]
spent = {}
for category, amount in purchases:
    spent[category] = spent.get(category, 0) + amount
for category, total in spent.items():
    print(f"{category}: ${total:.2f}")

food: $24.75
games: $20.00
books: $9.99

Food is 12.50 + 8.25 + 4.00 = 24.75. The only change from counting is + amount instead of + 1.

votes = ["pizza", "tacos", "pizza"]
counts = {}
for food in votes:
    counts[food] += 1
print(counts)

Traceback (most recent call last):
  File ".../day08/count_no_start.py", line 4, in <module>
    counts[food] += 1
    ~~~~~~^^^^^^
KeyError: 'pizza'

rolls = [3, 6, 3, 1, 6, 3]
tally = {}
for roll in rolls:
    tally[roll] = tally.get(roll, 0) + 1
print(tally)
print(len(tally), tally.get(2, 0))

{3: 3, 6: 2, 1: 1}
3 0

Counting answers “how many in each group?” Sometimes you need the group itself: which students are in grade 10, which words have five letters. Grouping collects items into lists, one list per group, with the dictionary’s key naming the group.

The pattern is close to counting, but each value is a list that grows:

• Work out the item’s group (its key).
• If the key is not in the dictionary yet, add it with an empty list, [].
• Append the item to that key’s list.

students = [("Ana", 10), ("Ben", 11), ("Chloe", 10), ("Dev", 12), ("Eli", 11)]
by_grade = {}
for name, grade in students:
    if grade not in by_grade:
        by_grade[grade] = []
    by_grade[grade].append(name)
print(by_grade)
for grade in sorted(by_grade):
    print(f"Grade {grade}: {', '.join(by_grade[grade])}")

{10: ['Ana', 'Chloe'], 11: ['Ben', 'Eli'], 12: ['Dev']}
Grade 10: Ana, Chloe
Grade 11: Ben, Eli
Grade 12: Dev

The key can be anything you can work out from the item: a grade, a word’s length (len(word)), or a name’s first letter. The groups appear in the order each key was first seen.

students = [("Ana", 10), ("Ben", 11), ("Chloe", 10), ("Dev", 12), ("Eli", 11)]
by_grade = {}
for name, grade in students:
    by_grade[grade] = [name]
print(by_grade)

{10: ['Chloe'], 11: ['Eli'], 12: ['Dev']}

animals = ["bat", "cow", "bee", "ant", "cat", "bear"]
groups = {}
for animal in animals:
    first = animal[0]
    if first not in groups:
        groups[first] = []
    groups[first].append(animal)
print(groups["b"])
print(len(groups), groups.get("d", []))

['bat', 'bee', 'bear']
3 []

A class quiz is played in teams. Each result is a record: a player’s name, team, and points. The program needs each team’s total (counting by category, 8.9), each team’s members (grouping, 8.10), and the winning team (Day 5’s maximum, over a dictionary’s items, 8.5).

results = [
    {"name": "Ana", "team": "Red", "points": 12},
    {"name": "Ben", "team": "Blue", "points": 9},
    {"name": "Chloe", "team": "Red", "points": 7},
    {"name": "Dev", "team": "Green", "points": 15},
    {"name": "Eli", "team": "Blue", "points": 11},
]

totals = {}
members = {}
for result in results:
    team = result["team"]
    totals[team] = totals.get(team, 0) + result["points"]
    if team not in members:
        members[team] = []
    members[team].append(result["name"])

best = None
for team, total in totals.items():
    names = ", ".join(members[team])
    print(f"{team}: {total} points ({names})")
    if best is None or total > totals[best]:
        best = team
print("Winning team:", best)

Red: 19 points (Ana, Chloe)
Blue: 20 points (Ben, Eli)
Green: 15 points (Dev)
Winning team: Blue

The first loop goes through the list of dictionaries (8.8) and builds two dictionaries at once:

• Line 12 stores result["team"] in a short name, team, because the next four lines all need it.
• Line 13 is the totaling line: get(team, 0) starts a new team at 0, then adds the player’s points.
• Lines 14–16 are the grouping lines: a new team gets an empty list, and every player is appended to their team’s list.
• The second loop uses items() to get each team with its total. It prints a line per team, using members[team] (the same key in the other dictionary) to list the players. It also keeps best, the team with the highest total so far, starting from None.
• Blue wins with 20, one point ahead of Red’s 19, even though Dev, on Green, scored more points than any other single player. Totals decide, not single scores.

The two dictionaries share their keys (the team names), which is a common way to keep several facts about the same groups.

• A dictionary stores key-value pairs and finds a value by its key, not by position: prices["tea"]. Keys are unique and must be hashable (strings, numbers, tuples); values can be anything.
• d[key] = value adds a new entry or replaces an existing value; del d[key] and d.pop(key) remove one. Like lists, dictionaries are mutable, so b = a shares and a.copy() copies.
• Brackets with a missing key stop with a KeyError. key in d checks the keys first, and d.get(key, default) gives a default instead. in never looks at values; use d.values() for that.
• for key in d:, d.values(), and for key, value in d.items(): loop over a dictionary in the order entries were added. Do not add or delete keys while looping over the same dictionary.
• Values can be lists or dictionaries, so a dictionary models a record, and a list of dictionaries holds many records. Chain brackets to reach inside: tasks[0]["title"].
• Counting uses counts[item] = counts.get(item, 0) + 1; grouping adds an empty list for a new key and appends every item.

Do these in your day08 folder. Type each program yourself, run it, and only then open the answer. Functions arrive tomorrow on Day 9, so write each one as a plain script.

paragraph = """The cat sat on the mat. The dog sat on the log.
The cat and the dog are friends."""

text = paragraph.lower().replace(".", "").replace(",", "")
counts = {}
for word in text.split():
    counts[word] = counts.get(word, 0) + 1

for word, count in counts.items():
    print(word, count)

most_common = None
for word, count in counts.items():
    if most_common is None or count > counts[most_common]:
        most_common = word
print(f"Most common: {most_common} ({counts[most_common]} times)")

the 6
cat 2
sat 2
on 2
mat 1
dog 2
log 1
and 1
are 1
friends 1
Most common: the (6 times)

contacts = {}
print("Commands: add, find, delete, list, quit")
while True:
    command = input("Command: ").strip().lower()
    if command == "quit":
        print("Goodbye!")
        break
    elif command == "add":
        name = input("Name: ").strip()
        phone = input("Phone: ").strip()
        if name in contacts:
            print(f"Updated {name}.")
        else:
            print(f"Added {name}.")
        contacts[name] = phone
    elif command == "find":
        name = input("Name: ").strip()
        phone = contacts.get(name)
        if phone is None:
            print(f"No contact named {name}.")
        else:
            print(f"{name}: {phone}")
    elif command == "delete":
        name = input("Name: ").strip()
        if name in contacts:
            del contacts[name]
            print(f"Deleted {name}.")
        else:
            print(f"No contact named {name}.")
    elif command == "list":
        if not contacts:
            print("No contacts yet.")
        for name in sorted(contacts):
            print(f"{name}: {contacts[name]}")
    else:
        print("Unknown command:", command)

Commands: add, find, delete, list, quit
Command: add
Name: Ana
Phone: 555-0142
Added Ana.
Command: add
Name: Ben
Phone: 555-0199
Added Ben.
Command: find
Name: Ana
Ana: 555-0142
Command: find
Name: Zoe
No contact named Zoe.
Command: delete
Name: Ben
Deleted Ben.
Command: list
Ana: 555-0142
Command: quit
Goodbye!

names = ["Maya", "Leo", "Ana", "Mateo", "Liam", "Aria", "Zoe", "Mia"]

by_letter = {}
for name in names:
    letter = name[0].upper()
    if letter not in by_letter:
        by_letter[letter] = []
    by_letter[letter].append(name)

for letter in sorted(by_letter):
    group = by_letter[letter]
    print(f"{letter} ({len(group)}): {', '.join(group)}")

A (2): Ana, Aria
L (2): Leo, Liam
M (3): Maya, Mateo, Mia
Z (1): Zoe

menu = {
    "tea": {"price": 2.50, "left": 2},
    "muffin": {"price": 2.75, "left": 0},
}
order = ["tea", "juice", "muffin", "tea", "tea"]
total = 0
for item in order:
    if item not in menu:
        print("No", item)
    elif menu[item]["left"] == 0:
        print("Out of", item)
    else:
        menu[item]["left"] -= 1
        total += menu[item]["price"]
print(f"Total: ${total:.2f}")

No juice
Out of muffin
Out of tea
Total: $5.00

scores = {"Ana": 92, "Ben": 78, "Chloe": 85}
for name, score in scores:
    print(name, "scored", score)

Traceback (most recent call last):
  File ".../day08/review_unpack.py", line 2, in <module>
    for name, score in scores:
        ^^^^^^^^^^^
ValueError: too many values to unpack (expected 2)

scores = {"Ana": 92, "Ben": 78, "Chloe": 85}
for name, score in scores.items():
    print(name, "scored", score)

Ana scored 92
Ben scored 78
Chloe scored 85

member = {"name": "Ana", "age": 15, "games": ["chess", "go"]}

scores = {"Ana": 92, "Ben": 58, "Chloe": 85, "Dev": 40, "Eli": 70}
results = {}
for name, score in scores.items():
    outcome = "pass" if score >= 60 else "fail"
    if outcome not in results:
        results[outcome] = []
    results[outcome].append(name)
print(results)
print(len(results["pass"]), results.get("merit", "none"))

{'pass': ['Ana', 'Chloe', 'Eli'], 'fail': ['Ben', 'Dev']}
3 none

The official Python Tutorial covers dictionaries in Data Structures: Dictionaries and looping over them with items() in Looping Techniques. Some of its examples use functions and comprehensions, which you meet on Days 9 and 11.

Check each statement. If the answer is “not yet,” reread the linked subsection.

• I can make a dictionary and look a value up by its key. Reread
• I can say which types can be keys and why a list cannot. Reread
• I can add, update, and delete entries. Reread
• I can explain when a KeyError happens and avoid it with get(). Reread
• I can loop over keys, values, and items, and unpack each pair. Reread
• I can use in to check for a key, and values() to check for a value. Reread
• I can model a record with a nested dictionary and reach inside it. Reread
• I can loop over a list of dictionaries and read each record. Reread
• I can count how many times each value appears. Reread
• I can group items into lists by a key. Reread