Dictionaries

A list finds items by position: scores[0], scores[1]. Often it's much more natural to find things by name: a word's definition, a user's email, a product's price. A dictionary stores key-value pairs, so you look up a value using its key.

Creating a dictionary

Write key: value pairs inside curly braces:

person = {
    "name": "Ada",
    "age": 36,
    "city": "London",
}

print(person)
print(type(person))
print(len(person))   # number of pairs

Each pair is a key, a colon, then its value, and the pairs are separated by commas. Keys are usually strings, but they can be numbers or tuples too. Values can be anything, including lists or other dictionaries.

A few rules to know:

• Each key appears only once. If you write the same key twice, the last value wins.
• Keys are case-sensitive: "name" and "Name" are different keys.
• The pairs stay in the order you added them.
• {} is an empty dictionary.

Looking up values

Put the key in square brackets:

person = {"name": "Ada", "age": 36, "city": "London"}

print(person["name"])
print(person["age"])

Lookups only work in one direction: from a key to its value. There's no person["Ada"] to find the key from a value. That's why you choose the thing you'll search by as the key.

Asking for a key that doesn't exist raises a KeyError:

person = {"name": "Ada", "age": 36}
print(person["email"])

Safer lookups with get()

get() returns None instead of crashing, or a default value that you choose:

person = {"name": "Ada", "age": 36}

print(person.get("name"))
print(person.get("email"))
print(person.get("email", "no email"))

Use in to check whether a key exists:

person = {"name": "Ada", "age": 36}

print("age" in person)
print("email" in person)

in checks the keys, not the values: "Ada" in person is False.

None of these add the key to the dictionary; they only read it.

Adding and changing entries

Assigning to a key adds it if it's new, or replaces its value if it already exists:

stock = {"apples": 10, "pears": 4}

# new key: added
stock["bananas"] = 7

# existing key: replaced
stock["apples"] = 12

# add 1 to the current value
stock["pears"] += 1

print(stock)

The same syntax adds or updates, so there's no separate "add" method. += needs a current value, though: stock["kiwis"] += 1 is a KeyError because there are no kiwis yet. That's the problem the counting pattern below solves.

update() adds or changes several entries at once:

stock = {"apples": 10}
stock.update({"pears": 3, "apples": 15})
print(stock)

defaults = {"theme": "light", "font_size": 14}
choices = {"font_size": 18}

settings = defaults | choices
print(settings)
print(defaults)    # unchanged

Removing entries

stock = {"apples": 10, "pears": 4, "bananas": 7, "kiwis": 2}

# remove a key and give back its value
removed = stock.pop("pears")
print(removed, stock)

# remove a key
del stock["bananas"]
print(stock)

# remove everything
stock.clear()
print(stock)

Keys, values and items

Three methods give you views of the dictionary's contents:

prices = {"coffee": 3.5, "tea": 2.8, "juice": 4.0}

print(list(prices.keys()))
print(list(prices.values()))
print(list(prices.items()))

• keys() gives the keys, values() the values, and items() each pair as a (key, value) tuple.
• They're wrapped in list() here only so they print neatly; on their own they print as dict_keys([...]) and so on.
• They follow the dictionary's order, so the first key, first value and first item all belong together.

These come in handy for calculations:

prices = {"coffee": 3.5, "tea": 2.8, "juice": 4.0}

print(sum(prices.values()))
print(max(prices.values()))

# a dictionary on its own means its keys
print(sorted(prices))

max(prices.values()) gives the highest price, 4.0, not which drink it is. When you pass the dictionary itself, as in sorted(prices), Python uses the keys.

You'll loop over these in the For Loops lesson, which is where dictionaries really shine.

Counting with a dictionary

A very common pattern is counting things. get(key, 0) gives 0 the first time a key is seen:

votes = {}

votes["red"] = votes.get("red", 0) + 1
votes["blue"] = votes.get("blue", 0) + 1
votes["red"] = votes.get("red", 0) + 1

print(votes)

The same line works whether or not the key exists yet, which is why this pattern is everywhere.

from collections import Counter

votes = ["red", "blue", "red", "green", "red", "blue"]
counts = Counter(votes)

print(counts)
print(counts["red"])
# missing keys count as 0
print(counts["purple"])

# the two most common
print(counts.most_common(2))

student = {
    "name": "Mia",
    "grades": [88, 92, 79],
    "address": {
        "city": "Leeds",
        "postcode": "LS1 4AP",
    },
}

print(student["grades"][1])
print(student["address"]["city"])

student["grades"].append(95)
print(student["grades"])

distances = {("London", "Paris"): 344}
print(distances[("London", "Paris")])

bad = {["a", "b"]: 1}

Exercises

Exercise 1: Contact card

Create a dictionary for a contact with keys name, phone and email, then print the phone number.

contact = {}

Exercise 2: Update the inventory

Sell 3 apples, add a new item "mangos" with 6 in stock, and remove "pears". It should print {'apples': 7, 'bananas': 5, 'mangos': 6}.

inventory = {"apples": 10, "pears": 4, "bananas": 5}

print(inventory)

Exercise 3: Safe lookup

Look up the capital of country. If the country isn't in the dictionary, print Unknown instead of crashing.

capitals = {"France": "Paris", "Japan": "Tokyo", "Kenya": "Nairobi"}
country = "Brazil"

Exercise 4: Order total

The order dictionary maps items to quantities, and prices maps items to prices. Calculate the total for coffee and cake and print Total: 12.0.

prices = {"coffee": 3.0, "cake": 4.5, "tea": 2.5}
order = {"coffee": 1, "cake": 2}

Dictionary methods at a glance

Each example starts from d = {"a": 1, "b": 2}. The Result column shows what the method gives back, or what d looks like afterwards for methods that change it.

Useful operations that aren't methods:

Summary

• A dictionary maps keys to values: {"name": "Ada"}.
• Look up values with d[key]. A missing key raises KeyError. Use d.get(key, default) to be safe.
• d[key] = value adds or updates. pop() and del remove.
• keys(), values() and items() give you the contents.