How Do You Merge Two Dictionaries?

There are three ways to merge, and on a key conflict the value from the right-hand dictionary wins in all of them.

a = {"name": "Ada", "role": "engineer"}
b = {"role": "manager", "team": "platform"}

# 1. The union operator (Python 3.9+)
merged = a | b
print(merged)               # {'name': 'Ada', 'role': 'manager', 'team': 'platform'}
print(a)                    # unchanged - a new dict was created

# 2. Dictionary unpacking
merged2 = {**a, **b}
print(merged2 == merged)    # True

# 3. In-place update
a.update(b)
print(a)                    # {'name': 'Ada', 'role': 'manager', 'team': 'platform'}

The role key exists in both, and manager replaces engineer. The first two forms leave the original dictionaries untouched and produce a new dictionary; update modifies the first dictionary in place.

All three preserve the insertion order of the left dictionary first, and then add any keys from the right that were not already present. A key that exists in both keeps the position it had in the left dictionary.

Two things to know about the union operator. It was added in Python 3.9, so older code uses the unpacking form or update. And it requires both sides to be dictionaries — you cannot union a dict with a list, whereas {**a, **b} also fails on a non-mapping. If you want to merge a dict with a list of pairs, dict(list_of_pairs) is the right tool.

One more point worth raising in an interview: merging with update silently overwrites. If you need to know whether a key was overwritten — to detect a configuration conflict, for instance — check before merging: overlapping = a.keys() & b.keys().

Python gives you three merge forms. The union operator, a | b, was added in 3.9 and returns a new dictionary. Dictionary unpacking, {**a, **b}, does the same thing and works in every version of Python 3. And update, a.update(b), merges in place, changing the left dictionary and returning None.

All three resolve conflicts the same way: the value from the right-hand side wins, and the key keeps its position from the left-hand side. So merging is destructive to the left-hand values without warning. That is the right behaviour most of the time — a defaults dictionary overridden by a user configuration, for example — but it is the wrong behaviour when you need to detect the overlap.

When conflicts matter, check first. The set intersection a.keys() & b.keys() gives you the overlapping keys, and you can then raise, log, or merge each conflict deliberately. A common pattern is to keep the right-hand value only when it is not None, which requires an explicit loop rather than a blind merge, because None is a legitimate value that a plain merge would happily overwrite.

Two more options to know. ChainMap lets you present several dictionaries as one without copying anything, so lookups fall through in order — useful for layered configuration. And for merging more than two dictionaries at once, functools.reduce with operator.or_ does it in one pass, though a simple loop over the dicts is usually clearer.