Dictionary Fundamentals and Operations
Composite keys are tuples used as dictionary keys to organize data by multiple related values simultaneously.
One Key, Several Details
A dictionary normally connects a key to a value. Sometimes one piece of information is not enough to identify the value you need. A composite key solves this by combining multiple related values into one tuple and using that complete tuple as the dictionary key. The dictionary then organizes data by the combination rather than by either component alone.
A grade record can be identified by several related pieces of information, such as a student ID, a course code, and a year. The combination can identify one record even when an individual component is not unique by itself.
The entire tuple is the key. The dictionary does not treat the tuple components as separate keys; it uses their complete combination for lookup.
Building the Composite Key
To assign a value with a composite key, place the comma-separated key components inside the dictionary brackets. The source gives the form dictionary[key1, key2] = value. Python treats those comma-separated components as a tuple key, so this is equivalent to dictionary[(key1, key2)] = value. The parentheses are optional in this bracketed syntax.
Assigning and Retrieving with the Same Pair
Use a last name and first name together as a composite key, then retrieve the value associated with that exact pair.
Create the key: The pair (Smith, Alice) is treated as one complete tuple key.
Assign the value: The source form directory[last, first] = number stores a value under the tuple made from last and first.
Retrieve the value: Accessing the dictionary with the same composite key looks up the value associated with that exact tuple.
Compare the components: (Smith, Alice) and (Smith, Bob) are different keys because one component differs. (Smith, Alice) and (Johnson, Alice) are also different keys because one component differs.
A lookup succeeds when the composite key matches the stored tuple key exactly.
Exact-Match Lookup
A composite key is useful when several pieces of information must be considered together. The dictionary compares the complete tuple key used for the lookup with the complete tuple key that was stored. Sharing a last name is not enough to identify the same key, and sharing a first name is not enough either. Every component contributes to the identity of the composite key.
| Stored or looked-up tuple | Relationship to (Smith, Alice) |
|---|---|
| (Smith, Alice) | Exact same composite key |
| (Smith, Bob) | Different first component value |
| (Johnson, Alice) | Different last component value |
Composite keys are distinguished by the complete combination of their components.
Use a composite key when the combination of multiple related values is the identifier you need for lookup. Keep the key structure consistent throughout the dictionary so assignments and retrievals use the same components in the same arrangement.
Unpacking During Iteration
When you iterate over a dictionary with composite keys, the loop receives each key in turn. Because each key is a tuple, you can write multiple variable names separated by commas in the loop. Python then unpacks the tuple into those variables automatically. This lets you work with the individual components directly instead of retrieving a tuple and manually extracting its parts.
What do you think happens?
What happens when a dictionary iteration uses two loop variables for each tuple key?
Reveal answer
Answer: The tuple is unpacked into the two variables.
For each key, Python assigns the tuple components to the corresponding loop variables automatically. This allows the individual components to be used directly during the iteration.
The unpacking variables represent the tuple components in order. The first variable receives the first component, and the second variable receives the second component. This makes iteration concise while preserving the complete composite-key structure used by the dictionary.
Key Validity and Structure
A composite key must be hashable, which means it must be immutable. Every element inside the tuple must also be hashable. The tuple can serve as a dictionary key only when this requirement is satisfied for the tuple and all of its elements.
Treating one component as if it were the complete key
The dictionary uses the complete tuple, so a partial component does not match the composite key.
Fix:
Use the same complete tuple structure for lookup that was used for assignment.Changing the order of tuple components
A composite key is matched as an exact tuple, and changing component order changes the key.
Fix:
Keep the component order consistent whenever the key is created, retrieved, or unpacked.Using an unhashable tuple component
Every element of a composite-key tuple must be hashable for the tuple to serve as a dictionary key.
Fix:
Ensure that the tuple and all of its elements satisfy the hashability requirement.
Practice the Lookup Pattern
A dictionary stores values using tuples made from a last name and a first name. Explain which of the following keys represents the same complete composite key as (Smith, Alice): (Smith, Alice), (Smith, Bob), or (Alice, Smith). Then describe how two loop variables could receive the two components when the dictionary is iterated.
Hints
- Compare every component, not just one shared name.
- The order of the tuple components matters.
- During iteration, the first loop variable receives the first component and the second receives the second component.
- A tuple used as a dictionary key combines multiple related values into one composite key. Assignment can use dictionary[key1, key2] = value, which is equivalent to using dictionary[(key1, key2)] = value. Retrieval must use the same complete tuple. During dictionary iteration, multiple loop variables can unpack each tuple key into its individual components.
Key Takeaways
- A composite key is a complete tuple used as one dictionary key.
- Dictionary[key1, key2] = value and dictionary[(key1, key2)] = value use equivalent tuple-key syntax.
- A lookup succeeds only when every composite-key component matches in the same order.
- Composite-key tuples and all their elements must be hashable.
- Dictionary iteration can unpack each tuple key directly into separate variables.