Python Dictionaries Exercises

Let’s carefully understand the basics of Python dictionaries:

• Dictionaries are unordered collections (in Python 3.7+, they preserve insertion order, but not sorted order).
• Keys in a dictionary must be unique. If a duplicate key is added, the latest value overwrites the old one.
• Keys must be immutable types such as strings, numbers, or tuples. Mutable types like lists are not allowed.
• Correct Option: 4 → Dictionaries are mutable (can be changed after creation) and store key-value pairs with unique keys.

Key takeaway: Think of a dictionary like a real-life dictionary – every word (key) must be unique, and each word has exactly one meaning (value).

In Python, dictionaries store data as key-value pairs. To access values, you use the key inside square brackets or the get() method.

• Option 1:  Invalid. Dictionaries don’t allow dot notation like objects in JavaScript. Use square brackets instead.
• Option 2:  Wrong, because "25" is not a key; it’s a value. You must use keys, not values, to access data.
• Option 3:  Correct. person["age"] will return 25.
• Option 4:  Invalid. The correct method is person.get("age"), not get_key().

Correct Option: 3

Tip: When unsure whether a key exists, prefer using dict.get(key, default) to avoid errors.

Let’s analyze step by step:

• Initially, student = {"name": "Sara", "age": 20}.
• Then student["age"] = 21 updates the value of "age" to 21.
• Next, student["grade"] = "A" adds a new key-value pair.

So, the final dictionary is:

{"name": "Sara", "age": 21, "grade": "A"}

Correct Option: 3

Key takeaway: Dictionaries allow updating existing keys and adding new ones dynamically.

Understanding the operations step by step:

• The initial dictionary is {"id": 101, "name": "Rafiq", "salary": 50000}.
• employee.pop("salary") removes the key "salary" and its value.
• After this, the dictionary becomes {"id": 101, "name": "Rafiq"}.
• Then employee["department"] = "HR" adds a new key-value pair.

• Option 1 – Incorrect: Still shows "salary" which was removed.
• Option 2 – Incorrect: Missing the "department" key added later.
• Option 3 – Correct: {"id": 101, "name": "Rafiq", "department": "HR"}.
• Option 4 – Incorrect: Omits the "id" key.

Example output:

{"id": 101, "name": "Rafiq", "department": "HR"}

Step-by-step reasoning:

1. Start: {"id": 101, "name": "Rafiq", "salary": 50000}
2. After pop: {"id": 101, "name": "Rafiq"}
3. After adding department: {"id": 101, "name": "Rafiq", "department": "HR"}

Key takeaways:

• pop(key) removes a key and returns its value.
• You can add new key-value pairs by direct assignment.
• Dictionaries are mutable, so changes happen in place.

Checking for key existence in a dictionary

• Option 1 – Correct: "city" in person checks whether the key exists and returns True or False.
• Option 2 – Incorrect: has_key() was removed in Python 3.
• Option 3 – Incorrect: contains() is not a valid dictionary method in Python.
• Option 4 – Incorrect: "city" in person.values() checks values, not keys.

Example:

person = {"name": "Nadia", "age": 30, "city": "Chittagong"}
print("city" in person)  # Output: True

Step-by-step reasoning:

1. Look at the dictionary keys: "name", "age", "city".
2. Check if "city" is present among keys → True.

Key takeaways:

• Use key in dict to safely check if a key exists.
• Do not confuse keys and values when checking existence.
• Remember that has_key() is only in Python 2, not Python 3.

Understanding the get() method:

• Option 1 – Incorrect: get() does not raise a KeyError if the key is missing. That’s the difference from accessing with square brackets.
• Option 2 – Correct: get(key, default) returns the value for the key if it exists; otherwise, it returns the default value (or None if default is not provided).
• Option 3 – Incorrect: get() works with any hashable key type, not just strings.
• Option 4 – Incorrect: get() does not remove the key from the dictionary.

Example:

person = {"name": "Rina", "age": 28}
print(person.get("age"))        # Output: 28
print(person.get("city", "NA")) # Output: NA

Step-by-step reasoning:

1. Check if key "age" exists → Yes → returns 28.
2. Check if key "city" exists → No → returns default "NA".

Key takeaways:

• Use get() to safely access keys without raising errors.
• You can provide a default value to handle missing keys gracefully.
• This is especially useful when working with dynamic or user-generated data.

Understanding dictionary comprehension and filtering

• Step 1 – frequency = {num: numbers.count(num) for num in numbers} This creates a dictionary where each number in the list is a key and its value is the count of occurrences.
• Step 2 – filtered = {k: v for k, v in frequency.items() if v > 1} This filters the dictionary to include only numbers that appear more than once.

• Option 1 – Incorrect: Shows all counts as 1, which is not true.
• Option 2 – Incorrect: Count for 1 is correct (2 in filtered), 4 and 5 should be excluded.
• Option 3 – Incorrect: Counts for 4 and 5 are wrong (should be excluded).
• Option 4 – Correct: Only numbers appearing more than once are included → {1: 2, 2: 2, 3: 2}

Example output:

{1: 2, 2: 2, 3: 2}

Step-by-step reasoning:

1. Count occurrences: {1: 2, 2: 2, 3: 2, 4: 1, 5: 1}
2. Filter by v > 1 → {1: 2, 2: 2, 3: 2}

Key takeaways:

• Use dictionary comprehension for quick transformations.
• Filtering dictionaries with conditions helps extract only relevant data.
• This pattern is useful for counting frequencies and identifying duplicates.

Understanding sorting of dictionary keys

• Step 1 – data.keys() returns a dictionary view of keys: dict_keys(['a', 'b', 'c']).
• Step 2 – list(data.keys()) converts it into a list: ['a', 'b', 'c'].
• Step 3 – keys.sort(reverse=True) sorts the list in descending order.

• Option 1 – Incorrect: This is ascending order.
• Option 2 – Correct: Descending order → ['c', 'b', 'a'].
• Option 3 – Incorrect: Random incorrect order.
• Option 4 – Incorrect: Random incorrect order.

Example output:

['c', 'b', 'a']

Step-by-step reasoning:

1. Initial keys list: ['a', 'b', 'c']
2. Sort in reverse: ['c', 'b', 'a']

Key takeaways:

• Dictionary views can be converted into lists for sorting.
• sort(reverse=True) sorts the list in descending order.
• This is useful when you need ordered processing of dictionary keys.

Updating dictionaries with another dictionary

• Option 1 – Correct: update() merges new_items into inventory. Existing keys (like "oranges") are updated, new keys (like "grapes") are added.
• Option 2 – Incorrect: add() is not a valid dictionary method.
• Option 3 – Incorrect: merge() is not a standard dictionary method in Python.
• Option 4 – Incorrect: You cannot use the `+` operator with dictionaries.

Example output:

{'apples': 5, 'oranges': 4, 'bananas': 2, 'grapes': 10}

Step-by-step reasoning:

1. Start with inventory: {'apples': 5, 'oranges': 3, 'bananas': 2}
2. Update with new_items → 'oranges' value changes to 4, 'grapes' is added
3. Final inventory: {'apples': 5, 'oranges': 4, 'bananas': 2, 'grapes': 10}

Key takeaways:

• update() is the standard way to merge dictionaries.
• Existing keys are overwritten, new keys are added.
• Other methods like + or add() do not work with dictionaries.

Mapping scores to students using a dictionary

• The code creates a dictionary score_map where keys are scores and values are lists of student names with that score.
• Loop through each student:
  • Score 85 → 'Amin' added → {85: ['Amin']}
  • Score 92 → 'Rina' added → {85: ['Amin'], 92: ['Rina']}
  • Score 75 → 'Tariq' added → {85: ['Amin'], 92: ['Rina'], 75: ['Tariq']}
  • Score 92 → 'Sana' appended → {85: ['Amin'], 92: ['Rina', 'Sana'], 75: ['Tariq']}
• top_score = max(score_map.keys()) finds 92.
• score_map[top_score] → ['Rina', 'Sana']

• Option 1 – Incorrect: Includes 'Amin', wrong score.
• Option 2 – Incorrect: Only 'Rina', misses 'Sana'.
• Option 3 – Correct: ['Rina', 'Sana']
• Option 4 – Incorrect: Includes 'Tariq', wrong score.

Example output:

['Rina', 'Sana']

Step-by-step reasoning:

1. Create empty score_map.
2. Iterate students and fill score_map with lists of names per score.
3. Find the maximum score → 92.
4. Retrieve students with that score → ['Rina', 'Sana'].

Key takeaways:

• Dictionaries can map keys to multiple values using lists.
• This technique is useful for grouping items by categories.
• Looping and conditionally appending helps build complex structures efficiently.

Understanding dictionary keys and values

• Option 1 – Incorrect: Keys must be immutable, not mutable. Mutable types like lists cannot be keys.
• Option 2 – Incorrect: Values can be duplicated; only keys must be unique.
• Option 3 – Incorrect: Insertion order is maintained from Python 3.7 onward. Older versions do not guarantee order.
• Option 4 – Correct: Dictionary keys must be immutable and hashable types like strings, numbers, or tuples.

Example:

valid_dict = {1: "one", (2,3): "tuple key", "name": "Alice"}
# Lists cannot be keys
# invalid_dict = {[1,2]: "list key"}  # Raises TypeError

Step-by-step reasoning:

1. Check key requirements: must be immutable and hashable → ✅ Option 4.
2. Values can repeat → Option 2 is wrong.
3. Insertion order is not guaranteed in older Python → Option 3 is wrong.
4. Mutable types like lists cannot be keys → Option 1 is wrong.

Key takeaways:

• Always use immutable types as dictionary keys.
• Values can be any data type, mutable or immutable.
• Understanding key requirements prevents runtime errors like TypeError: unhashable type.

Counting items across multiple orders and finding the most common

• The code iterates through each order and then each item in the order, building a dictionary item_count with item frequencies.
• Step 1 – Count items:
  • "apple" → 2
  • "banana" → 2
  • "orange" → 2
  • "grape" → 1
• Step 2 – Find items with count equal to the maximum value (2): ["apple", "banana", "orange"]
• Step 3 – Sort alphabetically → ['apple', 'banana', 'orange']

• Option 1 – Incorrect: misses "orange"
• Option 2 – Incorrect: misses "apple"
• Option 3 – Correct: ['apple', 'banana', 'orange']
• Option 4 – Incorrect: "grape" has count 1, not max

Example output:

['apple', 'banana', 'orange']

Step-by-step reasoning:

1. Create empty item_count dictionary.
2. Loop through all items in all orders and count occurrences.
3. Find the maximum count → 2.
4. Build a list of items with count equal to max → ["apple", "banana", "orange"].
5. Sort the list alphabetically → ['apple', 'banana', 'orange'].

Key takeaways:

• Dictionary get(key, default) is useful for counting items.
• List comprehensions help filter based on a condition.
• Sorting ensures consistent output order when multiple items share the same frequency.

Merging dictionaries by summing values of common keys

• Option 1 – Correct: Uses a dictionary comprehension with set(dict1) | set(dict2) to get all keys. dict1.get(k,0) + dict2.get(k,0) sums values for keys present in both dictionaries and keeps others as-is.
• Option 2 – Incorrect: update() overwrites existing keys, does not sum values.
• Option 3 – Incorrect: + operator is not supported for dictionaries.
• Option 4 – Incorrect: Only iterates dict1 keys → misses key 'd' from dict2.

Example output:

{'a': 2, 'b': 10, 'c': 6, 'd': 4}

Step-by-step reasoning:

1. Union of keys: {'a', 'b', 'c', 'd'}
2. Sum values for each key:
   • 'a' → 2 + 0 = 2
   • 'b' → 3 + 7 = 10
   • 'c' → 5 + 1 = 6
   • 'd' → 0 + 4 = 4
3. Final merged dictionary: {'a': 2, 'b': 10, 'c': 6, 'd': 4}

Key takeaways:

• Dictionary comprehensions allow flexible transformations.
• Use get(key, default) to handle missing keys safely.
• This pattern is useful when combining counts or measurements from multiple datasets.

Grouping dictionary values and filtering by length

• The code uses setdefault() to group IDs by scores in score_map.
• Step 1 – Build score_map:
  • 50 → [1, 3]
  • 75 → [2, 5]
  • 90 → [4]
• Step 2 – Filter scores with exactly 2 students:
  • 50 → 2 students → included
  • 75 → 2 students → included
  • 90 → 1 student → excluded
• Final result: {50: [1, 3], 75: [2, 5]}

• Option 1 – Correct: Matches the filtered result.
• Option 2 – Incorrect: Includes 90 which has only 1 student.
• Option 3 – Incorrect: Includes 90 and misses 50 → wrong.
• Option 4 – Incorrect: Includes all scores → 90 should be excluded.

Example output:

{50: [1, 3], 75: [2, 5]}

Step-by-step reasoning:

1. Create empty score_map.
2. Iterate through records and append IDs to the corresponding score key using setdefault().
3. Filter dictionary: only include entries where the list length is exactly 2.
4. Result → {50: [1, 3], 75: [2, 5]}.

Key takeaways:

• setdefault(key, default) is useful for grouping items without checking existence.
• Dictionary comprehensions allow filtering based on complex conditions like list length.
• This technique is handy for analyzing grouped data or identifying patterns in records.

Rotating dictionary keys while preserving values

• Option 1 – Correct:
  • Extract keys and values as lists.
  • Rotate keys by one: keys[1:] + keys[:1] shifts keys to the left.
  • Use zip() to map rotated keys to original values and convert back to dict.
• Option 2 – Incorrect: reversed() reverses order but does not rotate keys.
• Option 3 – Incorrect: Rotates items as (key, value) pairs → preserves original key-value mapping, not rotation of keys.
• Option 4 – Incorrect: Does not rotate keys, just copies the dictionary.

Example output:

{'b': 1, 'c': 2, 'd': 3, 'a': 4}

Step-by-step reasoning:

1. Original keys: ['a', 'b', 'c', 'd'], values: [1, 2, 3, 4]
2. Rotate keys: ['b', 'c', 'd', 'a']
3. Zip rotated keys with original values: [('b',1),('c',2),('d',3),('a',4)]
4. Convert to dictionary → {'b': 1, 'c': 2, 'd': 3, 'a': 4}

Key takeaways:

• Lists of keys and values allow flexible manipulation of dictionaries.
• zip() is useful for remapping keys to values.
• This technique is helpful for cyclic transformations or reordering dictionary keys.

Understanding dictionary comprehensions

• Option 1 – Incorrect: Dictionary comprehensions can be created from any iterable, not just lists.
• Option 2 – Incorrect: Conditional logic can be included in dictionary comprehensions using if statements.
• Option 3 – Incorrect: Dictionary comprehensions do not sort keys automatically; order is insertion-based in Python 3.7+.
• Option 4 – Correct: You can create key-value pairs using expressions and include optional if conditions.

Example:

# Squares of even numbers from 1 to 5
squares = {x: x**2 for x in range(1,6) if x % 2 == 0}
print(squares)  # Output: {2: 4, 4: 16}

Step-by-step reasoning:

1. Loop through an iterable (range 1-5).
2. Include only even numbers (if x % 2 == 0).
3. Compute the square and assign as value: x: x**2.
4. Resulting dictionary: {2: 4, 4: 16}

Key takeaways:

• Dictionary comprehensions are a concise way to create dictionaries from iterables.
• Optional conditions can filter which elements are included.
• Expressions allow dynamic computation of keys and values.

Calculating average grades and filtering with dictionary comprehension

• The code first computes the average grade for each student:
  • Alice → (85+90+95)/3 = 90.0
  • Bob → (75+80)/2 = 77.5
  • Charlie → 100/1 = 100.0
• Next, it filters students with average >= 90 using dictionary comprehension:
  • Alice → 90.0 → included
  • Charlie → 100.0 → included
  • Bob → 77.5 → excluded
• Resulting dictionary: {'Alice': 90.0, 'Charlie': 100.0}

• Option 1 – Correct: Matches filtered students with avg >= 90.
• Option 2 – Incorrect: Misses 'Charlie'.
• Option 3 – Incorrect: Misses 'Alice'.
• Option 4 – Incorrect: Includes 'Bob' who does not meet the condition.

Example output:

{'Alice': 90.0, 'Charlie': 100.0}

Step-by-step reasoning:

1. Compute average grades for all students using sum()/len().
2. Build dictionary avg_grade: {'Alice': 90.0, 'Bob': 77.5, 'Charlie': 100.0}
3. Filter using dictionary comprehension to include only avg >= 90 → {'Alice': 90.0, 'Charlie': 100.0}

Key takeaways:

• Dictionary comprehensions can include nested operations like computing averages.
• Filtering using conditions allows concise selection of relevant items.
• This pattern is useful for data analysis tasks involving grouped data.

Inverting a dictionary with grouping for duplicate values

• Option 1 – Incorrect: When values are duplicated, the last key overwrites previous keys. 'x' and 'z' both have value 1 → only 'z' remains.
• Option 2 – Correct: Uses setdefault() to create a list for each value, appending all keys with that value.
• Option 3 – Incorrect: Invalid syntax, swaps incorrectly.
• Option 4 – Incorrect: zip() only maps first occurrence → duplicates are lost.

Example output:

{1: ['x', 'z'], 2: ['y'], 3: ['w']}

Step-by-step reasoning:

1. Start with empty inverted dictionary.
2. Iterate through original dictionary items:
   • v=1 → append 'x'
   • v=2 → append 'y'
   • v=1 → append 'z'
   • v=3 → append 'w'
3. Final inverted dictionary: {1: ['x', 'z'], 2: ['y'], 3: ['w']}

Key takeaways:

• setdefault() is powerful for grouping values when inverting dictionaries.
• This approach ensures no data is lost for duplicate values.
• Dictionary comprehensions alone are insufficient when values are not unique.

Understanding nested dictionaries

• Option 1 – Incorrect: Nested dictionaries are mutable; values can be modified.
• Option 2 – Correct: You can access inner dictionary values using multiple keys, e.g., data['outer']['inner'], and modify them.
• Option 3 – Incorrect: Values can be of any type, not necessarily dictionaries.
• Option 4 – Incorrect: Printing nested dictionaries preserves structure; they do not flatten automatically.

Example:

data = {"student1": {"score": 85, "grade": "B"}}
data["student1"]["score"] = 90
print(data)  # Output: {'student1': {'score': 90, 'grade': 'B'}}

Step-by-step reasoning:

1. Access inner dictionary using the outer key → data['student1'].
2. Access specific value using inner key → data['student1']['score'].
3. Modify value directly → data['student1']['score'] = 90.
4. Nested dictionary remains intact and reflects updated values.

Key takeaways:

• Nested dictionaries allow hierarchical data storage.
• Multiple key lookups are used to read or update inner values.
• This is useful for complex data like JSON-like structures.

Updating nested dictionary values and calculating totals

• Step 1 – Increase all counts by 2:
  • Fruits: apple → 10+2=12, banana → 5+2=7
  • Vegetables: carrot → 7+2=9, spinach → 3+2=5
• Step 2 – Calculate total count per category using dictionary comprehension:
  • Fruits total: 12 + 7 = 19
  • Vegetables total: 9 + 5 = 14

• Option 1 – Incorrect: Sums incorrectly.
• Option 2 – Correct: {'fruits': 19, 'vegetables': 14}
• Option 3 – Incorrect: Sums incorrectly.
• Option 4 – Incorrect: Does not account for increment.

Example output:

{'fruits': 19, 'vegetables': 14}

Step-by-step reasoning:

1. Loop through each category in inventory.
2. Increase each item count by 2.
3. Use dictionary comprehension to sum values per category:
   • Fruits: 12+7=19
   • Vegetables: 9+5=14
4. Resulting dictionary → {'fruits': 19, 'vegetables': 14}

Key takeaways:

• Nested loops can efficiently update values in nested dictionaries.
• Dictionary comprehensions allow summarizing data concisely.
• This pattern is useful for inventory management, aggregation, or reporting tasks.