Processing and Building Dictionaries

A dictionary may represent one record, such as a book. It can also represent a lookup table: a connection from each category to its count, each product to its stock, or each identifier to some information.

The loop patterns are familiar. The new question is which keys and values the dictionary should contain.

Direct Iteration Produces Keys

stock = {"notebook": 4, "pencil": 12, "eraser": 3}

for product in stock:
    print(f"{product}: {stock[product]}")

Each iteration binds product to one key. The bracket lookup retrieves the value for that key.

For this dictionary, the output is:

notebook: 4
pencil: 12
eraser: 3

Dictionaries preserve insertion order. That does not make them lists: the access operation still uses a key, and the keys are not automatically sorted. We will ask for sorted output explicitly later in the part.

The same structure can calculate a total:

total = 0

for product in stock:
    total = total + stock[product]

assert total == 19

There is no new accumulation algorithm here. Instead of adding a list item directly, the loop retrieves the value associated with its current key.

Retrieve a Key and Its Value Together

The .items() method lets a loop receive a key and its value together:

for product, quantity in stock.items():
    print(f"{product}: {quantity}")

The two names are assigned from one pair on each iteration. On the first iteration, product is "notebook" and quantity is 4. This is called unpacking. Each item produced by .items() is a two-item tuple, a fixed sequence containing the key and value. You do not need a separate tuple-processing technique to use this loop.

Choose the version that makes the operation clearer. A key-only loop is useful when the key drives several lookups. An items loop is convenient when both the key and value are needed together.

Tracing makes the difference between a key-only loop and an items loop visible. Choose deliberately between those forms when you process another dictionary.

A Separate Counter for Each Key

Part 2 used one counter to count selected characters. What if we need a count for every word?

Each key has its own counter. Before using the stepper, predict the dictionary after each of the first three words: "red", "blue", and "red" again. Does the initialization line run on all three iterations?

The stepper uses just those three words. Check your predictions by following which lines execute and which dictionary entry changes.

The repeated "red" must keep its earlier count before adding one. Initialization belongs inside the missing-key condition; incrementing belongs after it. You could shorten the update using .get(word, 0), but use the explicit version until you can explain these two responsibilities.

The arranged program supplies the control-flow skeleton for per-category counting. The next task asks you to decide what should count as a category and which input values belong outside the result.

Updating Values While Iterating

Replacing values for existing keys is different from adding or deleting keys:

stock = {"notebook": 4, "pencil": 12}

for product in stock:
    stock[product] = stock[product] + 1

assert stock == {"notebook": 5, "pencil": 13}

The loop still visits the same keys. By contrast, changing the set of keys while iterating over that dictionary can invalidate the iteration. When selecting entries, build another dictionary instead:

def available_stock(stock):
    available = {}

    for product, quantity in stock.items():
        if quantity > 0:
            available[product] = quantity

    return available

For the numeric values used here, the result can be updated independently without changing the original dictionary’s entries. Later chapters examine what changes when values are themselves mutable collections.

Review the counter and selection patterns before writing another dictionary function:

Selection and transformation can both build a result dictionary. The difference is whether an input entry determines membership in the result or the value stored there.

Check Your Understanding

1. What does a direct for loop over a dictionary produce?
2. What do the two names in an .items() loop receive?
3. Why does a per-key counter initialize only when a key is new?
4. Why does preserving insertion order not mean the keys are sorted?
5. Why is building a new dictionary a useful way to select entries?

LEIA activity: dictionaries

In this activity, you will practise counting with dictionaries and selecting entries for a new dictionary by completing a programming task with an AI simulated client on the LEIA platform. You will be randomly assigned to a text-based or voice-based version.

This is part of a research study. The study explores how these ways of interacting support programming and learning. You can read more from the participant information sheet and the privacy notice. Research participation is voluntary; your research consent choices do not affect the course points available for these exercises.

Do not enter personal or sensitive information in the LEIA platform. This includes names, personal email addresses, student numbers, and any other identifying details in your messages, speech, code, or comments.

The voice-based version requires a microphone and speakers or headphones. If you have technical problems or cannot use the voice-based version, contact the course staff for access to the text-based version.

Once you have completed the activity and submitted your Conversation Viewer Link, please complete the survey below.