Question 1

Unhashable key type

Accepted Answer

Dictionary keys must be hashable - they must have a __hash__ method that returns a consistent integer. Lists are mutable and therefore unhashable; trying to use one as a key raises TypeError. If you need a list-like key, convert it to a tuple first: {(1, 2): 'value'} - tuples are immutable and hashable.

Question 2

Missing key: [] vs .get()

Accepted Answer

dict.get(key, default) returns the value if the key exists, otherwise the default. 'b' is missing so get returns the explicit default 0. 'a' exists with value 1, so the default 99 is ignored. Using d['b'] directly would raise a KeyError - .get() is the safe alternative when a missing key is expected.

Question 3

Merging dicts with update()

Accepted Answer

dict.update() merges another dict (or iterable of key-value pairs) into the target in place. Existing keys are overwritten with values from the argument, so 'y' becomes 99. New keys like 'z' are added. For a non-mutating merge you can use the | operator in Python 3.9+: merged = a | b.

Question 4

Dict comprehension

Accepted Answer

The dict comprehension builds {1: 1, 2: 4, 3: 9, 4: 16}. Accessing squares[3] returns 3 ** 2 = 9. Dict comprehensions use the form {key_expr: value_expr for var in iterable} and are the idiomatic way to build dicts from data.

Question 5

dict.pop() vs del d[key]

Accepted Answer

d.pop(key) removes key and returns its value. You can also pass a default: d.pop(key, None) avoids KeyError if the key is absent. del d[key] deletes the key-value pair but returns nothing, and raises KeyError if the key doesn't exist. Use pop() when you need the old value or want safe deletion; use del when you just want to remove without caring about the value.

Question 6

collections.defaultdict purpose

Accepted Answer

defaultdict takes a callable (the 'default factory') and calls it to produce a value whenever a missing key is accessed. For example, defaultdict(list) auto-creates an empty list for new keys, enabling patterns like d[key].append(value) without an explicit check. It does not sort keys, relax hashability requirements, or limit size.

Question 7

Iterating over a dict

Accepted Answer

Iterating over a dict directly yields its keys, not its values or key-value pairs. To iterate over values use d.values(), and to get key-value pairs use d.items() which yields tuples. The most common loop pattern is: 'for k, v in d.items(): ...'

Question 8

Dictionary key ordering (Python 3.7+)

Accepted Answer

Since Python 3.7, dictionaries preserve insertion order as a language guarantee. 'c' was inserted first, then 'a', then 'b', so iterating the keys gives that same order. If you need alphabetical order you still need sorted(d.keys()) - insertion order and sort order are two different things.

Question 9

get() with no default

Accepted Answer

When you call get() with only the key and the key doesn't exist, the default is None - not a KeyError. This is the key difference from bracket access: d['y'] would raise KeyError, but d.get('y') silently returns None. You'll often see 'if d.get(key):' as a safe existence check, though 'key in d' is more explicit.

Question 10

Updating a key preserves its position

Accepted Answer

Updating an existing key's value does not change its insertion position. 'a' was the first key inserted, and reassigning d['a'] = 99 keeps it first. Only deleting and re-inserting a key moves it to the end. This behavior is part of the insertion-order guarantee added in Python 3.7.

Question 11

Dict merge with | operator (Python 3.9+)

Accepted Answer

The | operator (Python 3.9+) merges two dicts and returns a new dict, leaving both originals unchanged. Right-side values win for conflicting keys, so 'y' is 99 in the result. 'a' is untouched. Compare this with a.update(b), which modifies 'a' in place and returns None.

Question 12

defaultdict(int) for counting

Accepted Answer

defaultdict(int) uses int as the factory, so accessing a missing key creates it with 0 (the result of int()). On the first occurrence of 'a', counts['a'] is auto-initialized to 0, then += 1 makes it 1. The second 'a' increments it to 2. This pattern replaces the more verbose 'counts[ch] = counts.get(ch, 0) + 1'.

Question 13

pop() with a default on missing key

Accepted Answer

d.pop(key, default) returns the default when the key is absent, instead of raising KeyError. 'c' isn't in the dict, so val gets -1. The dict itself is unchanged - pop doesn't add the key when it's missing. This makes pop(key, default) a clean 'remove if present, otherwise ignore' operation.

Question 14

Dict comprehension with filter

Accepted Answer

Dict comprehensions support an if clause, just like list comprehensions. Here we iterate over key-value pairs with d.items() and keep only the pairs where the value is even. 'b': 2 and 'd': 4 pass the filter; 'a': 1 and 'c': 3 do not.

Question 15

Iterating with .items()

Accepted Answer

d.items() yields (key, value) tuples in insertion order. Unpacking each tuple into k and v gives you both in one step. This is the most common way to loop over a dict when you need both the key and the value. Without tuple unpacking you'd write 'for item in d.items(): print(item[0], item[1])' - much less readable.