Learning how to iterate over a dictionary in python is a fundamental skill for anyone working with data structures, configuration files, or JSON‑like payloads. In real terms, dictionaries store key‑value pairs, and being able to traverse them efficiently lets you search, transform, or aggregate information with clean, readable code. This guide walks through the most common iteration patterns, explains when each is useful, highlights performance considerations, and shows how to avoid typical pitfalls such as modifying a dictionary while looping over it Simple, but easy to overlook. Took long enough..
Real talk — this step gets skipped all the time Small thing, real impact..
Why Iterate Over a Dictionary?
Dictionaries are ubiquitous in Python because they provide O(1) average‑time lookups by key. Iteration becomes necessary when you need to:
- Inspect or validate every entry (e.g., checking for missing required fields).
- Transform values (e.g., converting strings to integers).
- Aggregate data (e.g., summing numeric values across all keys).
- Filter items based on a condition (e.g., keeping only entries with values above a threshold).
- Serialize or deserialize data for storage or network transmission.
Understanding the different ways to loop over a dictionary helps you pick the most readable and efficient approach for each scenario No workaround needed..
Basic Iteration Patterns
Looping Over Keys Only
By default, iterating over a dictionary yields its keys. This is the most straightforward pattern when you only need to identify which entries exist Not complicated — just consistent..
person = {"name": "Ada", "age": 30, "city": "London"}
for key in person:
print(key) # name, age, city
Use this when you need to check for the presence of a key or build a list of keys.
Looping Over Values Only
If you only care about the stored values, call .values() which returns a view of all dictionary values.
for value in person.values():
print(value) # Ada, 30, London
Useful for calculations that ignore keys, such as finding the maximum value.
Looping Over Both Keys and Values
The .items() method returns a view of (key, value) tuples, allowing you to process both parts simultaneously.
for key, value in person.items():
print(f"{key}: {value}")
# name: Ada
# age: 30
# city: London
This is the most common pattern when you need to examine or modify each pair.
Advanced Iteration Techniques
Using Dictionary Views Directly
The objects returned by .keys(), .values(), and .items() are dynamic views. They reflect changes to the dictionary in real time, which can be handy but also dangerous if you mutate the dictionary while iterating Most people skip this — try not to. That alone is useful..
keys_view = person.keys()
person["country"] = "UK"
print(list(keys_view)) # ['name', 'age', 'city', 'country']
Enumerating Items
When you need an explicit counter alongside the key‑value pair, combine enumerate with .items() Small thing, real impact..
for idx, (key, value) in enumerate(person.items(), start=1):
print(f"{idx}. {key} -> {value}")
# 1. name -> Ada
# 2. age -> 30
# 3. city -> London
Sorting During Iteration
Dictionaries preserve insertion order (as of Python 3.7), but you may want to iterate in a sorted order. Apply sorted() to the keys, values, or items.
for key in sorted(person):
print(key, person[key])
# age 30
# city London
# name Ada
To sort by value instead:
for key, value in sorted(person.items(), key=lambda item: item[1]):
print(key, value)
# age 30
# name Ada
# city London
Using List Comprehensions for Quick Transformations
If you need to produce a new list or dictionary based on the original, comprehensions are concise and fast.
# List of uppercase names
upper_names = [v.upper() for k, v in person.items() if isinstance(v, str)]
# {'name': 'ADA'}
# New dictionary with ages incremented by one
incremented_age = {k: v + 1 for k, v in person.items() if isinstance(v, int)}
# {'age': 31}
While Loop with Manual Iteration
Although rare, you can obtain an iterator explicitly and advance it with next(). This mirrors low‑level iteration but is generally less readable.
it = iter(person.items())
while True:
try:
k, v = next(it)
print(k, v)
except StopIteration:
break
Performance Considerations
- View objects vs. lists:
.keys(),.values(), and.items()return lightweight views that do not copy data. Converting them to a list (list(dict.keys())) incurs O(n) memory and time overhead—only do this if you need a snapshot that won’t change. - Avoid repeated attribute lookups: Inside a tight loop, store the view in a local variable to reduce attribute access cost.
- Modifying size during iteration: Adding or removing keys while iterating over the dictionary raises a
RuntimeError. If you must modify the dictionary, iterate over a copy of the keys or collect changes to apply afterward.
# Safe way to delete items meeting a condition
for key in list(person.keys()): # list creates a static snapshot
if key == "age":
del person[key]
Common Pitfalls and How to Avoid Them
| Pitfall | Symptom | Solution |
|---|---|---|
| Modifying dict while iterating | RuntimeError: dictionary changed size during iteration |
Iterate over `list(dict. |
Confusing .OrderedDict if you need guaranteed order on older interpreters, or simply rely on insertion order in modern Python. items()with.On top of that, g. Think about it: zip(keys, values)` |
Mismatched pairs if dictionary changes mid‑loop | Stick to . , [[] for _ in range(n)]not[[]] * n`). |
| Using mutable default values in comprehensions | Shared mutable objects across entries | Ensure each iteration creates a new object (e.keys())` or collect deletions/insertions in a separate list. But 7** |
| **Assuming order before Python 3. In practice, items()` which always provides synchronized pairs. | ||
| Iterating over a view after the dict is deleted | Referencing a dead view | Keep the dictionary alive as long as you need the view, or convert to a list if the dictionary may be discarded. |
The official docs gloss over this. That's a mistake.
Advanced Iteration Patterns
Merging and Updating On the Fly
The moment you need to combine data from multiple dictionaries while iterating, ChainMap (from collections) or the | union operator (Python 3.9+) let you treat several mappings as a single logical unit without creating an intermediate copy.
from collections import ChainMap
defaults = {"timeout": 30, "retries": 3, "verbose": False}
user_cfg = {"timeout": 10, "verbose": True}
# ChainMap searches mappings in order; updates affect the first mapping only
config = ChainMap(user_cfg, defaults)
for k, v in config.items():
print(f"{k}: {v}")
# timeout: 10
# retries: 3
# verbose: True
For a true merged dictionary that you can iterate freely, the union operator is cleaner:
merged = defaults | user_cfg # Python 3.9+
for k, v in merged.items():
...
Iterating in Sorted or Custom Order
Dictionaries preserve insertion order, but sometimes you need a different sequence—alphabetical keys, descending values, or a domain-specific sort key. Because views are iterable, you can feed them directly into sorted():
scores = {"alice": 42, "bob": 17, "carol": 33}
# Alphabetical by key
for name in sorted(scores):
print(name, scores[name])
# Descending by value
for name, score in sorted(scores.items(), key=lambda kv: kv[1], reverse=True):
print(f"{name}: {score}")
Parallel Iteration with zip
When you have two dictionaries with identical keys (or a known subset) and want to process them side-by-side, zip on the .values() views avoids repeated key lookups:
prices = {"apple": 1.2, "banana": 0.5, "cherry": 2.5}
quantities = {"apple": 4, "banana": 12, "cherry": 3}
for price, qty in zip(prices.Worth adding: values(), quantities. values()):
revenue = price * qty
print(f"Revenue: {revenue:.
> **Caution:** `zip` stops at the shortest iterable. Ensure the dictionaries share the same key set, or explicitly align them first: `zip((prices[k] for k in common_keys), (quantities[k] for k in common_keys))`.
### Asynchronous Iteration (Python 3.10+)
If your dictionary values are awaitables (e.g., coroutines fetching remote data), you can iterate and `await` sequentially or in parallel:
```python
import asyncio
async def fetch(user_id):
await asyncio.sleep(0.1)
return f"data-{user_id}"
tasks = {1: fetch(1), 2: fetch(2), 3: fetch(3)}
# Sequential
for uid, coro in tasks.items():
result = await coro
print(uid, result)
# Parallel with asyncio.gather
results = await asyncio.gather(*tasks.values())
for uid, result in zip(tasks.keys(), results):
print(uid, result)
Real-World Mini-Case: Configurable Data Pipeline
Imagine a lightweight ETL step where each record is a dictionary. You need to:
- Filter out records missing required fields.
- Transform specific columns (e.g., normalize strings, parse dates).
- Aggregate a running total.
from datetime import datetime
RAW_RECORDS = [
{"id": 1, "name": " Alice ", "ts": "2024-01-01T12:00:00", "amount": "100.5"},
{"id": 2, "name": "Bob", "ts": "2024-01-02T08:30:00", "amount": "200"},
{"id": 3, "name": " Carol ", "ts": "invalid", "amount": "50"}, # bad timestamp
{"id": 4, "amount": "300"}, # missing name/ts
]
REQUIRED = {"id", "name", "ts", "amount"}
cleaned = []
total = 0.0
for rec in RAW_RECORDS:
# 1. Filter
if not REQUIRED.issubset(rec):
continue
# 2. Transform
try:
rec["name"] = rec["name"].strip()
rec["ts"] = datetime.
# 3. Aggregate
total += rec["amount"]
cleaned.append(rec)
print(f"Processed {len(cleaned)} records, total amount: {total}")
# Processed 2 records, total amount: 300.5
The loop above uses only standard dictionary iteration (
Beyond the basic patterns shown so far, there are several idiomatic tricks that make dictionary iteration both expressive and efficient in real‑world codebases. Below are a few techniques that often appear in production scripts, libraries, and data‑engineering pipelines.
1. Comprehensions for One‑Shot Transformations
When you need to build a new dictionary from an existing one, a dict‑comprehension is usually clearer than an explicit loop:
# Normalise all string values while preserving other types
norm = {k: v.strip() if isinstance(v, str) else v
for k, v in raw.items()}
Because the comprehension evaluates the source view only once, it avoids the overhead of repeated attribute look‑ups and works nicely with static type checkers (e.g., mypy) when you annotate the result type.
2. Filtering with filter or Generator Expressions
If the goal is to drop entries based on a predicate, you can feed a generator straight into a dict constructor:
# Keep only entries where the value is positive
positive = dict(filter(lambda kv: kv[1] > 0, data.items()))
# or, equivalently
positive = {k: v for k, v in data.items() if v > 0}
The generator form shines when the source dictionary is huge and you only need a small subset, because it never materialises the intermediate list of items.
3. Sorting by Key or Value
Dictionaries preserve insertion order (as of Python 3.7), so you can easily produce a sorted view:
# Ascending by value
sorted_by_val = dict(sorted(data.items(), key=lambda item: item[1]))
# Descending by key length
sorted_by_key_len = dict(sorted(data.items(),
key=lambda kv: len(kv[0]),
reverse=True))
When you only need the ordered sequence (e.But g. , for reporting) you can skip the dict() call and iterate over the list of tuples directly, saving the cost of rebuilding a mapping.
4. Merging Multiple Sources with the Union Operator
Python 3.9 introduced the | (union) and |= (in‑place union) operators for dictionaries, which are handy when layering configuration defaults, overrides, and environment‑specific values:
BASE = {"timeout": 30, "retries": 3, "log_level": "INFO"}
USER = {"timeout": 10} # user‑supplied override
ENV = {"log_level": "DEBUG"} # env‑specific tweak
settings = BASE | USER | ENV # {"timeout": 10, "retries": 3, "log_level": "DEBUG"}
The operation is left‑to‑right, so later dictionaries win on key conflicts—exactly the semantics most configuration systems need That's the whole idea..
5. Safe In‑Place Updates While Iterating
Mutating a dictionary while iterating over it raises RuntimeError. A common workaround is to iterate over a static snapshot of the keys or items:
# Remove entries whose value is None without breaking the loop
for k in list(data.keys()): # list() creates a snapshot
if data[k] is None:
del data[k]
Alternatively, you can collect the keys to delete in a separate set and perform a bulk removal after the loop:
to_remove = {k for k, v in data.items() if v is None}
data.difference_update(to_remove) # removes all keys in one go
6. Leveraging View Objects as Sets
dict.keys(), dict.values(), and dict.items() return set‑like views that support typical set operations. This can be useful for validating schema conformity or finding intersecting keys between two dictionaries:
required = {"id", "name", "
Continuing from where we left off, the view objects returned by `dict.keys()`, `dict.On the flip side, values()`, and `dict. items()` behave much like sets, enabling concise membership tests and set‑algebra without materialising intermediate collections.
```python
# Suppose we have two configuration dictionaries
default_cfg = {"host": "localhost", "port": 8080, "debug": False, "timeout": 30}
user_cfg = {"port": 9000, "debug": True, "theme": "dark"}
# 1. Find keys that the user supplied but are not recognised in the default schema
unexpected_keys = user_cfg.keys() - default_cfg.keys()
# unexpected_keys => {'theme'}
# 2. Verify that all required keys are present in the merged configuration
required = {"id", "name", "email"}
merged = default_cfg | user_cfg
missing = required - merged.keys()
if missing:
raise ValueError(f"Missing required fields: {missing}")
# 3. Detect duplicate values across different keys (e.g., ensuring no two services share the same port)
ports = {cfg["port"] for cfg in (default_cfg, user_cfg) if "port" in cfg}
if len(ports) < sum("port" in cfg for cfg in (default_cfg, user_cfg)):
raise RuntimeError("Port collision detected")
# 4. Compute the intersection of settings that both dictionaries agree on
agreed_settings = default_cfg.items() & user_cfg.items()
# agreed_settings => {('debug', False)} # only if values match exactly
These operations are O(n) in the size of the view and avoid the overhead of building temporary lists or dictionaries. They are especially handy when validating configuration files, checking API payloads against a schema, or reconciling data from multiple sources.
Conclusion
Python’s dictionary ecosystem offers a rich toolkit for everyday data manipulation:
- Comprehensions and generator expressions let you filter or transform entries with minimal memory footprint.
- Sorting leverages the guaranteed insertion order (since 3.7) to produce ordered views without extra copying.
- Union operators (
|,|=) provide a clean, readable way to layer defaults, overrides, and environment‑specific settings. - Safe in‑place updates can be achieved by iterating over snapshots or collecting changes for bulk removal.
- Set‑like view objects enable fast membership tests, set algebra, and schema validation directly on keys, values, or items.
By combining these patterns, you can write code that is both expressive and efficient—whether you’re handling tiny configuration dictionaries or massive datasets that demand lazy evaluation. Embracing these idioms will lead to cleaner, more maintainable Python programs Easy to understand, harder to ignore..
