How to Merge Two Dictionaries in a Single Expression in Python

By the end of this page, you will understand how dictionary merging works in Python, how key conflicts are resolved, and how to combine dictionaries into a new one using modern and older Python syntax. You will also see common mistakes, practical examples, and patterns used in real codebases.

In Python, a dictionary stores data as key-value pairs. Merging dictionaries means combining the pairs from two or more dictionaries into one new dictionary.

The key rule in your question is:

• keep all keys from both dictionaries
• if the same key appears in both, the value from the later dictionary should win

For example:

x = {'a': 1, 'b': 2}
y = {'b': 3, 'c': 4}

When merged:

{'a': 1, 'b': 3, 'c': 4}

The key 'b' exists in both dictionaries, so the value from y replaces the value from x.

This matters in real programming because dictionaries are often used for:

• configuration settings
• API response data
• user input
• default values overridden by custom values
• combining computed results

Python gives you several ways to merge dictionaries. The best choice depends on your Python version and whether you want to create a new dictionary or .

Think of a dictionary like a labeled set of sticky notes.

• x is one board of notes
• y is another board of notes
• merging means copying all notes onto a new board

If both boards have a note with the same label, you cannot keep both under the same label. The later board's note replaces the earlier one.

So when you merge x and then y, you are saying:

• start with everything from x
• place everything from y on top
• if y uses a label that already exists, its note covers the old one

That is why the value from y wins when keys overlap.

Modern syntax

In Python 3.9 and later, you can use the dictionary merge operator:

x = {'a': 1, 'b': 2}
y = {'b': 3, 'c': 4}

z = x | y
print(z)
# {'a': 1, 'b': 3, 'c': 4}

This creates a new dictionary.

Compatible syntax for older Python versions

In Python 3.5 and later, dictionary unpacking is a common solution:

x = {'a': 1, 'b': 2}
y = {'b': 3, 'c': 4}

z = {**x, **y}
print(z)
# {'a': 1, 'b': 3, 'c': 4}

This also creates a new dictionary, and later unpacked dictionaries override earlier ones.

Updating an existing dictionary

If you want to modify one dictionary in place instead of creating a new one:

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

x.update(y)
(x)

Consider this example:

x = {'a': 1, 'b': 2}
y = {'b': 3, 'c': 4}
z = {**x, **y}

Here is what happens step by step:

1. Python starts building a new empty dictionary for z.

2. **x adds all key-value pairs from x:

   {'a': 1, 'b': 2}
   

3. **y then adds all key-value pairs from y.

4. Python sees that 'b' already exists.

5. The new value from y replaces the old value from x.

6. 'c' is new, so it gets added.

Final result:

Dictionary merging is very common in Python programs.

Configuration systems

You may have default settings and user overrides:

default_config = {'debug': False, 'port': 5000}
user_config = {'port': 8000}
config = default_config | user_config

API data processing

You may combine data from different sources:

user = {'id': 1, 'name': 'Ava'}
profile = {'name': 'Ava Smith', 'city': 'London'}
full_data = user | profile

Form or request handling

You might start with defaults, then apply submitted values:

defaults = {'newsletter': False, 'role': 'user'}
submitted = {'newsletter': True}
result = defaults | submitted

Test setup

Tests often begin with a base object and override only one or two values:

base_payload = {: , : }
test_payload = base_payload | {: }

In real projects, developers use dictionary merging as part of larger patterns.

Defaults plus overrides

A very common pattern is:

settings = defaults | env_values | cli_args

This clearly shows precedence:

• defaults are lowest priority
• environment values override defaults
• command-line arguments override everything

Building new objects without mutating inputs

In production code, creating a new dictionary is often safer than changing an existing one:

new_state = old_state | {'loading': False}

This avoids unexpected side effects.

Guarded merging

Sometimes you only merge if extra values are present:

result = base.copy()
if extra_data:
    result |= extra_data

Validation before merge

Developers often validate incoming data before merging it:

def apply_overrides(config, overrides):
    allowed = {'host', 'port', 'debug'}
    clean = {k: v for k, v in overrides.items()  k  allowed}
     config | clean

1. Accidentally mutating the original dictionary

Broken expectation:

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

x.update(y)
print(x)  # x was changed

If you need a new dictionary, use:

z = x | y

or:

z = {**x, **y}

2. Expecting both values for duplicate keys to be kept

A dictionary cannot store the same key twice.

x = {'b': 2}
y = {'b': 3}
z = x | y
print(z)
# {'b': 3}

If you need both values, use a different structure such as a list:

{'b': [2, 3]}

3. Reversing the order

Broken logic:

x = {'b': }
y = {: }
z = y | x
(z)

Quick syntax

Python 3.9+

z = x | y

Python 3.5+

z = {**x, **y}

Modify existing dictionary

x.update(y)

Rules

• Dictionaries store unique keys.
• When keys overlap, the later value replaces the earlier one.
• x | y means y has higher priority than x.
• Merging dictionaries normally performs a shallow merge.

Examples

{'a': 1} | {'b': 2}
# {'a': 1, 'b': 2}

{'a': 1} | {'a': 9}
# {'a': 9}

{**{'a': 1}, **{: , : }}

How do I merge two dictionaries in Python without changing the originals?

Use x | y in Python 3.9+ or {**x, **y} in Python 3.5+. Both create a new dictionary.

Which dictionary wins when keys overlap?

The later dictionary wins. In x | y, the value from y replaces the value from x for duplicate keys.

Is dict.update() the same as merging?

It is similar in result, but it modifies the dictionary in place instead of creating a new one.

Does Python have a built-in merge(x, y) function?

No. Python uses operators and methods like |, unpacking, and update() instead.

Can I merge more than two dictionaries at once?

Yes.

result = a | b | c

or:

result = {**a, **b, **c}

Does dictionary merging work recursively for nested dictionaries?

No, not by default. Standard merging is shallow, so nested dictionaries are replaced, not recursively combined.

• Python dictionaries — merging makes more sense once you understand key-value storage.
• Dictionary methods — methods like update(), get(), and items() are often used alongside merging.
• Dictionary unpacking — {**x, **y} is based on unpacking syntax.
• Assignment vs mutation — important for understanding why update() changes an object but | creates a new one.
• Shallow copy vs deep copy — useful because dictionary merging is shallow.
• Nested dictionaries — relevant when merging structured data.
• Keyword arguments in Python — unpacking dictionaries is also used in function calls.
• Python data structures — helps compare dictionaries with lists, tuples, and sets.