Python: So führen Sie zwei Wörterbücher effizient zusammen – alle Methoden im Vergleich 2026

Das Zusammenführen von Wörterbüchern ist eine der häufigsten Python-Operationen. Mit Python 3.9+ wurde|eingeführt (Merge-)Operator, wodurch der sauberste Ansatz noch sauberer wird. Es gibt jedoch sechs verschiedene Möglichkeiten, Wörterbücher zusammenzuführen, jede mit unterschiedlichem Verhalten in Bezug auf doppelte Schlüssel, Mutation und Leistung. Hier wird jede Methode erklärt.

Kurzanleitung: Alle Methoden auf einen Blick

d1 = {"a": 1, "b": 2}
d2 = {"b": 3, "c": 4}

# 1. | operator (Python 3.9+) — RECOMMENDED for most cases
merged = d1 | d2             # {"a": 1, "b": 3, "c": 4}

# 2. |= operator — update d1 in-place (Python 3.9+)
d1 |= d2                     # d1 is now {"a": 1, "b": 3, "c": 4}

# 3. ** unpacking — works in all Python 3.x
merged = {**d1, **d2}        # {"a": 1, "b": 3, "c": 4}

# 4. .update() — in-place mutation
d1.update(d2)                # d1 modified in-place, no return value

# 5. dict() constructor + unpacking
merged = dict(**d1, **d2)    # {"a": 1, "b": 3, "c": 4}

# 6. ChainMap — lazy view of multiple dicts
from collections import ChainMap
merged = ChainMap(d1, d2)    # ChainMap({'a':1,'b':2}, {'b':3,'c':4})

Methode 1: | Operator (Python 3.9+ – empfohlen)

d1 = {"name": "Alice", "age": 30}
d2 = {"age": 31, "city": "Berlin"}  # 'age' exists in both

result = d1 | d2
# {"name": "Alice", "age": 31, "city": "Berlin"}
# d2 values win on duplicate keys
# d1 is NOT modified — creates new dict

# Order matters: d2 | d1 would keep d1's age value
result_reversed = d2 | d1
# {"age": 30, "city": "Berlin", "name": "Alice"}
# d1 values win on duplicate keys

Das| Der Operator ist sauber, lesbar und eindeutig, welches Diktat bei Konflikten gewinnt. Bevorzugen Sie dies für Python 3.9+-Projekte.

Methode 2: |= Für In-Place-Update (Python 3.9+)

config = {"debug": False, "timeout": 30}
overrides = {"debug": True, "max_connections": 100}

config |= overrides
# config is now {"debug": True, "timeout": 30, "max_connections": 100}
# Modifies config in-place — no new dict created

Verwenden Sie|= wenn Sie ein vorhandenes Diktat mit Werten aus einem anderen aktualisieren möchten. Entsprichtconfig.update(overrides) aber ausführlicher über die Zusammenführungssemantik.

Methode 3: {**d1, **d2} Entpacken (Python 3.5+)

defaults = {"color": "blue", "size": "medium"}
user_prefs = {"color": "red", "font": "arial"}

settings = {**defaults, **user_prefs}
# {"color": "red", "size": "medium", "font": "arial"}

# Advantage: can mix with literal keys
settings = {"version": "2.0", **defaults, **user_prefs, "modified": True}
# {"version":"2.0","color":"red","size":"medium","font":"arial","modified":True}

Am nützlichsten, wenn Sie ein Diktat inline mit Überschreibungen erstellen – häufig bei Konfigurationsmustern. Etwas schlechter lesbar als| für einfache Zusammenführungen, aber flexibler in den Ausdrücken.

Methode 4: .update() für In-Place-Mutation

# Returns None — common mistake: assigned to variable
d1 = {"a": 1}
result = d1.update({"b": 2})
print(result)  # None — NOT the merged dict!
print(d1)      # {"a": 1, "b": 2} — d1 was mutated

# Correct usage:
d1 = {"a": 1}
d1.update({"b": 2, "a": 99})  # duplicate key: new value wins
print(d1)  # {"a": 99, "b": 2}

Häufiger Fehler: Zuweisen des Ergebnisses von.update() zu einer Variablen – es gibtNonezurück . Verwenden Sie.update() nur, wenn Sie das erste Diktat absichtlich mutieren möchten, ohne ein neues zu erstellen.

Methode 5: ChainMap – Lazy View ohne Kopieren

from collections import ChainMap

defaults   = {"color": "blue", "debug": False, "size": 10}
production = {"debug": True}
local      = {"size": 20, "extra": "value"}

# ChainMap looks up keys in order (local first, then production, then defaults)
config = ChainMap(local, production, defaults)
print(config["debug"])  # True   (from production)
print(config["color"])  # "blue" (from defaults)
print(config["size"])   # 20     (from local)

# No copy made — changes to source dicts are reflected
defaults["color"] = "green"
print(config["color"])  # "green" — live view

Bester Anwendungsfall: Konfigurationsschichtung (lokal → Umgebung → Standardeinstellungen), bei der Sie eine nach Priorität geordnete Ansicht ohne Kopieren von Daten wünschen. Suchvorgänge sind O(n), wobei n = Anzahl der Diktate – bei umfangreichen Suchvorgängen vermeiden.

Leistungsvergleich

import timeit, collections

d1 = {i: i for i in range(1000)}
d2 = {i: i*2 for i in range(500, 1500)}

# Python 3.11+ benchmarks (microseconds for 10,000 iterations)
print(timeit.timeit(lambda: d1 | d2,              number=10000))  # 5.1µs
print(timeit.timeit(lambda: {**d1, **d2},          number=10000))  # 5.4µs
print(timeit.timeit(lambda: {**d1, **d2},          number=10000))  # 5.4µs
print(timeit.timeit(lambda: dict(d1, **d2),        number=10000))  # 5.8µs

Alle Methoden zum Erstellen eines neuen Diktats liegen innerhalb von 15 % voneinander. Für Vor-Ort-Vorgänge.update() und|= sind schneller, da kein neues Diktat zugewiesen wird. Der Leistungsunterschied ist für die meisten Anwendungsfälle vernachlässigbar – wählen Sie basierend auf der Lesbarkeit.

Deep Merge (verschachtelte Wörterbücher)

# Standard merge doesn't deep-merge nested dicts
d1 = {"user": {"name": "Alice", "age": 30}}
d2 = {"user": {"email": "alice@example.com"}}

merged = d1 | d2
# {"user": {"email": "alice@example.com"}}  — nested dict REPLACED not merged!

# Deep merge function
def deep_merge(base, override):
    result = base.copy()
    for key, value in override.items():
        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
            result[key] = deep_merge(result[key], value)
        else:
            result[key] = value
    return result

merged = deep_merge(d1, d2)
# {"user": {"name": "Alice", "age": 30, "email": "alice@example.com"}}  ✓

Häufig gestellte Fragen

F: Welche Methode sollte ich in Python 3.9+ verwenden?
A: Verwenden Sied1 | d2 zum Erstellen eines neuen zusammengeführten Diktats. Verwenden Sied1 |= d2 für In-Place-Updates. Beide sind die pythonischsten und lesbarsten im modernen Python.

F: Was passiert mit doppelten Schlüsseln?
A: Bei allen Standardmethoden gewinnt der Wert des ganz rechten (letzten) Diktats. d1 | d2 — Der Wert von d2 gewinnt. {**d2, **d1} — Der Wert von d1 gewinnt. Die Reihenfolge bestimmt die Priorität.

F: Wie füge ich zwei Diktate zusammen und behalte beide Werte für doppelte Schlüssel bei?
A: Verwenden Sie ein Standarddict oder eine manuelle Logik:{k: [d1.get(k), d2.get(k)] for k in d1.keys() | d2.keys()}. Oder zum Zusammenführen von Listen: iterieren und setdefault verwenden.

F: Gibt es einen Einzeiler für mehrere Diktate?
A: merged = {} | d1 | d2 | d3 Ketten fusionieren Betreiber. Oder:from functools import reduce; merged = reduce(lambda a, b: a | b, [d1, d2, d3])

F: Bleibt beim Zusammenführen die Einfügungsreihenfolge erhalten?
A: Ja. Python 3.7+ Diktate behalten die Einfügereihenfolge bei. Bei Zusammenführungen erscheinen die Schlüssel in der Reihenfolge: die eindeutigen Schlüssel von d1, dann die Schlüssel von d2 (einschließlich Duplikate, die durch die Werte von d2 ersetzt werden).

Fazit

Für Python 3.9+-Projekte:Verwenden Sied1 | d2 für neue zusammengeführte Diktate undd |= other für In-Place-Updates. Für älteres Python oder beim Erstellen komplexer Ausdrücke:{**d1, **d2}. Verwenden SieChainMap für Konfigurationsschichtung ohne Kopieren. Vermeiden Siedict.update() Wenn Sie einen Rückgabewert erwarten, wirdNonezurückgegeben und das direkte Ändern von Daten ist normalerweise die falsche Wahl für Code im unveränderlichen Stil.