Dictionary with Tuple as Key in Python

Dictionaries allow a wide range of key types, including tuples. Tuples, being immutable, are suitable for use as dictionary keys when storing compound data. For example, we may want to map coordinates (x, y) to a specific value or track unique combinations of values. Let's explores multiple ways to work with dictionaries using tuples as keys.

Direct Assignment

The simplest way to create a dictionary with tuples as keys is by directly assigning key-value pairs. This approach is best when the tuple keys are predefined.

# Creating a dictionary with tuples as keys
d = {
    (1, 2): "Point A",
    (3, 4): "Point B",
    (5, 6): "Point C"
}

# Accessing a value using a tuple key
val = d[(1, 2)]
print(val)

Point A

Explanation:

• In this method, tuples (1, 2), (3, 4), and (5, 6) are keys, each mapping to a specific value.
• We can directly access the value associated with any tuple key by referencing it in square brackets.

Let's explore some more ways and see how we can store dictionary with tuple as key in Python.

Dynamic Insertion

When the tuple keys are not predefined and are generated dynamically, we can create or update the dictionary using tuple keys at runtime.

# Initialize an empty dictionary
d = {}

# Dynamically adding tuple keys
d[(1, 2)] = "Point A"
d[(3, 4)] = "Point B"
d[(5, 6)] = "Point C"

# Accessing a value using a tuple key
value = d[(3, 4)]
print(value)

Point B

Explanation:

• This method allows flexibility by enabling us to add tuple keys dynamically.
• It is ideal for situations where the dictionary keys are determined during program execution.

Using defaultdict for Multiple Tuple Keys

If we need to store multiple values for a tuple key, using a defaultdict from the collections module simplifies the process.

from collections import defaultdict

# Initialize a defaultdict with list as default type
d = defaultdict(list)

# Adding values to tuple keys
d[(1, 2)].append("Value 1")
d[(1, 2)].append("Value 2")
d[(3, 4)].append("Value 3")

# Converting defaultdict to a regular dictionary for display
print(dict(d))

{(1, 2): ['Value 1', 'Value 2'], (3, 4): ['Value 3']}

Explanation:

• Here, each tuple key can have multiple values stored in a list.
• This approach is useful when managing a mapping of tuple keys to multiple related values.

Nested Tuples as Keys

In some cases, tuples themselves may contain other tuples, forming nested structures. These can also be used as dictionary keys.

# Creating a dictionary with nested tuple keys
data = {
    (("John", "Doe"), 25): "Engineer",   
    (("Jane", "Smith"), 30): "Doctor"    
}

# Accessing a value using a nested tuple key
value = data[(("Jane", "Smith"), 30)]
print(value)

Doctor

Explanation: Each key contains a tuple inside another tuple → making it a nested tuple.

Using Tuples as Composite Identifiers

Tuples can be used to represent composite identifiers, like combining multiple attributes to form a unique key.

# Creating a dictionary with tuples as keys
d = {
    (1, 2): "Point A",
    (3, 4): "Point B",
    (5, 6): "Point C"
}

# Iterating over the dictionary
for key, value in d.items():
    print(f"Key: {key}, Value: {value}")

Key: (1, 2), Value: Point A
Key: (3, 4), Value: Point B
Key: (5, 6), Value: Point C

Explanation:

• Composite keys are useful when storing information about individuals or entities that require multiple attributes to identify them uniquely.
• This method is practical for applications like databases or user records.

Iterating Over Tuple Keys

You can iterate over tuple keys in a dictionary just like any other key type. This is particularly useful when you need to process or analyze data stored in the dictionary.

# Creating a dictionary with tuples as keys
d = {
    (1, 2): "Point A",
    (3, 4): "Point B",
    (5, 6): "Point C"
}

# Iterating over the dictionary
for key, value in d.items():
    print(f"Key: {key}, Value: {value}")

Key: (1, 2), Value: Point A
Key: (3, 4), Value: Point B
Key: (5, 6), Value: Point C

Explanation:

• items() method allows us to retrieve both keys and values during iteration.
• This method is efficient for processing all entries in the dictionary.