📊 Day 07 : Dictionaries

🎯 Enterprise Objective

Dictionaries are the most critical data structure in modern programming. They map keys to values with lightning-fast O(1) lookups and are the exact equivalent of JSON objects. Today we master dictionary manipulation, safe extraction, functional comprehensions, and deep nested hierarchies. Mastery of dictionaries is non-negotiable for working with APIs and DataFrames.

📋 Strategic Overview

A dictionary is a mutable, unordered collection of key-value pairs. It is Python's most powerful data structure, serving as the foundation for JSON parsing, DataFrames, and fast lookups. Keys must be hashable (strings, numbers, tuples), while values can be anything.

• JSON Data: Dictionaries are the Python equivalent of JSON objects

• Fast Lookups: Looking up a value by its key is an O(1) operation

• Data Modeling: Representing real-world entities (e.g., a user profile)

You cannot use a list or dictionary as a dictionary key because they are unhashable (mutable). You will get a TypeError: unhashable type: 'list'. Use tuples instead.

Since Python 3.7, dictionaries maintain insertion order. But never rely on this for logic; if order matters explicitly, document it or use collections.OrderedDict for backward compatibility.

You can access values using dict[key], but if the key doesn't exist, it raises a KeyError. To safely access data, use the .get(key, default) method. To add or modify, simply assign dict[key] = value.

• API Parsing: APIs often have missing fields. Use .get() to avoid crashing your pipeline

• Counter Patterns: d[key] = d.get(key, 0) + 1 is the standard way to count frequencies

• Configuration Defaults: port = config.get('port', 80) applies safe default values

Dictionaries provide dynamic view objects through three methods: .keys(), .values(), and .items(). These views update automatically when the dictionary changes and are fast and memory-efficient.

• Column Checks: Check if expected columns exist in a data record using .keys()

• Data Extraction: Extract all metric values for analysis using .values()

• Transformation: Iterate over .items() to apply a function to all values

Views don't support indexing. d.keys()[0] raises a TypeError. If you need a list, explicitly convert it: list(d.keys()).

Iterating directly over a dictionary loops over its keys. To loop over both keys and values, use .items(). This is the most common and Pythonic way to process dictionary data.

# ❌ Bad: Looping keys to get values
for k in d:
    v = d[k]  # Inefficient lookup

# ✅ Good: Unpacking items directly
for k, v in d.items():
    print(k, v)

• Formatting Output: Printing structured reports of metrics or configuration

• Data Cleaning: Iterating over items to clean strings or convert types

• Filtering: Looping to build a new dictionary with specific key-value pairs

You cannot add or remove keys from a dictionary while iterating over it. It will raise a RuntimeError: dictionary changed size during iteration. If you must modify keys, iterate over a copy or build a new dictionary.

Just like list comprehensions, dictionary comprehensions provide a concise way to create dictionaries from iterables. The syntax is {key: value for item in iterable if condition}.

# Square numbers mapping
squares = {x: x**2 for x in range(5)}
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

• Data Transformation: Convert a list of records into a dictionary keyed by ID for fast lookups

• Filtering Dictionaries: {k: v for k, v in data.items() if v > 0} — clean negative values

• Key Mapping: Mapping original column names to new clean column names

A very common pattern for fast lookups: lookup = {row['id']: row for row in dataset}. This converts an O(n) search into an O(1) dictionary lookup.

Python provides multiple ways to combine dictionaries. dict.update() modifies in-place. Python 3.9+ introduced the merge operator | which creates a new dictionary.

• Configuration Management: Merge default_config with user_config (user overrides default)

• Aggregating Data: Combining parsed JSON objects from multiple API endpoints

When merging, if the same key exists in both dictionaries, the value from the dictionary on the right side (or passed to .update()) wins.

A dictionary can contain other dictionaries (or lists, sets, etc.) as values. This is essential for working with hierarchical data like JSON or NoSQL document databases.

users = {
    'u1': {'name': 'Alice', 'role': 'Admin'},
    'u2': {'name': 'Bob', 'role': 'User'}
}
# Access nested data
alice_role = users['u1']['role']

• API Parsing: Traversing complex JSON responses from web services

• Document Storage: Representing MongoDB documents in memory

• Configuration Trees: Hierarchical settings (e.g., config['database']['host'])

Accessing data['user']['address']['zip'] will crash if any key in the chain is missing. Use chained .get() or handle exceptions.

Theory is useless without muscle memory. Complete these tasks to solidify your understanding.

✅ Instructor's End-of-Day Checklist

• [ ] I understand why dictionary keys must be immutable (hashable).

• [ ] I know to use .get() to safely extract data without crashing.

• [ ] I can iterate efficiently using .items().

• [ ] I can create dictionaries quickly using dictionary comprehensions.

• [ ] I know how to merge two dictionaries using the | operator or .update().

• [ ] I understand how to navigate nested dictionaries (JSON objects).

• [ ] I have completed all 5 practice tasks.

• [ ] I have reviewed all 25 interview questions.