Dictionaries: Intermediate

Loop through keys, values, or both

You can also explicitly use the .keys() method, which does exactly the same thing but makes your intent clearer:

When you only need the values and don't care about the keys, use .values(). This is useful for calculations or aggregations:

Often you need both the key and the value together. The .items() method returns pairs, which you can unpack directly in the for loop. This is one of the most useful dictionary patterns:

The syntax for key, value in dict.items() is called tuple unpacking. Each item from .items() is a pair (technically a tuple), and Python automatically splits it into two variables. You can name these variables anything, but key/value or k/v are conventional.

prices = {
    "apple": 1.50,
    "banana": 0.75,
    "orange": 2.00
}
total = 0
for price in prices.___():
    total = total + price
names = list(prices.___())
print("Total:", total)
print("Items:", names)

Choosing the right iteration method is about being explicit in your intent. .keys() signals "I only care about names," .values() signals "I only care about the data," and .items() signals "I need both together."

The .items() method is the most versatile and is what you will reach for most often in data transformation code. It lets you reference both the key and value by readable names rather than indexing into a tuple.

Use views, update, and setdefault

When you call .keys(), .values(), or .items(), Python doesn't create a list. Instead, it returns a special "view" object. Views are lightweight and always reflect the current state of the dictionary.

Notice that we didn't call .keys() again, but the view automatically includes the new "city" key. This is different from lists, where you'd need to recreate the list to see changes.

Sometimes you need an actual list of keys or values (for example, to sort them or access by index). Use the list() function to convert a view:

The .update() method adds or updates multiple key-value pairs at once. You can pass it another dictionary, and all its entries will be merged into the original:

If a key already exists, .update() overwrites it with the new value. This makes it useful for applying changes or defaults:

The .setdefault() method is a combination of "check if key exists" and "add it if it doesn't." It returns the value for a key, but if the key doesn't exist, it first sets it to a default value:

This is particularly useful when building up dictionary data incrementally. A common pattern is using .setdefault() to initialize lists or counters:

Combine dicts with overrides intact

As we just saw, .update() merges a dictionary into an existing one. This modifies the original dictionary:

The |= operator is like .update() but uses the new merge syntax. It modifies the left dictionary in place:

defaults = {
    "theme": "light",
    "volume": 50
}
user_prefs = {
    "volume": 80, "lang": "en"
}
combined = defaults.___()
combined.___(user_prefs)
print(combined)

Merge order matters when both dictionaries have the same key. The rightmost value always wins. Design your merge calls so that the higher-priority dictionary is on the right side of | or passed as the argument to .update().

Navigate multi-level data safely

Accessing deeply nested data can fail if any intermediate key is missing. The safe approach is to check each level or use .get() with defaults:

data = {"user": {"name": "Alice"}}
result = ___data.get("user", {}).get("age", 0)data["user"]["age"]data.get("age", 0)
print(result)

The try/except approach is an alternative to chained .get() for complex nested access. Wrap the access in a try block catching KeyError, which lets you write the direct bracket path and handle all missing-key cases in one except clause.

Group multiple items under one key

A frequent task is grouping items into lists based on some criterion. The .setdefault() method we learned earlier is perfect for this:

Lists as values

Group multiple items under one key, like tags or roles for a user.

Dicts as values

Nest dictionaries for hierarchical data like addresses or profiles.

.setdefault() grouping

Initialize a list on first access, then append items incrementally.

Clone dicts without shared mutations

The .copy() method creates a new dictionary with the same key-value pairs. Changes to the copy don't affect the original:

However, .copy() only creates a shallow copy. If your dictionary contains mutable values (like lists or nested dictionaries), those inner objects are NOT copied:

data = {"x": 10, "y": 20}
snapshot = data.___()
data.___({"z": 30})
print(len(data))
print(len(snapshot))

Build filtered dicts in one line

The pattern is {key_expression: value_expression for item in iterable}. This is a concise way to transform data into dictionary form:

words = ["hello", "world", "python"]
result = ___{w: len(w) for w in words}{len(w): w for w in words}{w: w.upper() for w in words}
print(result)

Invert, count, and group with dicts

The expression dict.get(key, 0) + 1 returns the current count (or 0 if missing) and adds 1. This is a classic Python idiom for counting.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

counts = {}
for ch in "hello":
  counts[ch] = counts[ch] + 1
print(counts)

The grouping pattern collects items into lists under a shared key. Use setdefault or a defaultdict to accumulate values without checking for key existence first.