List Sorting and Ordering

From Key to Value

A dictionary stores entries as key-value pairs. When a for loop iterates directly over a dictionary, the loop variable receives a key. That key can then be used inside square brackets to retrieve the corresponding value. The important sequence is: the loop produces a key, and dict[key] retrieves the value associated with that key.

scores = {"Ada": 91, "Lin": 84, "Mina": 96}

for key in scores:
    print(key, scores[key])

Ada 91
Lin 84
Mina 96

Tracing One Loop

Filtering by Value

Dictionary iteration can be combined with conditional logic. The loop still receives a key, but the condition examines dict[key], the value associated with that key. Only entries whose values satisfy the condition are printed or otherwise processed.

scores = {"Ada": 91, "Lin": 84, "Mina": 96}

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

Ada 91
Mina 96

The condition does not change which object the loop traverses: it still traverses dictionary keys. It changes what happens after each key is received. The current value is looked up, tested, and either allowed through or skipped.

Alphabetical Key Order

A direct loop over a dictionary is not the same as a loop over alphabetically sorted keys. To sort dictionary entries alphabetically by key, first extract the keys with list(dict.keys()), sort that separate list, and then loop through the sorted list. Each sorted key is used to look up its value in the original dictionary.

scores = {"Mina": 96, "Ada": 91, "Lin": 84}
sorted_keys = list(scores.keys())
sorted_keys.sort()

for key in sorted_keys:
    print(key, scores[key])

Ada 91
Lin 84
Mina 96

Two Traversal Strategies

The lookup expression can remain the same in both strategies: dict[key]. The difference is the source of key. In direct iteration, key comes from the dictionary. In sorted iteration, key comes from the separately extracted and sorted list.

Mistakes to Avoid

• Treating the loop variable as a value during direct dictionary iteration.

  A direct for loop over a dictionary iterates through keys. The loop variable therefore represents a key.

  Fix: Use a key variable and retrieve the value with scores[key].

• Testing the key instead of the value when filtering.

  The value-based condition must examine the value associated with the current key.

  Fix: Use a condition such as if scores[key] >= 90:.

• Assuming that sorting a key list sorts the original dictionary.

  The sorting operation applies to the separate list of keys.

  Fix: Continue using scores as the original dictionary and use sorted_keys to control the traversal order.

• Sorting keys but then printing only the keys.

  This traverses the sorted keys but does not display the corresponding values.

  Fix: Use print(key, scores[key]) when both parts of each entry are needed.

Practice Check

Key Takeaways

1. A for loop over a dictionary iterates through keys.
2. Use dict[key] to access the value associated with the current key.
3. A conditional inside the loop can filter entries by value.
4. Alphabetical ordering requires extracting the keys into a list, sorting that list, and looping through it.
5. Sorting the separate key list does not change the original dictionary.