Mastering Nested Dictionary Flattening in Python

Last update on June 28 2025 12:41:37 (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.

Go to:

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

Python Code Editor: