Mastering Nested Dictionary Flattening in Python

Last update on April 10 2025 12:54:34 (UTC/GMT +8 hours)

81. Nested Dictionary Manipulation

Write a Python function that flattens a nested dictionary into a single-level dictionary. The keys in the flattened dictionary should be tuples representing the path to each value.

Hints

• Use recursion to traverse the nested structure
• Keep track of the current path using a tuple
• Check if a value is a dictionary using isinstance(value, dict)

Example:

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

Output: {('a',): 1, ('b', 'c'): 2, ('b', 'd', 'e'): 3, ('f',): 4}

Solution:

Python Code:

# Define a function to flatten a nested dictionary into a single-level dictionary.
def flatten_dict(nested_dict, parent_key=(), result=None):
    """
    Flattens a nested dictionary into a single-level dictionary.
    The keys in the flattened dictionary are tuples representing the path to each value.
    
    Args:
        nested_dict: The dictionary to flatten
        parent_key: Tuple containing the path to the current position
        result: The resulting flattened dictionary
        
    Returns:
        A flattened dictionary with tuple keys
    """
    # Initialize the result dictionary if it is not provided (first call to the function).
    if result is None:
        result = {}
    
    # Iterate over each key-value pair in the nested dictionary.
    for key, value in nested_dict.items():
        # Create a new key by appending the current key to the parent key tuple.
        new_key = parent_key + (key,)
        
        # Check if the current value is itself a dictionary (nested structure).
        if isinstance(value, dict):
            # If it's a dictionary, recursively call the function to flatten this sub-dictionary.
            flatten_dict(value, new_key, result)
        else:
            # If it's not a dictionary, add the key-value pair to the result dictionary.
            result[new_key] = value
            
    # Return the fully flattened dictionary after processing all keys.
    return result

# Test the function with a sample nested dictionary and print the result.
print(flatten_dict({'a': 1, 'b': {'c': 2, 'd': {'e': 3}}, 'f': 4}))

Output:

{('a',): 1, ('b', 'c'): 2, ('b', 'd', 'e'): 3, ('f',): 4}

Explanation of Each Line:

• Function Definition : The function flatten_dict is defined to take three arguments: the nested dictionary, a tuple to track the current key path (parent_key), and the result dictionary to store flattened key-value pairs.
• Result Initialization : If result is None (indicating the first call), it initializes an empty dictionary to store the flattened results.
• Iterating Over Dictionary : The for loop iterates through each key-value pair in the input nested_dict.
• Creating New Key : The new_key is created by appending the current key to the parent_key tuple, forming a path to the current value.
• Checking for Nested Dictionary : The isinstance check determines if the current value is a dictionary. If so, the function calls itself recursively to process the nested structure.
• Adding Non-Nested Values : If the value is not a dictionary, it is added to the result dictionary with its full path as the key.
• Returning the Result : After processing all keys, the function returns the fully flattened dictionary.
• Testing the Function : The print statement tests the function with a sample nested dictionary and outputs the flattened result.

Explanation - Nested Dictionary Manipulation

• Concept: Transform a multi-level nested dictionary into a single-level (flat) dictionary using tuple keys as paths.
• Challenge: Implement a recursive approach to traverse all levels of the nested dictionary.
• Key Skills:
• Recursive dictionary traversal
• Path tracking with tuples
• Dictionary transformation
• Applications:
• Processing complex configuration files
• Handling nested JSON data from APIs
• Flattening hierarchical data for easier processing
• Creating searchable indexes from nested structures
• Benefits:
• Simplifies access to deeply nested values
• Preserves the complete path to each value
• Makes nested data easier to iterate over

For more Practice: Solve these Related Problems:

• Write a Python function to merge multiple nested dictionaries, preserving the hierarchy.
• Write a Python function to count the occurrences of each unique key in a deeply nested dictionary.
• Write a Python function to find and replace all occurrences of a given value in a nested dictionary.
• Write a Python function to extract all paths (keys) that lead to a given value in a nested dictionary.

Python Code Editor:

Previous: Find Key of Maximum Value in a Dictionary.
Next: Dictionary-based Memoization.