Recursive Merge for Python Dict.

What is Recursive Merge?

1. Shallow Keys: For keys that exist only in one dictionary, their values are directly copied to the merged result.

2. Nested Dictionaries: For keys that exist in both dictionaries and whose values are themselves dictionaries, the merge is applied recursively to their contents.

The Code

def merge_dicts(source, updates):
    """
    Recursively merge two dictionaries. If a key exists in both, and its value is a dictionary,
    merge them recursively. Otherwise, take the value from `updates`.
    """
    for key, value in updates.items():
        # If the value is a dictionary and the key exists in the source as a dictionary, recurse
        if isinstance(value, dict) and key in source and isinstance(source[key], dict):
            merge_dicts(source[key], value)
        else:
            # Otherwise, set or update the key in the source
            source[key] = value
    return source

How It Works

1. Iterating Through Updates: The function iterates through the updates dictionary.

2. Handling Nested Dictionaries:
• If a value in updates is a dictionary and the same key exists in source with a dictionary value, the function calls itself recursively to merge them.

3. Updating Values: For all other cases, the value from updates overwrites or adds to the source.

Example Usage

source = {
    "a": 1,
    "b": {
        "c": 2,
        "d": 3
    },
    "e": 4
}

updates = {
    "b": {
        "d": 30,
        "e": 40
    },
    "f": 50
}

merged = merge_dicts(source, updates)

print(merged)

Output:

{
    "a": 1,
    "b": {
        "c": 2,
        "d": 30,
        "e": 40
    },
    "e": 4,
    "f": 50
}

Explanation:

• The key "b" exists in both source and updates. Since its value is a dictionary, the function merges their contents recursively.

• Keys "a" and "e" are unchanged as they don’t exist in updates.

• Key "f" is added from updates.

Why Use Recursive Merge?

1. Complex Structures: Ideal for deeply nested dictionaries, like configuration files, JSON responses, or hierarchical data.

2. Preserves Data: Avoids overwriting nested structures, retaining data from both dictionaries.

3. Customizable: The function can be adapted for more complex merging strategies.

Tips and Best Practices

1. In-Place Modification: The function modifies the source dictionary in-place. If you want to keep source immutable, create a deep copy before calling the function.

2. Type Checking: Ensure the function handles cases where keys might not map to dictionaries in one of the inputs.

3. Error Handling: Consider edge cases, such as non-dictionary inputs or deeply nested structures that could hit Python's recursion limit.

Conclusion