पायथन: दो शब्दकोशों को कुशलतापूर्वक कैसे मर्ज करें – सभी विधियों की तुलना 2026

शब्दकोशों को मर्ज करना सबसे आम पायथन ऑपरेशनों में से एक है। पायथन 3.9+ ने|की शुरुआत की (मर्ज) ऑपरेटर, सबसे स्वच्छ दृष्टिकोण को और भी अधिक स्वच्छ बनाता है। लेकिन शब्दकोशों को मर्ज करने के छह अलग-अलग तरीके हैं, प्रत्येक डुप्लिकेट कुंजी, उत्परिवर्तन और प्रदर्शन के लिए अलग-अलग व्यवहार के साथ। यहां हर विधि बताई गई है.

त्वरित संदर्भ: सभी विधियाँ एक नज़र में

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})

विधि 1: | ऑपरेटर (पायथन 3.9+ – अनुशंसित)

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

ऑपरेटर साफ, पठनीय और स्पष्ट है कि संघर्षों पर कौन सा निर्देश जीतता है। Python 3.9+ प्रोजेक्ट के लिए इसे प्राथमिकता दें।|विधि 2: |= इन-प्लेस अपडेट के लिए (पायथन 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

के बराबर लेकिन मर्ज शब्दार्थ के बारे में अधिक स्पष्ट।|=विधि 3: {**d1, **d2} अनपैकिंग (पायथन 3.5+)config.update(overrides)ओवरराइड के साथ एक डिक्ट इनलाइन बनाते समय सबसे उपयोगी – कॉन्फ़िगरेशन पैटर्न के लिए सामान्य।

से थोड़ा कम पठनीय सरल विलयों के लिए लेकिन अभिव्यक्ति में अधिक लचीलेपन के लिए।

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}

विधि 4: .update() इन-प्लेस म्यूटेशन के लिए|सामान्य गलती:

Method 4: .update() For 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}

का परिणाम निर्दिष्ट करना एक वेरिएबल के लिए – यहलौटाता है ..update()का प्रयोग करें केवल तभी जब आप जानबूझकर कोई नया बनाए बिना पहले निर्देश को बदलना चाहते हैं।Noneविधि 5: चेनमैप – नकल किए बिना आलसी दृश्य.update()सर्वोत्तम उपयोग का मामला:

कॉन्फ़िगरेशन लेयरिंग (स्थानीय → वातावरण → डिफ़ॉल्ट) जहां आप डेटा कॉपी किए बिना प्राथमिकता-क्रम वाला दृश्य चाहते हैं। लुकअप O(n) हैं जहां n = डिक्ट्स की संख्या – बड़े पैमाने पर लुकअप से बचें।

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

प्रदर्शन तुलनासभी क्रिएट-न्यू-डिक्ट विधियां एक-दूसरे के 15% के भीतर हैं। इन-प्लेस संचालन के लिए,

और

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

चूंकि कोई नया निर्देश आवंटित नहीं किया गया है इसलिए ये तेज़ हैं। अधिकांश उपयोग मामलों के लिए प्रदर्शन अंतर नगण्य है – पठनीयता के आधार पर चुनें।.update()डीप मर्ज (नेस्टेड डिक्शनरी)|=अक्सर पूछे जाने वाले प्रश्न

प्रश्न: मुझे Python 3.9+ में किस विधि का उपयोग करना चाहिए?

# 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"}} ✓

ए:

का प्रयोग करें एक नया मर्ज किया गया निर्देश बनाने के लिए।
का प्रयोग करें इन-प्लेस अपडेट के लिए. दोनों आधुनिक पायथन में सबसे अधिक पायथोनिक और पठनीय हैं।d1 | d2प्रश्न: डुप्लिकेट कुंजियों से क्या होता है?d1 |= d2ए: सभी मानक तरीकों में, सबसे दाहिना (अंतिम) निर्देश का मान जीतता है।

– d2 का मान जीतता है।
– d1 का मान जीतता है। आदेश प्राथमिकता को नियंत्रित करता है।d1 | d2प्रश्न: मैं दो डिक्ट्स को कैसे मर्ज करूं और डुप्लिकेट कुंजियों के लिए दोनों मान कैसे रखूं?{**d2, **d1}ए: डिफॉल्टडिक्ट या मैन्युअल तर्क का उपयोग करें:

. या सूचियों को मर्ज करने के लिए: पुनरावृति करें और सेटडिफॉल्ट का उपयोग करें।
प्रश्न: क्या अनेक निर्देशों के लिए कोई एक-लाइनर है?{k: [d1.get(k), d2.get(k)] for k in d1.keys() | d2.keys()} चेन मर्ज ऑपरेटर। या:

प्रश्न: क्या विलय सम्मिलन आदेश को सुरक्षित रखता है?
A: merged = {} | d1 | d2 | d3उत्तर: हाँ. पायथन 3.7+ निर्देश सम्मिलन क्रम को बनाए रखता है। मर्ज में, कुंजियाँ क्रम में दिखाई देती हैं: d1 की अद्वितीय कुंजियाँ, फिर d2 की कुंजियाँ (d2 के मानों से प्रतिस्थापित डुप्लिकेट सहित)।from functools import reduce; merged = reduce(lambda a, b: a | b, [d1, d2, d3])

निष्कर्ष
पायथन 3.9+ परियोजनाओं के लिए:

का उपयोग करें नए मर्ज किए गए डिक्ट्स और

के लिए इन-प्लेस अपडेट के लिए. पुराने पायथन के लिए या जटिल अभिव्यक्ति बनाते समय:d1 | d2.d |= otherका प्रयोग करें बिना कॉपी किए कॉन्फ़िगरेशन लेयरिंग के लिए। बचें जब आप वापसी मूल्य की उम्मीद करते हैं – तो यह{**d1, **d2}लौटाता है और डेटा को उसी स्थान पर संशोधित करना आम तौर पर अपरिवर्तनीय-शैली कोड के लिए गलत विकल्प है।ChainMapलौटाता है और डेटा को उसी स्थान पर संशोधित करना आम तौर पर अपरिवर्तनीय-शैली कोड के लिए गलत विकल्प है।dict.update()लौटाता है और डेटा को उसी स्थान पर संशोधित करना आम तौर पर अपरिवर्तनीय-शैली कोड के लिए गलत विकल्प है।Noneलौटाता है और डेटा को उसी स्थान पर संशोधित करना आम तौर पर अपरिवर्तनीय-शैली कोड के लिए गलत विकल्प है।