Dictionaries: Advanced

Create fully independent dict copies

In the intermediate lesson, we saw that .copy() creates a shallow copy: the top-level dictionary is new, but nested objects are still shared. This can lead to subtle bugs when you modify what you think is a copy.

Python's copy module provides deepcopy(), which recursively copies all nested objects. After a deep copy, the original and copy are completely independent:

Preserve original state

Deep copy before modifying nested data so you can roll back if needed.

Protect from mutation

Pass a deep copy to functions that might change nested lists or dicts.

import copy
data = {"users": ["Alice", "Bob"]}
snapshot = copy.___(data)
snapshot["users"].append("Carol")
print(len({{data}}["users"]))

A practical rule of thumb: use assignment when you want shared state, .copy() when you want an independent top-level dict but shared nested objects, and deepcopy() when you need fully independent data at every level.

Deep copying is slower for large nested structures because it traverses and duplicates every object recursively. Profile before defaulting to deepcopy() on performance-critical paths.

When working with configuration objects or templates that get modified per-request, deepcopy() is the right tool. It ensures each caller receives an independent copy that they can customize without affecting others.

Eliminate missing-key boilerplate

Remember how we used .setdefault() or .get() to handle missing keys? The collections module provides defaultdict, which automatically creates missing keys with a default value. This eliminates the need for manual checking.

The argument to defaultdict is a "factory function" that gets called to create the default value. Common factories include list (for grouping), int (for counting), and set (for unique collections).

When you use int as the factory, missing keys automatically get the value 0 (since int() returns 0). This makes counting trivially simple:

Compare this to the manual approach with .get(). The defaultdict version is cleaner and less error-prone because you don't have to remember the initialization logic.

from collections import defaultdict
counts = defaultdict(___intliststr)
counts["a"] += 1
counts["b"] += 1
counts["a"] += 1
print(dict(counts))

defaultdict eliminates the most common boilerplate in Python data processing: the pattern of checking if a key exists before updating it. With the right factory, you can write grouping and counting code that is both shorter and more readable.

The factory function is called with no arguments every time a missing key is accessed. This means you can use any callable that returns your desired default - not just built-ins like int or list, but also lambda functions or custom classes.

When iterating over a defaultdict, convert it to a regular dict first with dict(d) to avoid accidentally creating empty entries for keys that were only checked but never set.

Rank items by frequency instantly

While defaultdict(int) works for counting, Python provides a specialized Counter class that's optimized for this exact use case. Counter has extra features that make counting tasks even easier.

Counter provides several useful methods that you'd have to implement yourself with a regular dictionary.

Get the N most frequent items with .most_common(), already sorted by count:

Counter shines in production because of its convenience methods and arithmetic support.

While modern regular dicts also maintain order, OrderedDict has a method that regular dicts lack: move_to_end().

The move_to_end() method moves a key to either end of the dictionary. This is useful for implementing LRU (Least Recently Used) caches:

Choose dicts over lists for speed

O(1) means the operation takes the same amount of time whether your dictionary has 10 items or 10 million items. This is incredibly powerful. A list would require O(n) time to find an item, meaning it gets slower as the list grows.

Solve two-sum and cache with dicts

One of the most famous interview problems is finding two numbers in a list that add up to a target. The optimal solution uses a dictionary to achieve O(n) time:

This pattern appears in many variations. The key insight is using the dictionary to "remember" what you've seen, turning a potential O(n²) nested loop into O(n).

Convert between dicts and JSON

import json
user = {"name": "Alice", "age": 28}
text = json.___(user)
back = json.___(text)
print(type(back))

JSON and Python dictionaries map almost perfectly to each other. JSON objects become Python dicts, JSON arrays become Python lists, JSON booleans become Python True/False, and JSON null becomes Python None.

One key difference: JSON keys must always be strings. When you use json.dumps() on a dict with integer keys, Python will convert them to strings automatically, which may change the structure when you parse the result back.

Use json.dumps(data, indent=2) to produce human-readable JSON with indentation. This is invaluable for debugging API responses and configuration files during development.

Avoid mutation and iteration traps

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

data = {"a": 1, "b": 5, "c": 2}
for key in data:
  if data[key] < 3:
    del data[key]
print(data)

Iterating over a copy of the keys with list(data.keys()) or list(data) is the safest pattern when you need to modify a dictionary during a loop. It is explicit, readable, and avoids the RuntimeError entirely.

Mutable default arguments are one of Python's most notorious gotchas. The rule is simple: never use a dict, list, or set as a default parameter value. Always use None and create the mutable object inside the function.

The two-sum pattern - using a dictionary to remember previously seen values - is one of the most broadly applicable interview algorithms. Any problem that asks "have I seen this complement before?" can be solved with a dictionary in O(n) instead of O(n²) with nested loops.