Python Tricks: The Complete Guide to Dictionary Merge

Dictionaries are one of the most powerful data structures in Python. Merging dictionaries is a common operation, and there are several ways to do it. In this guide, we’ll explore all the available techniques, from the most basic to the most advanced.

1. Classic Merging Methods

The update() method

The most traditional way to merge dictionaries is update():

dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
dict1.update(dict2)
print(dict1)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4}

Unpacking with **

A more modern approach uses the unpacking operator **:

dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
merged = {**dict1, **dict2}
print(merged)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4}

2. The New | Operator (Python 3.9+)

Python 3.9 introduced a new operator for merging dictionaries:

dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
merged = dict1 | dict2
print(merged)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4}

# Assignment version
dict1 |= dict2  # Equivalent to dict1.update(dict2)

3. Handling Key Conflicts

What should you do when the dictionaries share common keys?

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}

# The last value wins
merged = dict1 | dict2
print(merged)  # {'a': 1, 'b': 3, 'c': 4}

# Custom solution
def merge_with_max(d1, d2):
    return {k: max(d1.get(k, 0), d2.get(k, 0)) for k in set(d1) | set(d2)}

merged_max = merge_with_max(dict1, dict2)
print(merged_max)  # {'a': 1, 'b': 3, 'c': 4}

4. Merging Nested Dictionaries

Merging nested dictionaries requires a more sophisticated approach:

def deep_merge(dict1, dict2):
    merged = dict1.copy()
    for key, value in dict2.items():
        if key in merged and isinstance(merged[key], dict) and isinstance(value, dict):
            merged[key] = deep_merge(merged[key], value)
        else:
            merged[key] = value
    return merged

dict1 = {'a': 1, 'b': {'x': 10, 'y': 20}}
dict2 = {'c': 3, 'b': {'y': 30, 'z': 40}}
merged = deep_merge(dict1, dict2)
print(merged)  # {'a': 1, 'b': {'x': 10, 'y': 30, 'z': 40}, 'c': 3}

5. Best Practices and Tips

1. Performance: For small dictionaries, all methods are equivalent in terms of performance. For large dictionaries, update() is generally faster.

2. Readability: The | operator (Python 3.9+) offers the clearest and most concise syntax.

3. Immutability: If you don’t want to modify the original dictionaries, use the | operator or unpacking with **.

4. Types: Make sure the values are compatible when merging, especially with nested dictionaries.

6. Advanced Use Cases

Merging Multiple Dictionaries

dicts = [{'a': 1}, {'b': 2}, {'c': 3}]

# Method with |
merged = {}
for d in dicts:
    merged |= d

# Alternative with reduce
from functools import reduce
merged = reduce(lambda x, y: x | y, dicts)

Conditional Merging

def conditional_merge(dict1, dict2, condition):
    return {
        k: v for k, v in (dict1 | dict2).items()
        if condition(k, v)
    }

# Example: keep only positive values
merged = conditional_merge(
    {'a': 1, 'b': -2},
    {'c': 3, 'd': -4},
    lambda k, v: v > 0
)
print(merged)  # {'a': 1, 'c': 3}

Additional Resources

• Python Documentation on Dictionaries
• PEP 584 – Add Union Operators To dict
• Real Python - Merging Dictionaries