Iterating Through Dictionary Keys

The Key-First Loop

When a dictionary is used directly as the sequence in a for loop, Python gives the loop one key at a time. It does not automatically give the loop the corresponding values. This key-first behavior is the foundation for both ordinary dictionary traversal and filtering dictionary entries by value.

counts = {
    "chuck": 1,
    "annie": 13,
    "jan": 15
}

for key in counts:
    print(key)

chuck
annie
jan

The loop variable key contains the current key, such as chuck or annie. To obtain the associated count, use the current key inside bracket notation: counts[key]. The loop therefore has two separate actions: it receives a key from the dictionary, then uses that key to retrieve the value.

Following a Value Filter

Filtering by value combines three elements. First, the for statement supplies a key. Second, the index operator retrieves the value associated with that key. Third, an if statement tests the retrieved value. Only when the condition is true does the loop body run for that entry.

counts = { "chuck": 1, "annie": 13, "jan": 15 } for key in counts: if counts[key] > 10: print(key, counts[key])

The Bracket Lookup

The expression key and the expression counts[key] are not interchangeable. key refers to the dictionary key currently held by the loop variable. counts[key] refers to the value stored under that key. A condition that is meant to test counts must therefore compare counts[key], not key.

Insertion Order and Output

Dictionary keys maintain insertion order. If the dictionary is created with chuck first, annie second, and jan third, a direct for loop visits those keys in that same order. This makes the order of printed output predictable and makes it possible to trace the loop one iteration at a time.

Keeping the Selected Entries

Printing a passing entry is useful when inspecting a loop. When the selected entries are needed later, assign each passing key-value pair to a new dictionary. The original dictionary is used for the iteration, while filtered stores only the entries that satisfy the condition.

counts = {
    "chuck": 1,
    "annie": 13,
    "jan": 15
}

filtered = {}

for key in counts:
    if counts[key] > 10:
        filtered[key] = counts[key]

print(filtered)

{'annie': 13, 'jan': 15}

This is filtering: the loop selects existing entries whose values pass the test. The selected key and its existing value are placed in filtered. The loop does not change those entries while selecting them. A filtered dictionary can later be passed to other functions, iterated again, or modified further.

A list can also be used when the later task needs only the selected keys or another collected representation. The essential filtering step remains the same: iterate through keys, retrieve each value with bracket notation, and keep the entry when the condition is true.

Filtering Versus Changing

For the pattern in this article, the condition selects entries based on their values. Assigning filtered[key] = counts[key] preserves the selected key and value in a new dictionary. That is different from selecting an entry and then modifying it. Keeping this distinction clear helps you identify whether your loop is choosing existing data or producing changed data.

Mistakes That Break the Filter

• Comparing the key instead of the value

  The loop variable contains a key. It does not contain the dictionary value that should be tested.

  Fix: Use if counts[key] > 10: so the index operator retrieves the associated value first.

• Forgetting the index operator

  This compares the key directly with 10 rather than testing the value stored under that key.

  Fix: Write the comparison against counts[key].

• Using assignment where comparison is intended

  The condition needs to compare the retrieved value with a threshold.

  Fix: Use a comparison such as counts[key] == 10 or counts[key] > 10.

• Expecting the loop variable to contain both pieces of the entry

  A direct dictionary loop traverses keys. The value must be retrieved separately.

  Fix: Use print(key, counts[key]) when both the key and its corresponding value are needed.

• Modifying the dictionary being traversed

  Changing the dictionary during iteration is identified as a common mistake in this pattern.

  Fix: Collect selected entries in a new dictionary such as filtered, then use that result afterward.

Practice the Trace

scores = {
    "red": 4,
    "blue": 12,
    "green": 7
}

for key in scores:
    if scores[key] > 5:
        print(key, scores[key])

blue 12
green 7

Red is examined first but is not printed because its value is 4. Blue is printed next because 12 is greater than 5. Green is printed last because 7 is also greater than 5. The output order follows the dictionary's insertion order, while the condition determines which entries appear.

Key Takeaways

1. A for loop over a dictionary traverses its keys.
2. Use dictionary[key] to retrieve the value associated with the current key.
3. To filter by value, test the retrieved value in an if condition.
4. Filtered entries can be printed immediately or collected in a new dictionary.
5. Dictionary keys maintain insertion order, so the loop and its output follow that order.