حيل بايثون: الدليل الشامل لدمج القواميس (Dictionary Merge)

القواميس من أقوى هياكل البيانات في بايثون. ودمج القواميس عملية شائعة، وتوجد عدة طرق لتنفيذها. في هذا الدليل سنستعرض جميع التقنيات المتاحة، من الأبسط إلى الأكثر تقدمًا.

1. الطرق التقليدية للدمج

الدالة update()

الطريقة الأكثر تقليدية لدمج القواميس هي update():

dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
dict1.update(dict2)
print(dict1)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4}

الفك (Unpacking) باستخدام **

يعتمد أسلوب أحدث على معامل الفك **:

dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
merged = {**dict1, **dict2}
print(merged)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4}

2. المعامل الجديد | (Python 3.9+)

أضاف Python 3.9 معاملًا جديدًا لدمج القواميس:

dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
merged = dict1 | dict2
print(merged)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4}

# Version avec assignation
dict1 |= dict2  # Équivalent à dict1.update(dict2)

3. التعامل مع تعارض المفاتيح

ماذا نفعل عندما تتشارك القواميس مفاتيح مشتركة؟

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}

# La dernière valeur l'emporte
merged = dict1 | dict2
print(merged)  # {'a': 1, 'b': 3, 'c': 4}

# Solution personnalisée
def merge_with_max(d1, d2):
    return {k: max(d1.get(k, 0), d2.get(k, 0)) for k in set(d1) | set(d2)}

merged_max = merge_with_max(dict1, dict2)
print(merged_max)  # {'a': 1, 'b': 3, 'c': 4}

4. دمج القواميس المتداخلة

يتطلب دمج القواميس المتداخلة أسلوبًا أكثر تعقيدًا:

def deep_merge(dict1, dict2):
    merged = dict1.copy()
    for key, value in dict2.items():
        if key in merged and isinstance(merged[key], dict) and isinstance(value, dict):
            merged[key] = deep_merge(merged[key], value)
        else:
            merged[key] = value
    return merged

dict1 = {'a': 1, 'b': {'x': 10, 'y': 20}}
dict2 = {'c': 3, 'b': {'y': 30, 'z': 40}}
merged = deep_merge(dict1, dict2)
print(merged)  # {'a': 1, 'b': {'x': 10, 'y': 30, 'z': 40}, 'c': 3}

5. أفضل الممارسات والنصائح

1. الأداء: في القواميس الصغيرة، تتساوى جميع الطرق من حيث الأداء. أما في القواميس الكبيرة، فتكون update() عادةً الأسرع.

2. سهولة القراءة: يوفر المعامل | (Python 3.9+) أوضح صياغة وأكثرها إيجازًا.

3. عدم قابلية التغيير (Immutability): إذا كنت لا تريد تعديل القواميس الأصلية، فاستخدم المعامل | أو الفك باستخدام **.

4. الأنواع: تأكد من توافق القيم عند الدمج، خاصةً مع القواميس المتداخلة.

6. حالات استخدام متقدمة

دمج عدة قواميس

dicts = [{'a': 1}, {'b': 2}, {'c': 3}]

# Méthode avec |
merged = {}
for d in dicts:
    merged |= d

# Alternative avec reduce
from functools import reduce
merged = reduce(lambda x, y: x | y, dicts)

الدمج الشرطي

def conditional_merge(dict1, dict2, condition):
    return {
        k: v for k, v in (dict1 | dict2).items()
        if condition(k, v)
    }

# Exemple: ne garder que les valeurs positives
merged = conditional_merge(
    {'a': 1, 'b': -2},
    {'c': 3, 'd': -4},
    lambda k, v: v > 0
)
print(merged)  # {'a': 1, 'c': 3}

مصادر إضافية

• Documentation Python sur les dictionnaires
• PEP 584 – Add Union Operators To dict
• Real Python - Merging Dictionaries