Python Dictionary Exercises: 40 Coding Problems with Solutions

Solution:

student = {"name": "Alice", "age": 20, "grade": "B"}

# Add a new key
student["city"] = "New York"

# Modify an existing key
student["age"] = 21

# Access a key
print(student)
print("Name:", student["name"])Code language: Python (python)

Explanation:

• student["city"] = "New York": Adds a new key-value pair to the dictionary. If the key does not exist, Python creates it automatically.
• student["age"] = 21: Overwrites the existing value associated with "age". Dictionary keys are unique, so assigning to an existing key updates it in place.
• student["name"]: Retrieves the value stored under the key "name". This is the standard bracket-access syntax and raises a KeyError if the key is absent.

Solution:

car = {"brand": "Toyota", "model": "Camry", "year": 2022, "color": "blue"}

# Remove a key
car.pop("color")
print(car)

# Get all key-value pairs
print(car.items())

# Check key existence
print("'brand' exists:", "brand" in car)
print("'color' exists:", "color" in car)Code language: Python (python)

Explanation:

• car.pop("color"): Removes the key "color" from the dictionary and returns its value. Unlike del, pop() can accept a default value to avoid a KeyError if the key is missing.
• car.items(): Returns a dynamic view object of all key-value pairs as tuples. It reflects any subsequent changes to the dictionary.
• "brand" in car: The in operator checks the dictionary’s keys (not values) and evaluates to True if the key is found, False otherwise.

Solution:

keys = ["name", "age", "city"]
values = ["Bob", 25, "London"]

result = dict(zip(keys, values))
print(result)Code language: Python (python)

Explanation:

• zip(keys, values): Pairs elements from both lists by their position, producing an iterator of tuples such as ("name", "Bob"), ("age", 25), and so on. It stops at the shorter list if lengths differ.
• dict(...): Converts the iterator of two-element tuples directly into a dictionary, treating the first element of each tuple as the key and the second as the value.
• Alternative: A dictionary comprehension {k: v for k, v in zip(keys, values)} achieves the same result and is preferred when you need to transform keys or values during construction.

Solution:

inventory = {"apples": 10, "bananas": 5, "oranges": 8}

inventory.clear()
print(inventory)Code language: Python (python)

Explanation:

• inventory.clear(): Removes every key-value pair from the dictionary in place. The variable inventory still exists and still points to a dictionary object — it is simply empty.
• Why not inventory = {}?: Reassigning to {} creates a brand-new dictionary and rebinds the variable, leaving any other references to the original object unaffected. clear() modifies the existing object, so all references see the empty state.

Solution:

dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}

# Method 1: update() — modifies dict1 in place
dict1.update(dict2)
print(dict1)

# Method 2: unpacking — creates a new dictionary
dict1 = {"a": 1, "b": 2}
merged = {**dict1, **dict2}
print(merged)

# Method 3: merge operator (Python 3.9+)
dict1 = {"a": 1, "b": 2}
merged = dict1 | dict2
print(merged)Code language: Python (python)

Explanation:

• dict1.update(dict2): Merges all key-value pairs from dict2 into dict1 in place. Where keys overlap, dict2‘s value wins. This method mutates dict1 directly.
• {**dict1, **dict2}: Unpacks both dictionaries into a new dictionary literal. Keys appearing in both are resolved left to right, so dict2 values take precedence. The originals remain unchanged.
• dict1 | dict2: The merge operator introduced in Python 3.9 produces a new merged dictionary with the same precedence rules as unpacking, offering a cleaner, more readable syntax.

Solution:

person = {"name": "Carol", "address": {"city": "Paris", "zip": "75001"}}

city = person["address"]["city"]
print("City:", city)Code language: Python (python)

Explanation:

• person["address"]: Accesses the value stored under "address", which is itself a dictionary: {"city": "Paris", "zip": "75001"}.
• person["address"]["city"]: Chains a second bracket access on the inner dictionary to retrieve "Paris". Each pair of brackets descends one level deeper into the nested structure.
• Safer alternative: person.get("address", {}).get("city") returns None instead of raising a KeyError if either "address" or "city" is absent, making it preferable for untrusted or incomplete data.

Solution:

student = {"name": "Dave", "grades": {"math": 88, "science": 92, "history": 75}}

history_grade = student["grades"]["history"]
print("History grade:", history_grade)Code language: Python (python)

Explanation:

• student["grades"]: Retrieves the nested dictionary {"math": 88, "science": 92, "history": 75} stored under the "grades" key.
• student["grades"]["history"]: Applies a second key lookup on the inner dictionary to extract the integer value 75. This chained syntax is the standard way to navigate nested dictionaries in Python.
• Practical note: In real applications such as JSON API responses or configuration files, nesting can go three or more levels deep. For such cases, consider using .get() at each level or a helper function to handle missing keys gracefully.

Solution:

keys = ["math", "science", "english", "history"]
default = 0

scores = dict.fromkeys(keys, default)
print(scores)Code language: Python (python)

Explanation:

• dict.fromkeys(keys, default): A class method that accepts an iterable of keys and an optional default value, returning a new dictionary where every key maps to that same value. If the second argument is omitted, all keys default to None.
• {k: default for k in keys}: A dictionary comprehension that achieves the same result. It is preferable when the default value needs to be computed or transformed per key rather than shared directly.
• Mutable default warning: Using dict.fromkeys(keys, []) assigns the same list object to every key. Modifying one key’s list modifies all of them. Use a comprehension — {k: [] for k in keys} — to give each key its own independent list.

Solution:

employee = {"fname": "John", "age": 30, "dept": "Engineering"}

employee["first_name"] = employee.pop("fname")
print(employee)Code language: Python (python)

Explanation:

• employee.pop("fname"): Removes the key "fname" from the dictionary and returns its value "John" in a single atomic operation, avoiding the need for a temporary variable.
• employee["first_name"] = ...: Assigns the returned value to the new key "first_name", effectively completing the rename. The rest of the dictionary is untouched.
• Insertion order note: In Python 3.7+, dictionaries preserve insertion order. The renamed key will appear at the end of the dictionary rather than in the original position of "fname". If order matters, rebuild the dictionary with a comprehension that substitutes the key inline.

Solution:

product = {"id": 101, "name": "Laptop", "price": 999, "stock": 50, "warehouse": "A3"}
keys_to_remove = ["stock", "warehouse"]

for key in keys_to_remove:
    product.pop(key, None)

print(product)Code language: Python (python)

Explanation:

• for key in keys_to_remove: Iterates over each key that should be deleted, allowing the same removal logic to be applied to any number of keys without repeating code.
• product.pop(key, None): Removes the key if it exists and silently returns None if it does not, preventing a KeyError crash when a key in the removal list is absent from the dictionary.
• Comprehension alternative: {k: v for k, v in product.items() if k not in keys_to_remove} produces a new filtered dictionary without mutating the original — preferable when you need to keep the original intact alongside the trimmed version.

Solution:

roles = {"alice": "admin", "bob": "editor", "carol": "viewer"}

print("'editor' exists as a value:", "editor" in roles.values())
print("'manager' exists as a value:", "manager" in roles.values())Code language: Python (python)

Explanation:

• roles.values(): Returns a dynamic view object containing all the values in the dictionary — in this case dict_values(['admin', 'editor', 'viewer']). The view reflects any subsequent changes to the dictionary.
• "editor" in roles.values(): The in operator performs a sequential scan through the values view and returns True as soon as a match is found, or False if the entire view is exhausted without a match.
• Key vs value search: "alice" in roles checks keys and runs in O(1) time thanks to hashing. "alice" in roles.values() checks values and runs in O(n) time. For frequent value lookups on large dictionaries, consider maintaining an inverse mapping.

Solution:

expenses = {"rent": 1200, "food": 300, "transport": 150, "utilities": 200}

total = sum(expenses.values())
print("Total expenses:", total)Code language: Python (python)

Explanation:

• expenses.values(): Returns a view of all the dictionary’s values — dict_values([1200, 300, 150, 200]) — without needing to extract them into a separate list first.
• sum(...): Python’s built-in sum() accepts any iterable of numbers, including a values view, and returns their cumulative total. It is the most concise and readable approach for this task.
• Loop alternative: A manual loop — total = 0; for v in expenses.values(): total += v — produces the same result and is useful when you need to apply a condition or transformation to each value before adding it to the running total.

Solution:

user = {"id": 42, "username": "jdoe", "email": "jdoe@example.com", "password": "s3cr3t", "joined": "2021-03-15"}
keys_to_keep = ["id", "username", "email"]

subset = {k: user[k] for k in keys_to_keep}
print(subset)Code language: Python (python)

Explanation:

• {k: user[k] for k in keys_to_keep}: A dictionary comprehension that iterates over keys_to_keep and retrieves each corresponding value from user. Only the specified keys appear in the resulting dictionary; all others are silently excluded.
• Original preserved: Because a new dictionary is constructed rather than modifying user in place, the original record — including sensitive fields like "password" — remains fully intact for use elsewhere in the program.
• Safe variant: Replace user[k] with user.get(k) to handle cases where a requested key may not exist in the source dictionary, returning None for missing keys rather than raising a KeyError.

Solution:

attributes = ["brand", "model", "year", "color"]
details = ["Honda", "Civic", 2023, "silver"]

car = dict(zip(attributes, details))
print(car)Code language: Python (python)

Explanation:

• zip(attributes, details): Lazily pairs elements from both lists by index, yielding tuples such as ("brand", "Honda") and ("year", 2023) one at a time. No intermediate list is created, making it memory-efficient for large inputs.
• dict(...): Consumes the zip iterator and constructs a dictionary by treating the first element of each tuple as the key and the second as the value — identical in result to Exercise 3, but applied here to a vehicle-attributes context to reinforce the pattern.
• CSV row example: When reading a CSV file, headers and row are both lists of strings. dict(zip(headers, row)) instantly converts a raw data row into a named-field dictionary — the same pattern used internally by Python’s csv.DictReader.

Solution:

text = "hello world"

freq = {}
for char in text:
    freq[char] = freq.get(char, 0) + 1

print(freq)Code language: Python (python)

Explanation:

• for char in text: Iterates over the string one character at a time, including spaces. Every character in the string — not just letters — is counted, so whitespace and punctuation are included unless explicitly filtered out.
• freq.get(char, 0) + 1: Retrieves the current count for char, falling back to 0 if the key does not yet exist, then adds 1. The result is written back, either creating the key on its first occurrence or incrementing an existing count.
• collections.Counter(text): A standard-library shortcut that produces the same frequency mapping in a single call. Counter is a subclass of dict, so it supports all the same operations plus extras like most_common(n) — preferable when further analysis of the counts is needed.

Solution:

company = {"name": "TechCorp", "location": {"city": "Berlin", "country": "Germany"}}

company["location"]["city"] = "Munich"
print(company)Code language: Python (python)

Explanation:

• company["location"]: Retrieves a reference to the inner dictionary object {"city": "Berlin", "country": "Germany"}. Because dictionaries are mutable, this is a live reference — not a copy — so any assignment through it modifies the original nested structure directly.
• company["location"]["city"] = "Munich": Navigates to the inner dictionary via the reference obtained above and overwrites the value of "city". The outer dictionary and the "country" key are both left untouched.
• In-place vs rebuild: This approach mutates the existing structure. If you need an updated copy while preserving the original, use copy.deepcopy(company) first, then modify the copy — a shallow copy would still share the inner dictionary object and lead to unexpected side effects.

Solution:

data = {"school": {"department": {"class": {"teacher": "Mr. Smith", "students": 30}}}}

data["school"]["department"]["class"]["students"] = 35
print(data)Code language: Python (python)

Explanation:

• data["school"]["department"]["class"]: Traverses three levels of nesting, each bracket lookup returning the next inner dictionary as a live mutable reference. No intermediate variables are needed because each result is immediately used to access the next level.
• ["students"] = 35: Performs the final assignment at the innermost dictionary, updating students from 30 to 35. All parent dictionaries remain unchanged because only the target key’s value is overwritten.
• Error handling tip: If any intermediate key might be absent, chaining raw bracket access raises a KeyError. For defensive traversal, use a helper that calls .get() at each level and returns a fallback, or use a library like glom which is designed specifically for safe deep access and update in nested structures.

Solution:

squares = {n: n ** 2 for n in range(1, 11)}
print(squares)Code language: Python (python)

Explanation:

• {n: n ** 2 for n in range(1, 11)}: A dictionary comprehension that iterates over integers 1 through 10, using each integer n as the key and its square n ** 2 as the corresponding value. The entire structure is built and returned as a single expression.
• n ** 2: The exponentiation operator raises n to the power of 2. It is equivalent to n * n but is more readable and idiomatic for powers in Python.
• Adding a filter: Appending an if clause — {n: n ** 2 for n in range(1, 11) if n % 2 == 0} — restricts the comprehension to even numbers only, demonstrating how comprehensions can combine generation and filtering in one concise expression.

Solution:

scores = {"Alice": 82, "Bob": 45, "Carol": 91, "Dave": 58, "Eve": 73}

passing = {k: v for k, v in scores.items() if v > 60}
print(passing)Code language: Python (python)

Explanation:

• scores.items(): Returns a view of all key-value pairs as tuples, enabling the comprehension to unpack each pair into k (the name) and v (the score) simultaneously on every iteration.
• if v > 60: Acts as a guard clause inside the comprehension — only pairs where the value exceeds 60 are included in the resulting dictionary. Pairs that fail the condition are silently skipped.
• Original preserved: The comprehension builds a brand-new dictionary, leaving scores completely unchanged. This non-destructive pattern is preferred over deleting keys from the original when both the full and filtered versions may be needed later.

Solution:

stock = {"apples": 34, "bananas": 12, "oranges": 57, "grapes": 8, "mangoes": 23}

lowest = min(stock, key=stock.get)
print("Lowest stock item:", lowest)Code language: Python (python)

Explanation:

• min(stock, ...): When a dictionary is passed to min() without a key argument it iterates over the keys. The key parameter tells min() what value to use for comparison instead of the raw iteration item.
• key=stock.get: Passes the bound method stock.get as the comparison function. For each key, min() calls stock.get(key) to obtain its numeric value and uses that for the minimum comparison — returning the key itself, not the value.
• Getting both key and value: min(stock.items(), key=lambda item: item[1]) returns the full tuple ('grapes', 8), which is convenient when you need both the name and the count in the same expression.

Solution:

scores = {"Alice": 88, "Bob": 95, "Carol": 72, "Dave": 95, "Eve": 84}

top = max(scores, key=scores.get)
print("Top scorer:", top)

# Bonus: retrieve all keys that share the maximum score
best_score = max(scores.values())
all_top = [k for k, v in scores.items() if v == best_score]
print("All top scorers:", all_top)Code language: Python (python)

Explanation:

• max(scores, key=scores.get): Mirrors the min() pattern from Exercise 20 — iterates over the dictionary’s keys and uses scores.get to retrieve each key’s value for comparison, returning the key whose value is the largest. When a tie exists, the first key encountered in insertion order is returned.
• max(scores.values()): Computes the highest score as a standalone number. Storing it in best_score avoids recalculating the maximum on every iteration of the list comprehension, keeping the tie-finding logic efficient.
• [k for k, v in scores.items() if v == best_score]: Collects every key whose value matches the maximum, handling ties correctly. In this example both "Bob" and "Dave" scored 95, so the bonus output is ['Bob', 'Dave'] — a result that max() alone cannot provide.

Solution:

pairs = [("name", "Alice"), ("age", 25), ("city", "Paris")]

result = dict(pairs)

print(result)Code language: Python (python)

Explanation:

• dict(pairs): The built-in dict() constructor accepts an iterable of two-item iterables (such as tuples) and maps the first element of each tuple to a key and the second to its value.
• No loop needed: Because dict() handles the iteration internally, you get a clean one-liner without writing an explicit for loop.
• Duplicate keys: If two tuples share the same first element, the last one wins, as dictionary keys must be unique.

Solution:

d1 = {"a": 1, "b": 2, "c": 3}
d2 = {"b": 20, "c": 30, "d": 40}

common_keys = d1.keys() & d2.keys()

print("Common keys:", common_keys)Code language: Python (python)

Explanation:

• d1.keys(): Returns a dict_keys view, which behaves like a set and supports operations such as union, intersection, and difference.
• & operator: Applies set intersection to the two key views, producing only the keys found in both dictionaries.
• Order not guaranteed: The result is a set, so the displayed order of keys may vary between runs.

Solution:

d1 = {"a": 1, "b": 2, "c": 3}
d2 = {"b": 20, "d": 40}

only_in_d1 = d1.keys() - d2.keys()

print("Keys only in d1:", only_in_d1)Code language: Python (python)

Explanation:

• d1.keys() - d2.keys(): Applies set difference, returning a new set of keys that appear in d1 but not in d2.
• Asymmetric operation: The order of operands matters. d1.keys() - d2.keys() and d2.keys() - d1.keys() produce different results.
• Alternative: You can also write d1.keys().difference(d2.keys()) for the same effect using the explicit method form.

Solution:

d1 = {"a": 1, "b": 2, "c": 3}
d2 = {"a": 1, "b": 99, "c": 3}

intersection = {k: d1[k] for k in d1.keys() & d2.keys() if d1[k] == d2[k]}

print("Intersection:", intersection)Code language: Python (python)

Explanation:

• d1.keys() & d2.keys(): Produces the set of keys shared by both dictionaries, so the comprehension only examines relevant keys.
• if d1[k] == d2[k]: The filter condition ensures that only pairs where both dictionaries hold the exact same value are included in the result.
• Dictionary comprehension: The {k: d1[k] for k in ...} syntax builds the new dictionary in a single readable expression without an explicit loop.

Solution:

text = "the cat sat on the mat the cat"

word_count = {}
for word in text.lower().split():
    word_count[word] = word_count.get(word, 0) + 1

print(word_count)Code language: Python (python)

Explanation:

• text.lower(): Converts the entire string to lowercase before processing, ensuring “The” and “the” are treated as the same token.
• .split(): Splits on any whitespace and discards extra spaces, producing a clean list of words.
• word_count.get(word, 0) + 1: Retrieves the current count for a word, defaulting to 0 if the word has not been seen yet, then increments it by one.
• Alternative: from collections import Counter; word_count = Counter(text.lower().split()) achieves the same result in a single line.

Solution:

data = {"name": "Alice", "age": None, "city": "Paris", "score": None}

cleaned = {k: v for k, v in data.items() if v is not None}

print(cleaned)Code language: Python (python)

Explanation:

• data.items(): Returns each key-value pair as a tuple, allowing the comprehension to unpack both k and v in a single expression.
• if v is not None: Uses identity comparison rather than equality, which is the recommended way to test for None in Python and avoids unexpected behaviour with objects that override __eq__.
• Non-destructive: The comprehension produces a new dictionary called cleaned, leaving the original data unchanged. If you need in-place removal, you can reassign: data = cleaned.

Solution:

data = {"banana": 3, "apple": 5, "cherry": 1, "date": 4}

sorted_data = dict(sorted(data.items()))

print(sorted_data)Code language: Python (python)

Explanation:

• data.items(): Produces a view of (key, value) tuples that can be passed directly to sorted().
• sorted(...): Sorts the tuples in ascending order by their first element (the key) using Python’s default lexicographic comparison for strings.
• dict(...): Converts the sorted list of tuples back into a dictionary. Since Python 3.7, dictionaries maintain insertion order, so the result preserves the sorted sequence.
• Descending order: To sort in reverse, pass reverse=True to sorted(): dict(sorted(data.items(), reverse=True)).

Solution:

scores = {"Alice": 88, "Bob": 72, "Charlie": 95, "Diana": 60}

sorted_scores = dict(sorted(scores.items(), key=lambda item: item[1]))

print(sorted_scores)Code language: Python (python)

Explanation:

• scores.items(): Returns all key-value pairs as a view of tuples, e.g., [("Alice", 88), ...].
• key=lambda item: item[1]: Tells sorted() to compare items by their second element (the value), not the key.
• dict(...): Converts the sorted list of tuples back into a regular dictionary. Python 3.7+ preserves insertion order, so the result stays sorted.
• Alternative: To sort in descending order, add reverse=True inside sorted().

Solution:

data = {"a": 1, "b": 2, "c": 3, "d": 2}

values = list(data.values())
is_unique = len(values) == len(set(values))

print(is_unique)Code language: Python (python)

Explanation:

• data.values(): Returns a view of all values in the dictionary, here [1, 2, 3, 2].
• set(values): Creates a set from the values, eliminating any duplicates. Here it becomes {1, 2, 3}.
• len(values) == len(set(values)): If both lengths are equal, no duplicates exist. Since 4 does not equal 3, the result is False.
• Alternative: You can write this as a one-liner: is_unique = len(data) == len(set(data.values())).

Solution:

main = {"a": 1, "b": 2, "c": 3, "d": 4}
subset = {"a": 1, "c": 3}
is_subset = subset.items() <= main.items()
print(is_subset)Code language: Python (python)

Explanation:

• subset.items(): Returns a view of the key-value pairs of the smaller dictionary as a set-like object: {("a", 1), ("c", 3)}.
• main.items(): Returns a similar view for the larger dictionary. Dictionary item views support set operations directly.
• <= operator: When used on dict item views, it checks whether every pair in subset.items() also exists in main.items(), returning True or False.
• Alternative: subset.items().issubset(main.items()) produces the same result and may read more clearly in some codebases.

Solution:

words = {"a": "banana", "b": "kiwi", "c": "strawberry", "d": "fig"}

sorted_words = dict(sorted(words.items(), key=lambda item: len(item[1])))

print(sorted_words)Code language: Python (python)

Explanation:

• words.items(): Produces pairs like [("a", "banana"), ("b", "kiwi"), ...] that sorted() can iterate over.
• lambda item: len(item[1]): For each pair, extracts the value (item[1]) and returns its character count. sorted() uses this count as the sort key.
• dict(...): Reconstructs the dictionary from the now-ordered list of tuples. The insertion order is maintained in Python 3.7+.
• Note: If two values share the same length, their relative order depends on their original position in the dictionary (stable sort behavior).

Solution:

data = {"fruits": ["apple", "banana", "cherry"], "vegs": ["carrot"], "grains": ["rice", "wheat"]}

longest_key = max(data.items(), key=lambda item: len(item[1]))[0]

print(longest_key)Code language: Python (python)

Explanation:

• data.items(): Provides all key-value pairs. Each value here is a list, e.g., ("fruits", ["apple", "banana", "cherry"]).
• key=lambda item: len(item[1]): Instructs max() to compare items by the length of their list values rather than by the keys themselves.
• [0]: max() returns the winning tuple, e.g., ("fruits", [...]). Indexing with [0] pulls out just the key name.
• Note: If two keys have lists of equal maximum length, max() returns whichever appears first during iteration.

Solution:

import json

person = {"name": "Alice", "age": 30, "address": {"city": "Mumbai", "pin": "400001"}}

json_string = json.dumps(person, indent=4)

print(json_string)Code language: Python (python)

Explanation:

• import json: Loads Python’s standard library module for JSON encoding and decoding – no installation needed.
• json.dumps(person, indent=4): Serializes the dictionary to a JSON-formatted string. The indent=4 argument adds 4-space indentation at each nesting level for human-readable output.
• Nested structure: The address key holds another dictionary. json.dumps() handles nested structures recursively, so no extra steps are needed.
• Alternative: Use json.dump(person, file_object, indent=4) to write the JSON directly to a file instead of returning a string.

Solution:

original = {"a": 1, "b": 2, "c": 3}

inverted = {v: k for k, v in original.items()}

print(inverted)Code language: Python (python)

Explanation:

• original.items(): Returns each key-value pair as a tuple, e.g., ("a", 1), which is unpacked into k and v in the comprehension.
• {v: k for k, v in ...}: Builds a new dictionary where each original value v becomes a key and each original key k becomes the value – a clean one-line inversion.
• Key constraint: Dictionary keys must be unique and hashable. If two keys in original share the same value, only the last one survives in the inverted dictionary.
• Alternative: Use dict(zip(original.values(), original.keys())) for an equivalent result without a comprehension.

Solution:

original = {"a": 1, "b": 2, "c": 1, "d": 3, "e": 2}

inverted = {}
for k, v in original.items():
    inverted.setdefault(v, []).append(k)

print(inverted)Code language: Python (python)

Explanation:

• original.items(): Yields each key-value pair in turn, e.g., ("a", 1), ("b", 2), ("c", 1), and so on.
• inverted.setdefault(v, []): Checks if v already exists as a key in inverted. If not, it inserts it with an empty list as the default value and returns that list either way.
• .append(k): Adds the original key to the list associated with that value, so all keys sharing the same value are collected together.
• Alternative: Use collections.defaultdict(list) and replace setdefault with a direct inverted[v].append(k) for slightly cleaner syntax.

Solution:

nested = {"a": 1, "b": {"c": 2, "d": {"e": 3, "f": 4}}}

def flatten(d, prefix=""):
    result = {}
    for k, v in d.items():
        new_key = f"{prefix}.{k}" if prefix else k
        if isinstance(v, dict):
            result.update(flatten(v, new_key))
        else:
            result[new_key] = v
    return result

print(flatten(nested))Code language: Python (python)

Explanation:

• prefix="": The default empty string means top-level keys get no dot prepended. As recursion deepens, the prefix carries the accumulated path of parent keys.
• new_key = f"{prefix}.{k}" if prefix else k: Builds the dotted path for the current key. At the top level it is just k; at deeper levels it becomes something like b.d.
• isinstance(v, dict): Checks whether the current value is another dictionary. If so, the function calls itself with the nested dict and the updated prefix, then merges the results with result.update().
• Base case: When the value is not a dictionary, it is a leaf node and gets stored directly under its fully qualified key.

Solution:

words = ["apple", "avocado", "banana", "blueberry", "cherry", "apricot"]

grouped = {}
for word in words:
    letter = word[0]
    grouped.setdefault(letter, []).append(word)

print(grouped)Code language: Python (python)

Explanation:

• word[0]: Extracts the first character of each word, which serves as the grouping key. For "apple" this yields "a", for "banana" it yields "b", and so on.
• grouped.setdefault(letter, []): Returns the existing list for that letter if it already exists, or inserts a fresh empty list and returns it if the letter is seen for the first time.
• .append(word): Adds the current word to the correct group. Because setdefault returns the list in place, the append operates directly on the stored list.
• Alternative: collections.defaultdict(list) removes the need for setdefault: just write grouped[letter].append(word) directly.

Solution:

dict1 = {"a": 10, "b": 20, "c": 30}
dict2 = {"b": 5, "c": 15, "d": 25}

merged = dict1.copy()
for k, v in dict2.items():
    merged[k] = merged.get(k, 0) + v

print(merged)Code language: Python (python)

Explanation:

• dict1.copy(): Creates a shallow copy of dict1 as the starting point so the original dictionary is not modified during the merge.
• merged.get(k, 0): Retrieves the current value for key k from merged, defaulting to 0 if the key is not yet present. This makes the addition safe for both overlapping and new keys.
• merged[k] = ... + v: Stores the summed result back. For shared keys like "b", this gives 20 + 5 = 25. For new keys like "d", it gives 0 + 25 = 25.
• Alternative: collections.Counter supports addition directly: Counter(dict1) + Counter(dict2) produces the same result in one line.

Solution:

import copy

original = {"name": "Alice", "scores": [90, 85, 92]}

# Shallow copy
shallow = original.copy()
shallow["scores"].append(100)
print("Shallow copy scores:", shallow["scores"])
print("Original scores after shallow mutation:", original["scores"])

print()

# Restore original for a clean deep copy demo
original = {"name": "Alice", "scores": [90, 85, 92, 100]}

# Deep copy
deep = copy.deepcopy(original)
deep["scores"].append(99)
print("Deep copy scores:", deep["scores"])
print("Original scores after deep mutation:", original["scores"])Code language: Python (python)

Explanation:

• original.copy(): Creates a new dictionary with the same top-level keys, but the values are not duplicated. The scores list in the shallow copy is the exact same list object in memory as the one in original.
• Shallow mutation effect: Appending 100 to shallow["scores"] modifies the shared list, so original["scores"] reflects the same change. This is the key risk of shallow copies with mutable nested values.
• copy.deepcopy(original): Recursively duplicates every object at every level. The scores list in deep is a brand-new list with no connection to the original.
• Deep mutation effect: Appending 99 to deep["scores"] has no impact on original["scores"], confirming full independence between the two copies.