Looping Through Dictionaries

Quick review: one dictionary, three views

grades = {"Ava": 92, "Ben": 85, "Cy": 77}

How to pick the right view

Ask yourself what the loop needs to know on each pass:

• Only the names (keys)? → loop over the dictionary itself, or .keys().
• Only the numbers (values)? → .values().
• Both, together? → .items().

Why "insertion order" matters: if you add Ava, then Ben, then Cy, every loop visits them in that order. Updating Ben's grade does not move him. Only removing a key and adding it back puts it at the end.

Looping over the keys

for name in grades:
    print(name)

for name in grades:
    print(name, "scored", grades[name])

What happens on each pass

1. Pass 1: name is "Ava". grades[name] looks up 92.
2. Pass 2: name is "Ben". grades[name] looks up 85.
3. Pass 3: name is "Cy". grades[name] looks up 77.

The lookup inside the loop is always safe, because every key the loop gives you is guaranteed to be in the dictionary.

Keys are perfect for a roster or a menu: print every name, or every item someone can order, without needing the values at all.

Working with .keys()

What "live" means

A view is not a snapshot; it always shows the dictionary as it is right now. In the demo, names was created before Di was added, yet printing it afterward includes Di. A list made with list(grades.keys()) is different: it is a copy taken at that moment and does not update.

Sorting keys: sorted(grades) gives a new alphabetical list without changing the dictionary's order. To sort names by their grades instead, use sorted(grades, key=grades.get, reverse=True), which gives ['Ava', 'Ben', 'Cy'] (highest grade first).

Looping over the values with .values()

for grade in grades.values():
    print(grade)

total = sum(grades.values())          # 254
average = total / len(grades)         # 84.666...
print(max(grades.values()))           # 92
print(min(grades.values()))           # 77

Counting with values

passing = 0
for grade in grades.values():
    if grade >= 80:
        passing += 1
print(passing, "students scored 80 or higher")   # 2

This is the counting pattern you already know, applied to the values. Because you only need the numbers, .values() is the simplest choice.

Check for an empty dictionary before computing an average: len(grades) of 0 would cause a ZeroDivisionError, and max() of no values is a ValueError.

Looping over pairs with .items()

for name, grade in grades.items():
    print(name, "scored", grade)

What .items() hands the loop

On each pass, Python gets one tuple, like ('Ben', 85), and splits it: name = 'Ben', grade = 85. It is exactly the same as writing name, grade = ('Ben', 85).

A sneaky version of the bug

Without .items(), Python tries to unpack each key string into two names. "Ava" has 3 letters, so it fails. But "Cy" has exactly 2 letters, so it "works": name becomes 'C' and grade becomes 'y'! If you ever see single letters where you expected names and numbers, check for a missing .items().

Loop Visualizer

Pick a loop and click Next (or Play). The highlighted row is the pair Python is visiting; the variables and output update at each step. Nothing is recorded.

Compare the three loops

All three visit the pairs in the same order. The only difference is what you get to hold on each pass.

Printing a neat report with f-strings

for name, grade in grades.items():
    print(f"{name}: {grade}")

Reading a format code

Everything after the colon inside { } is a format instruction:

• < means left-align, > right-align, and the number is the total width. Text usually looks best left-aligned and numbers right-aligned, so the digits line up.
• .1f means a float with 1 digit after the decimal point. .2f is good for money.
• You can combine them: {avg:>6.1f} right-aligns in 6 spaces with 1 decimal place.

Quotes inside an f-string: if the f-string uses double quotes, use single quotes for any string inside the braces, like f"{'Name':<6}".

Does a key exist? Use in

"Ava" in grades       # True
"Dee" in grades       # False
"Dee" not in grades   # True

name = input("Student: ")
if name in grades:
    print(name, "has", grades[name])
else:
    print("No grade for", name)

Why check before you look up?

A program that uses user input cannot know in advance which names someone will type. One typo would crash the program with a KeyError. The if name in grades: check turns that crash into a friendly message.

Making the check friendlier

Users often type extra spaces or different capitals. Cleaning the input first helps, as long as your keys are stored the same way:

name = input("Student: ").strip().title()   # " ava " becomes "Ava"
if name in grades:
    print(name, "has", grades[name])

Checking values and pairs

Finding who had a certain value

85 in grades.values() tells you whether someone scored 85, but not who. To find the name, loop over the pairs:

for name, grade in grades.items():
    if grade == 85:
        print(name, "scored 85")      # Ben scored 85

More than one student might have the same value, so this loop can find several matches. Keys, on the other hand, are always unique.

Key Detective

Type a key (text needs quotes) and click Investigate. See what in, square brackets, and .get() each do with it. Nothing is recorded.

What each tool does with a missing key

Try 92 as the key to see that values are not keys.

Common patterns

Building a new dictionary from an old one

curved = {}
for name, grade in grades.items():
    curved[name] = grade + 5
print(curved)    # {'Ava': 97, 'Ben': 90, 'Cy': 82}

Python also has a one-line dictionary comprehension for this, just like list comprehensions: {name: grade + 5 for name, grade in grades.items()}. Add an if at the end to filter: {n: g for n, g in grades.items() if g >= 80} keeps only Ava and Ben.

Changing a dictionary while looping

Why adding keys during a loop is a problem

The loop is walking through the dictionary's keys in order. If the dictionary grows or shrinks partway through, Python can no longer be sure which keys it has visited, so it stops with an error instead of guessing.

The safe way to remove failing students

for name in list(grades):      # a snapshot of the keys
    if grades[name] < 80:
        del grades[name]           # safe: we loop over the snapshot

list(grades) makes a separate list of the keys before the loop starts, so deleting from the dictionary does not disturb the loop.

Loop Builder challenge

Fill in the blanks with the dropdowns so each program prints exactly the target output, then click Check. The code really runs. Practice only; nothing is recorded.

Strategy

1. Look at the target output. Does each line show a key, a value, or both?
2. Pick d/.keys(), .values(), or .items() to match.
3. Is the order alphabetical? Then you need sorted().
4. Are only some entries shown? Then you need an if inside the loop.

Common mistakes

Reading the error messages

• "too many values to unpack" or "not enough values": you wrote two loop names but forgot .items().
• "unsupported operand ... 'int' and 'str'": you are doing math on keys (strings) instead of values.
• "not subscriptable": you used [0] on a view. Wrap it in list().
• "not iterable": you forgot the () after .values, .keys, or .items.
• No error, but False: plain in only checks keys, and checks capitals exactly.

Check yourself

Every question uses grades = {"Ava": 92, "Ben": 85, "Cy": 77}. Choose an answer, then click Check. Practice only; nothing is graded or recorded.

Cheat sheet

for name in grades:          # keys
for name in grades.keys():   # keys
for g in grades.values():    # values
for name, g in grades.items():  # pairs
for name in sorted(grades):  # keys, A-Z

"Ava" in grades           # key?
"Dee" not in grades       # key missing?
92 in grades.values()     # value?
("Ava", 92) in grades.items()

if name in grades:
    print(grades[name])

list(grades)              # list of keys
len(grades)               # how many
sum(grades.values())      # total
max(grades.values())      # highest
print(f"{name}: {g}")     # neat output

Remember:

• A plain loop or a plain in works with keys
• Need both key and value? Use .items() and two loop names
• Check with in before using d[key] on a key that might be missing
• Do not add or remove keys while looping; loop over list(d) instead

Key words to know

keys() · values() · items() · view · insertion order · unpacking · in / not in · f-string · format code · dictionary comprehension · RuntimeError