Dictionaries

What is a dictionary?

ages = {"Ava": 15, "Ben": 16, "Cy": 14}
#        key  value

Why not just use two lists?

You could keep names in one list and ages in another, matched by position. But to find Cy's age you would have to search the names list for Cy, get its index, then use that index in the ages list. And if one list gets sorted or changed, the two no longer match up.

A dictionary keeps each key glued to its value, and it can jump straight to a key without searching through everything. Even with a million entries, ages["Cy"] is about as fast as with three.

How to read it out loud: ages["Ava"] is "the value stored under the key Ava in ages," or simply "Ava's age."

Building a dictionary

Building a dictionary in a loop

Often you start empty and fill it as your program runs:

prices = {}
prices["taco"] = 2.50
prices["burrito"] = 7.25
print(prices)    # {'taco': 2.5, 'burrito': 7.25}

Formatting a longer dictionary: like long lists, you can spread a dictionary over several lines, one pair per line, until the closing }. It is much easier to read and to add pairs later.

Careful with {}: empty curly braces make an empty dictionary, not an empty set or list.

Getting a value by its key

ages = {"Ava": 15, "Ben": 16}
print(ages["Ava"])    # 15
print(ages["Cy"])     # KeyError: 'Cy'

Brackets mean something different here

With a list, the thing in brackets is a position. With a dictionary, it is a key. That is why ages[0] does not mean "the first person"; Python searches for a key that is literally the number 0.

Using a variable as the key

name = input("Whose age? ")
print(ages[name])

Notice there are no quotes around name in the brackets: we want the value of the variable (whatever the user typed), not the word "name."

Three ways to handle a missing key

if name in ages:
    print(ages[name])
else:
    print(name, "not found")

print(ages.get(name))       # None if missing
print(ages.get(name, 0))    # 0 if missing

try:
    print(ages[name])
except KeyError:
    print(name, "not found")

Which way should I choose?

get() does not add the key. After ages.get("Dee", 0), the dictionary still has no "Dee". It just hands you the default for that one lookup.

in checks keys only: 15 in ages is False even if someone is 15. To search values, use 15 in ages.values().

How try / except works

try:
    # code that might cause an error
except KeyError:
    # runs only if a KeyError happened

Trace both paths

Notice that print("found it") never runs for "art". Once an error happens, the rest of the try block is skipped.

Keep the try block small. Put only the line that might fail inside it. A big try block can accidentally catch errors from other lines that you did not expect.

Adding and updating pairs

inventory = {"apples": 3}
inventory["pears"] = 5       # add
inventory["apples"] = 10     # update
inventory["apples"] += 2     # update using the old value
inventory.update({"plums": 4, "pears": 6})  # add/update many

Add or update: Python decides for you

d[key] = value does not ask whether the key exists. If it is new, a pair is added; if it already exists, the old value is simply replaced, with no warning. If you need to protect existing data, check first:

if "apples" not in inventory:
    inventory["apples"] = 0    # only set it the first time

Why += needs the key

inventory["kiwis"] += 1 really means inventory["kiwis"] = inventory["kiwis"] + 1. The right side reads inventory["kiwis"] first, and that lookup fails if the key is not there yet. The counting pattern on slide 11 solves this.

Removing pairs

Choosing a removal tool

• Just remove it: del d[key]
• Remove it and use the value: x = d.pop(key), for example to move an item from one dictionary to another.
• Remove it if it is there, no error either way: d.pop(key, None)
• Start over: d.clear() empties the dictionary but keeps the same dictionary object.

LIFO means "last in, first out," like a stack of plates: the plate put on most recently is the first one taken off. popitem() removes the most recently added pair.

Dictionary Lab

Pick an operation, fill in the key (and value), and click Run. Every line runs on the same dictionary. Put text in quotes, like "kiwi". Nothing is recorded.

Experiments to try

• Add a key, then add it again with a different value. How many pairs are there?
• Look up a missing key with brackets, then with get. Compare the results.
• Use pop on a key and see what value comes back.
• Try "Kiwi" and "kiwi". Are they the same key?

Looping through a dictionary

Looping by key gives you the value too

for k in d: gives only keys, but you can always get the value with d[k]. Still, .items() is clearer when you need both:

for subject, score in scores.items():
    print(f"{subject}: {score}")

Finding the biggest value

best = None
for subject, score in scores.items():
    if best is None or score > scores[best]:
        best = subject
print("Best subject:", best)    # music

A shortcut that does the same: max(scores, key=scores.get).

A classic pattern: counting

counts = {}
for ch in word:
    if ch in counts:
        counts[ch] += 1
    else:
        counts[ch] = 1

counts = {}
for ch in word:
    counts[ch] = counts.get(ch, 0) + 1

Trace for the word "book"

The same pattern counts anything: votes for each candidate, how many times each word appears in a story, or how often each number came up on a die.

Dictionaries with lists and dictionaries inside

student = {
    "name": "Ava",
    "grades": [90, 85, 77],
    "address": {"city": "Plantation", "state": "FL"}
}
student["grades"][0]            # 90
student["address"]["city"]      # 'Plantation'
student["grades"].append(88)    # change the list inside

Reading student["address"]["city"] step by step

1. student["address"] gives the inner dictionary {"city": "Plantation", "state": "FL"}.
2. ["city"] looks up "city" in that dictionary: 'Plantation'.

Each set of brackets works on whatever the previous step produced. If the previous step gave a list, the next brackets need an index; if it gave a dictionary, they need a key.

Real data looks like this. Information from websites and apps (often in a format called JSON) is mostly dictionaries and lists nested inside each other.

Rules for keys

Why must keys be immutable?

A dictionary finds a key quickly by turning it into a number (called a hash) that says where to look. If a key could change after being stored, its hash would change too, and the dictionary would look in the wrong place and never find it again. Keeping keys unchangeable keeps lookups reliable.

Values are free: two students can both have the value 15. Only the keys need to be unique.

Gradebook challenge

Write a Python expression that uses gradebook to produce each answer, then click Check. Practice only; nothing is recorded.

Strategy

• First, look at the structure: what are the keys, and what kind of value is stored under each (a number, a list, another dictionary)?
• Build the expression one bracket at a time and check what each step gives.
• For "how many," try len(). For totals of a list, try sum().

Common mistakes

KeyError checklist

1. Read the key in the error message. KeyError: 'ava' tells you exactly which key was not found.
2. Print the keys: print(list(d)) shows what is really in the dictionary.
3. Compare carefully: capitals, extra spaces ("Ava "), and types (the string "1" is not the number 1).

Keys from input() are always strings. If your dictionary uses number keys, convert first: d[int(choice)].

Check yourself

Choose an answer, then click Check. This is practice only. Nothing is graded or recorded.

Cheat sheet

ages = {"Ava": 15, "Ben": 16}
empty = {}
ages["Ava"]        # 15
len(ages)          # 2
"Ava" in ages      # True
for name, age in ages.items():
    print(name, age)

ages["Cy"] = 14     # add
ages["Ava"] = 16    # update
ages.update({"Di": 15})
del ages["Ben"]     # remove
x = ages.pop("Cy")  # remove + return
ages.clear()        # remove all

if "Dee" in ages:
    print(ages["Dee"])

ages.get("Dee")      # None
ages.get("Dee", 0)   # 0
ages.pop("Dee", None)

try:
    print(ages["Dee"])
except KeyError:
    print("not found")

Remember:

• Keys are unique and immutable (strings, numbers, tuples), and case sensitive
• d[key] = value adds a new pair or replaces the old value
• d[key] on a missing key raises KeyError; get() does not
• Never add or remove keys while looping over the same dictionary

Key words to know

dictionary · key · value · pair / item · KeyError · get() · default · try / except · insertion order · immutable key · nesting