You've probably run into this: two dictionaries, both with useful data, and now you need to merge them. Maybe one has default settings, and the other holds user preferences. Or maybe you're just pulling together pieces from different sources. Either way, combining dictionaries in Python isn't hard—but the method you choose matters. Some options are clean and quick.

Others give you more control. Depending on your Python version, certain tricks may not even be available. If you've ever copied and pasted key-value pairs manually, this guide will save you time and probably a little sanity, too. Let's get into it.

How to Merge Two Dictionaries in Python?

Using the update() Method

The update() function is one of the oldest methods for merging two dictionaries. It updates the original dictionary in place with key-value pairs from another dictionary. If the key exists, its value will be overwritten.

a = {'x': 1, 'y': 2}

b = {'y': 3, 'z': 4}

a.update(b)

print(a)

# Output: {'x': 1, 'y': 3, 'z': 4}

In this example, 'y' existed in both dictionaries. The value from b replaces the one in a. The result is stored in a. If you want to keep the original unchanged, you’ll need to copy it first.

Using the {**d1, **d2} Syntax

Starting in Python 3.5, you can use dictionary unpacking with **. This syntax creates a new dictionary and doesn’t change the originals.

a = {'x': 1, 'y': 2}

b = {'y': 3, 'z': 4}

merged = {**a, **b}

print(merged)

# Output: {'x': 1, 'y': 3, 'z': 4}

This approach is clean and works well for small merges. The second dictionary’s values will overwrite the first if there are key conflicts. If you need a non-destructive way to merge and you’re on 3.5+, this is a good pick.

Using dict() with Unpacking

This is a variation of the previous one. You use dict() with the unpacking operator to merge:

a = {'x': 1, 'y': 2}

b = {'y': 3, 'z': 4}

merged = dict(**a, **b)

print(merged)

# Output: {'x': 1, 'y': 3, 'z': 4}

This works the same as {**a, **b} but uses the constructor directly. Functionally, they behave alike in this context. Choose whichever feels more readable in your codebase.

Using a Loop to Manually Merge

If you want full control over how keys and values are merged, a manual loop is the way to go.

a = {'x': 1, 'y': 2}

b = {'y': 3, 'z': 4}

merged = a.copy()

for key, value in b.items():

merged[key] = value

print(merged)

# Output: {'x': 1, 'y': 3, 'z': 4}

This gives you the freedom to add custom logic. Maybe you want to skip certain keys or only add keys that don’t already exist. This approach opens that door.

Using ChainMap from collections

If you want to treat two dictionaries as one but without actually merging them into a new dictionary, use ChainMap.

from collections, import ChainMap

a = {'x': 1, 'y': 2}

b = {'y': 3, 'z': 4}

merged = ChainMap(b, a)

print(dict(merged))

# Output: {'y': 3, 'z': 4, 'x': 1}

This doesn’t create a true merged dictionary. It just creates a view. It checks b first, then a. You can convert it to a regular dictionary if needed. This is useful when you want a combined view without making a copy.

Using Dictionary Comprehension

This method gives you control over the merge while keeping things concise.

a = {'x': 1, 'y': 2}

b = {'y': 3, 'z': 4}

merged = {k: v for d in (a, b) for k, v in d.items()}

print(merged)

# Output: {'x': 1, 'y': 3, 'z': 4}

It loops through each dictionary in order and builds a new one. The last dictionary in the sequence has the final say for overlapping keys. You can also insert logic inside the loop to control the merge more finely.

Using the | Merge Operator (Python 3.9+)

Python 3.9 introduced a clean way to merge dictionaries using the | operator.

a = {'x': 1, 'y': 2}

b = {'y': 3, 'z': 4}

merged = a | b

print(merged)

# Output: {'x': 1, 'y': 3, 'z': 4}

This doesn’t modify either dictionary—it returns a new one. If you want an in-place update, there’s also |=.

a |= b

print(a)

# Output: {'x': 1, 'y': 3, 'z': 4}

This is the most readable option if you're using Python 3.9 or newer.

Handling Conflicts When Merging

Sometimes, both dictionaries have the same key but different values, and you don’t want to just overwrite. Maybe you want to add them or store them as a list. Here's how you could handle that:

a = {'x': 1, 'y': 2}

b = {'y': 3, 'z': 4}

merged = a.copy()

for k, v in b.items():

if k in merged:

merged[k] = [merged[k], v] # Or any custom logic

else:

merged[k] = v

print(merged)

# Output: {'x': 1, 'y': [2, 3], 'z': 4}

This is a simple example of resolving conflicts manually. You could expand it to check data types, run validation, or use more complex merge rules. This is useful when a plain overwrite isn't good enough.

Conclusion

Merging dictionaries in Python isn't one-size-fits-all. You might want to keep your originals untouched, combine them into a new one, or handle overlaps in a specific way. Python gives you a bunch of tools for the job, from the basic update() method to the newer | operator. If you’re after speed and simplicity, dictionary unpacking or the merge operator are solid. If you need control or custom logic, loops and comprehensions give you that. The best choice depends on what you're trying to do and which version of Python you're working with. Keep it clear, and pick the method that keeps your code readable.