What is the common pitfall with Modifying Dictionary Keys During Iteration (RuntimeError)?

Modifying the internal hash table while iterating invalidates the iterator. Exam trap note: Exams frequently check if you know to iterate over `list(d.keys())` when deleting items in a loop.

What are the core concepts of Python Dictionaries?

Accessing a nonexistent key via bracket syntax `d[key]` raises a KeyError. The `.get(key, default)` method returns `None` (or your chosen fallback) if the key is not found, preventing crashes. The `setdefault(key, default)` method returns the value if present, or inserts and returns default if absent.

← Previous: Python Sets All Modules Next: Python If...Else & Branching →

MOD-12 · Sequence #12 · Python Collections

Python Dictionaries

Python dictionaries (dict) are associative arrays mapping unique keys to values. Since Python 3.7, dictionary keys maintain insertion order. They provide average O(1) key lookups, deletions, and insertions, and support dictionary comprehensions.

Live Interactive Code Snippet (Python 3.12 CPython WASM) Open in Practice Mode →

car = {"brand": "Ford", "model": "Mustang", "year": 1964}
print(car.get("color", "Red"))  # 'Red'

Core Principles & Mental Models

1. Dictionary Lookups and .get()

Avoiding KeyError with Defaults

Accessing a nonexistent key via bracket syntax `d[key]` raises a KeyError.
The `.get(key, default)` method returns `None` (or your chosen fallback) if the key is not found, preventing crashes.
The `setdefault(key, default)` method returns the value if present, or inserts and returns default if absent.

counts = {"apple": 5}
# print(counts["banana"]) -> Raises KeyError!
print("Banana count:", counts.get("banana", 0))

💡 Key Takeaway: Use `.get()` when a key might be missing and you have a sensible default.

2. Iterating Dictionaries and Comprehensions

.keys(), .values(), .items()

Iterating directly over a dict iterates over its keys: `for k in d:`.
Use `.items()` to iterate over key-value pairs simultaneously: `for k, v in d.items():`.
Dict comprehensions allow transforming mappings: `{k: v**2 for k, v in d.items()}`.

grades = {"Alice": 85, "Bob": 92, "Charlie": 78}
honors = {name: score for name, score in grades.items() if score >= 90}
print("Honors list:", honors)

💡 Key Takeaway: `.items()` returns a dynamic view of key-value pairs in insertion order.

Interactive Walkthrough Examples

Word Frequency Counter (Basic)

Building a word frequency map using .get() with fallback.

text = "python is fun and python is powerful"
words = text.split()
freq = {}
for w in words:
    freq[w] = freq.get(w, 0) + 1
for word, count in freq.items():
    print(f"'{word}': {count}")

Explanation: freq.get(w, 0) + 1 increments the existing count or starts at 0 + 1 for new keys.

Common Misconceptions & Exam Traps

Common Pitfall: Modifying Dictionary Keys During Iteration (RuntimeError)

Modifying the internal hash table while iterating invalidates the iterator.

Buggy Code

d = {"a": 1, "b": 2, "c": 3}
for k in d:
    if d[k] % 2 == 0:
        del d[k]  # RuntimeError: dictionary changed size during iteration!

Correct Solution

d = {"a": 1, "b": 2, "c": 3}
for k in list(d.keys()):  # Iterate over an independent list snapshot
    if d[k] % 2 == 0:
        del d[k]
print("Cleaned:", d)

Exam Trap Note: Exams frequently check if you know to iterate over `list(d.keys())` when deleting items in a loop.

Conceptual Knowledge Self-Check Quiz

Q1: What is returned by `d.get("missing", 42)` if the key "missing" is not in dictionary `d`?

KeyError exception
None
42
False

`.get(key, default)` returns the second argument (42 in this case) when the key does not exist.

Algorithmic Practice Challenges

Idiomatic Best Practices

✅ Use collections.defaultdict for counting or grouping items into lists.
✅ Remember that dictionary keys must be hashable (tuples are allowed; lists are not).

← Python Sets Take Assessed Test → Python If...Else & Branching →

All 26 Curriculum Modules

MOD-01: Python Syntax & Indentation — Whitespace blocks, execution statements, and semicolon absence in Python.
MOD-02: Python Comments — Single-line comments (#) and multiline docstrings.
MOD-03: Python Variables & Dynamic Binding — Variable creation, dynamic typing, unpacking, and multiple assignment.
MOD-04: Python Data Types — Built-in fundamental types: int, float, str, bool, list, tuple, dict, set, None.
MOD-05: Python Numbers & Type Casting — Int, float, complex numbers, and casting via int(), float(), str().
MOD-06: Python Strings & Slicing — String arrays, indexing [start:stop:step], negative indices, and string methods.
MOD-07: Python Booleans & Logical Evaluation — Boolean truth values, truthy vs falsy values, and logical operators.
MOD-08: Python Operators — Arithmetic, assignment, comparison, logical, identity (is), and membership (in).
MOD-09: Python Lists (Arrays) — Ordered, mutable sequences, indexing, append, insert, remove, pop, and list comprehensions.
MOD-10: Python Tuples — Ordered, immutable sequences, unpacking, and tuple hashing for dictionary keys.
MOD-11: Python Sets — Unordered, unindexed collections of unique elements; union, intersection, difference.
MOD-12: Python Dictionaries — Key-value associative mappings, keys(), values(), items(), and dict comprehensions.
MOD-13: Python If...Else & Branching — Conditional branching, elif ladder, nested conditions, and ternary conditional operators.
MOD-14: Python While Loops — Conditional loops, break, continue, and the while...else loop construct.
MOD-15: Python For Loops & Range — Sequence iteration, range(start, stop, step), enumerate(), and zip().
MOD-16: Python Functions & Parameters — def declarations, positional args, keyword args, *args, **kwargs, and return statements.
MOD-17: Python Lambda Functions — Anonymous inline functions, map(), filter(), and sorted(key=lambda).
MOD-18: Python Classes & Objects (OOP) — Class definition, the __init__ constructor, the self receiver, and instance methods.
MOD-19: Python Inheritance & Polymorphism — Subclassing, super() initializer, method overriding, and polymorphism.
MOD-20: Python Iterators & Generators — __iter__ and __next__ protocols, and generator functions with the yield keyword.
MOD-21: Python Scope & LEGB Rule — Local, Enclosing, Global, and Built-in namespaces; global and nonlocal keywords.
MOD-22: Python Modules & Packages — import, from ... import ..., as alias, dir() inspection, and __name__ == "__main__".
MOD-23: Python Dates & Math — datetime module (now, strftime, strptime) and math functions (pow, sqrt, ceil, floor).
MOD-24: Python JSON & Regular Expressions — json.loads(), json.dumps(), and the re module (search, findall, sub, split).
MOD-25: Python Try...Except & Error Handling — Exception catching with try, except, else, finally, and raising custom exceptions.
MOD-26: Python File Handling — File open modes ("r", "w", "a", "x"), with context manager, and os removal.