keys(), values() and items() in Practice

A dictionary exposes three views over its contents: keys, values and items.

scores = {"ada": 99, "alan": 91}

print(list(scores.keys()))     # ['ada', 'alan']
print(list(scores.values()))   # [99, 91]
print(list(scores.items()))    # [('ada', 99), ('alan', 91)]

# Views are live - they reflect later changes
view = scores.keys()
scores["grace"] = 87
print(list(view))               # ['ada', 'alan', 'grace']

Each method returns a view object rather than a list, and the last block shows the difference that matters: the view was taken before grace was added, yet listing it afterwards includes grace. A view is a window onto the dictionary, not a snapshot.

That behaviour is useful — you can hold a view and keep iterating it — but it also has a consequence. Modifying the dictionary's size while you are iterating over a view raises a RuntimeError telling you the dictionary changed size during iteration. Assigning to an existing key is fine, because the size does not change; adding or removing a key is not.

Wrapping a view in list() takes a snapshot, which is what you want when you need to iterate over the keys and modify the dictionary inside the loop.

Another detail worth knowing is that the values view is not unique — two keys can hold the same value, so list(scores.values()) may contain duplicates even though the keys are unique. If you want the distinct values, use a set: set(scores.values()).

Iterating the dictionary directly gives you the keys. To get the pairs, use items() and unpack each tuple.

scores = {"ada": 99, "alan": 91}

for name, score in scores.items():
    print(name, score)

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

The first loop prints ada 99 and alan 91. The second prints the same thing but looks up each value with a second hash lookup, so items() is the faster and clearer form whenever you need both halves.

Unpacking works because each item is a two-element tuple, and the for statement unpacks it into the two names. That is the same tuple-unpacking mechanism used in assignments, and it means the loop fails loudly with a ValueError if the pairs are not of length two — which is a good reason to prefer items() over zipping keys and values separately, where a length mismatch would silently truncate.

Two variations worth knowing. If you need the index as well, wrap the loop in enumerate: for index, (name, score) in scores.items(). And if you only want one half, use the values view: for score in scores.values(), which avoids the unpack entirely.

The three methods differ in what they yield. keys() yields the keys, values() yields the values and items() yields (key, value) tuples. All three return view objects in Python 3, and iterating a dictionary directly is equivalent to iterating its keys view.

Views were introduced in Python 3 and they are deliberately not lists. A list is a snapshot; a view is a live window onto the dictionary. If you take a view and then add a key, listing the view shows the new key. That is more useful than it first sounds, because it means you can write a function that takes a view and see the current state of the data.

There is a performance reason too. Returning a view is O(1) — it is just a small object holding a reference to the dictionary. Returning a list would mean copying every key or value on every call, so a loop calling dict.keys() inside a hot path would allocate a new list each iteration. With a view, the iteration itself is fast and memory efficient.

Three practical implications. The views support set-like operations, so scores.keys() & other.keys() gives the shared keys and scores.keys() - other.keys() gives the difference. Views are iterable, so you can call len on them and test membership in them. And because they are live, mutating the dictionary's size while iterating a view raises a RuntimeError — take a list snapshot first if you need to modify the dictionary inside the loop.

One last quirk: the values view is not unique, so two keys can produce the same value. If you want distinct values, wrap it in a set.