Loop Idioms and Patterns

A for loop over a dictionary iterates through keys; to filter by value, use the index operator to retrieve each value and test it against a condition.

Programming

Interactive lab

Try it: Loop Tracer

How a Python for loop visits each item in turn, and how an accumulator variable (a total, a count, a best-so-far or a result list) changes on every iteration.

How it works

Initialise the accumulator before the loop.
Each iteration, the loop variable takes the next value from the list.
An if inside the loop decides whether to update the accumulator.
After the last item the loop ends and the accumulator holds the answer.

Default run (13 steps): values = [4, 9, 2, 7, 5]. Run the loop one statement at a time. … The loop has used every value. print(total) shows 27.

Simplified: A model of five fixed loop programs (sum, count, maximum, minimum, filter) run on your list — it steps the program exactly as Python would, but it does not run Python.

Educational simulation

Loading the simulation…

The Key-Value Puzzle

When a for loop iterates directly over a dictionary, the loop variable contains a key. That is useful when you want to work with keys, but it creates an extra step when your condition concerns values. To decide whether an entry qualifies, first use the key with the index operator to retrieve its corresponding value, then test that value.

What do you think happens?

A dictionary stores name counts. Which entries should pass a condition requiring a count greater than 10?

Every entry whose key is a name
Only entries whose stored value is greater than 10
Only entries whose key has more than 10 characters

Reveal answer

Answer:

Only entries whose stored value is greater than 10

The filtering condition is about each entry's value. The key helps retrieve that value, but the key itself is not what the condition tests.

From Key to Value

The index operator connects the loop variable to the value stored under that key. If the loop variable is key and the dictionary is counts, then counts[key] retrieves the value associated with the current key. The loop therefore follows three stages: obtain a key, retrieve its value with the index operator, and test the retrieved value with a condition.

When the loop gives you a dictionary key, how does the index operator connect that key to its corresponding value?

Code walkthrough

counts = {
    "Maya": 14,
    "Luis": 12,
    "Chuck": 1
}

for name in counts:
    if counts[name] > 10:
        print(name, counts[name])

1
The for statement assigns a dictionary key to name.
2
counts[name] retrieves the value associated with that key.
3
The if statement checks whether the retrieved value is greater than 10.
4
Maya and Luis pass the test, so their entries are printed.
5
Chuck has a count of 1, so its entry is skipped.

Output

Maya 14
Luis 12

The Filtering Path

For each dictionary key-value pair, what happens when the value passes or fails the filtering condition?

For each key, the condition determines whether the loop body runs. A true comparison sends the entry into the body, where it can be printed or collected. A false comparison skips the body and lets the loop continue with the next key. The condition can use different comparison operators and data types; the essential pattern remains the same: iterate through keys, retrieve values, and test those values.

Best practice

Before reading the output, predict which entries satisfy the value condition. Then trace one passing entry and one failing entry. This makes it easier to notice whether the condition is testing counts[name] or accidentally testing name.

Selecting Without Changing

Operation	What happens to qualifying entries	Typical destination
Filtering	Existing key-value pairs that pass the condition are selected	Printed output, new dictionary, or list
Transforming	Entries are modified before they are stored or used	A result collection containing changed entries

Filtering selects entries; transforming changes entries. The loop pattern in this article is primarily a filtering pattern.

Does the loop select existing entries that meet a condition, or does it modify entries before storing them?

In the filtering pattern, a qualifying entry is selected rather than altered. For example, adding counts[name] to a new dictionary preserves the key-value pair from the source dictionary. A separate operation could modify the collected dictionary later, but that would be different from deciding which entries pass the filter.

Collecting Qualifying Entries

How do qualifying dictionary entries move from the source collection into a new dictionary or list?

Code walkthrough

counts = {
    "Maya": 14,
    "Luis": 12,
    "Chuck": 1
}

filtered = {}
for name in counts:
    if counts[name] > 10:
        filtered[name] = counts[name]

selected_names = []
for name in counts:
    if counts[name] > 10:
        selected_names.append(name)

1
filtered starts as a new empty dictionary.
2
When a value passes the condition, the original key and its value are assigned to filtered.
3
After the loop, filtered contains only the passing entries.
4
selected_names starts as a new empty list.
5
When a value passes the condition, its key is appended to selected_names.
6
The dictionary result retains key-value pairs, while the list result stores only the selected keys.

Output

filtered is {"Maya": 14, "Luis": 12}
selected_names is ["Maya", "Luis"]

Mistakes That Break the Pattern

Common mistake
Comparing the key instead of the value
What it looks like
```
if name > 10:
```
Why it fails
Direct dictionary iteration supplies a key. In a name-count dictionary, the key is a name, not the numeric count being filtered.
Do this instead
Retrieve the value first: if counts[name] > 10:
Common mistake
Forgetting the index operator
What it looks like
```
if name == 10:
```
Why it fails
This compares the key with 10 instead of testing the value stored under that key.
Do this instead
Use the dictionary and current key together: counts[name]
Common mistake
Using assignment instead of comparison
What it looks like
```
if counts[name] = 10:
```
Why it fails
The filtering condition needs to compare a value with a threshold. Assignment and comparison are different operations.
Do this instead
Use a comparison operator such as == or > in the condition.
Common mistake
Modifying the dictionary being iterated over
What it looks like
Adding or removing entries from counts inside the loop over counts
Why it fails
The source pattern iterates through a dictionary and collects passing entries in a separate result. Changing the dictionary during that iteration is a common mistake.
Do this instead
Build a new dictionary for filtered results, then use or modify that result after the loop.

Before

for name in counts:
    if name > 10:
        print(name)

The condition attempts to test the key.

After

for name in counts:
    if counts[name] > 10:
        print(name)

The condition retrieves and tests the value associated with the key.

Practice the Selection Pattern

MEDIUM

Write a loop that examines a dictionary called scores and prints the keys whose values are less than 50. Then adapt the loop so it stores the passing key-value pairs in a new dictionary called low_scores.

Hints

Iterating directly over scores gives you each key.
Use scores[key] to retrieve the value for the current key.
Use one condition for printing and assign the passing key-value pair to low_scores for collection.

Your attempt (not saved)

Worked example

Tracing One Entry

Suppose the current key is Maya and counts[Maya] is 14. Decide whether the entry passes the condition counts[name] > 10.

1
Receive the key
The loop variable name receives Maya.
2
Retrieve the value
The index expression counts[name] retrieves 14.
3
Test the condition
The comparison 14 > 10 is true.
4
Run the loop body
Because the condition is true, the entry can be printed or added to a result collection.

Result

The Maya entry passes the filter.

Pattern Summary

1
A for loop that iterates directly over a dictionary supplies keys.
2
Use the index operator, such as counts[key], to retrieve the value associated with the current key.
3
Filter by testing the retrieved value, not by comparing the key directly.
4
A passing entry can be printed immediately or collected in a new dictionary or list.
5
Filtering selects existing entries; transforming changes entries before they are stored or used.

At a glance

Direct dictionary iteration gives the loop variable a key.
The index operator retrieves the value needed for a value-based condition.
A true condition selects an entry; a false condition skips it.
Filtered results can be printed, collected in a new dictionary, or collected as selected keys in a list.
Do not confuse filtering with transforming, and avoid modifying the dictionary being iterated over.

Related concepts

More concepts starting with L