Perbarui nilai kamus bersarang dengan kedalaman beragam

Saya mencari cara untuk memperbarui kamus dict1 dengan isi pembaruan dict tanpa menimpa levelA

dictionary1={'level1':{'level2':{'levelA':0,'levelB':1}}}
update={'level1':{'level2':{'levelB':10}}}
dictionary1.update(update)
print dictionary1
{'level1': {'level2': {'levelB': 10}}}

Saya tahu pembaruan itu menghapus nilai-nilai di level2 karena memperbarui kunci terendah level1.

Bagaimana saya bisa mengatasi ini, mengingat bahwa dictionary1 dan pembaruan dapat memiliki panjang?

Jawaban @ FM memiliki ide umum yang tepat, yaitu solusi rekursif, tetapi agak aneh pengkodean dan setidaknya satu bug. Saya akan merekomendasikan, sebagai gantinya:

Python 2:

import collections

def update(d, u):
    for k, v in u.iteritems():
        if isinstance(v, collections.Mapping):
            d[k] = update(d.get(k, {}), v)
        else:
            d[k] = v
    return d

Python 3:

import collections.abc

def update(d, u):
    for k, v in u.items():
        if isinstance(v, collections.abc.Mapping):
            d[k] = update(d.get(k, {}), v)
        else:
            d[k] = v
    return d

Bug muncul ketika "pembaruan" memiliki k, vitem di mana va dictdan pada kawalnya bukan kunci dalam kamus yang diperbarui - @ FM kode "melompati" bagian ini dari pembaruan (karena melakukan itu pada yang baru kosong dictyang tidak disimpan atau dikembalikan ke mana pun, hilang begitu saja ketika panggilan rekursif kembali).

Perubahan saya yang lain kecil: tidak ada alasan untuk if/ elsemembangun kapan .getmelakukan pekerjaan yang sama lebih cepat dan lebih bersih, dan isinstancepaling baik diterapkan pada kelas dasar abstrak (bukan yang konkret) untuk umum.

Saya perlu sedikit tentang hal ini, tetapi berkat pos @ Alex, dia mengisi celah yang saya lewatkan. Namun, saya menemukan masalah jika nilai dalam rekursif dictterjadi menjadi list, jadi saya pikir saya akan berbagi, dan memperluas jawabannya.

import collections

def update(orig_dict, new_dict):
    for key, val in new_dict.iteritems():
        if isinstance(val, collections.Mapping):
            tmp = update(orig_dict.get(key, { }), val)
            orig_dict[key] = tmp
        elif isinstance(val, list):
            orig_dict[key] = (orig_dict.get(key, []) + val)
        else:
            orig_dict[key] = new_dict[key]
    return orig_dict

@ Jawaban Alex bagus, tetapi tidak berfungsi saat mengganti elemen seperti integer dengan kamus, seperti update({'foo':0},{'foo':{'bar':1}}). Pembaruan ini mengatasinya:

import collections
def update(d, u):
    for k, v in u.iteritems():
        if isinstance(d, collections.Mapping):
            if isinstance(v, collections.Mapping):
                r = update(d.get(k, {}), v)
                d[k] = r
            else:
                d[k] = u[k]
        else:
            d = {k: u[k]}
    return d

update({'k1': 1}, {'k1': {'k2': {'k3': 3}}})

Solusi yang sama dengan yang diterima, tetapi penamaan variabel yang lebih jelas, docstring, dan memperbaiki bug di mana {}sebagai nilai tidak akan menimpa.

import collections


def deep_update(source, overrides):
    """
    Update a nested dictionary or similar mapping.
    Modify ``source`` in place.
    """
    for key, value in overrides.iteritems():
        if isinstance(value, collections.Mapping) and value:
            returned = deep_update(source.get(key, {}), value)
            source[key] = returned
        else:
            source[key] = overrides[key]
    return source

Berikut adalah beberapa kasus uji:

def test_deep_update():
    source = {'hello1': 1}
    overrides = {'hello2': 2}
    deep_update(source, overrides)
    assert source == {'hello1': 1, 'hello2': 2}

    source = {'hello': 'to_override'}
    overrides = {'hello': 'over'}
    deep_update(source, overrides)
    assert source == {'hello': 'over'}

    source = {'hello': {'value': 'to_override', 'no_change': 1}}
    overrides = {'hello': {'value': 'over'}}
    deep_update(source, overrides)
    assert source == {'hello': {'value': 'over', 'no_change': 1}}

    source = {'hello': {'value': 'to_override', 'no_change': 1}}
    overrides = {'hello': {'value': {}}}
    deep_update(source, overrides)
    assert source == {'hello': {'value': {}, 'no_change': 1}}

    source = {'hello': {'value': {}, 'no_change': 1}}
    overrides = {'hello': {'value': 2}}
    deep_update(source, overrides)
    assert source == {'hello': {'value': 2, 'no_change': 1}}

Fungsi ini tersedia dalam paket penipu , di charlatan.utils.

Berikut adalah versi kamus gabungan rekursif yang tidak berubah jika ada yang membutuhkannya.

Berdasarkan jawaban @Alex Martelli .

Python 2.x:

import collections
from copy import deepcopy


def merge(dict1, dict2):
    ''' Return a new dictionary by merging two dictionaries recursively. '''

    result = deepcopy(dict1)

    for key, value in dict2.iteritems():
        if isinstance(value, collections.Mapping):
            result[key] = merge(result.get(key, {}), value)
        else:
            result[key] = deepcopy(dict2[key])

    return result

Python 3.x:

import collections
from copy import deepcopy


def merge(dict1, dict2):
    ''' Return a new dictionary by merging two dictionaries recursively. '''

    result = deepcopy(dict1)

    for key, value in dict2.items():
        if isinstance(value, collections.Mapping):
            result[key] = merge(result.get(key, {}), value)
        else:
            result[key] = deepcopy(dict2[key])

    return result

Perbaikan kecil pada jawaban @ Alex yang memungkinkan pembaruan kamus dengan kedalaman yang berbeda serta membatasi kedalaman yang dibelokkan ke dalam kamus bersarang yang asli (tetapi kedalaman kamus yang diperbarui tidak terbatas). Hanya beberapa kasus yang telah diuji:

def update(d, u, depth=-1):
    """
    Recursively merge or update dict-like objects. 
    >>> update({'k1': {'k2': 2}}, {'k1': {'k2': {'k3': 3}}, 'k4': 4})
    {'k1': {'k2': {'k3': 3}}, 'k4': 4}
    """

    for k, v in u.iteritems():
        if isinstance(v, Mapping) and not depth == 0:
            r = update(d.get(k, {}), v, depth=max(depth - 1, -1))
            d[k] = r
        elif isinstance(d, Mapping):
            d[k] = u[k]
        else:
            d = {k: u[k]}
    return d

Pertanyaan ini sudah lama, tetapi saya mendarat di sini ketika mencari solusi "penggabungan yang mendalam". Jawaban di atas mengilhami apa yang berikut. Saya akhirnya menulis sendiri karena ada bug di semua versi yang saya uji. Titik kritis yang terlewatkan adalah, pada kedalaman sewenang-wenang dari dua dicts input, untuk beberapa kunci, k, pohon keputusan ketika d [k] atau u [k] bukan dict yang salah.

Juga, solusi ini tidak memerlukan rekursi, yang lebih simetris dengan cara dict.update()kerjanya, dan kembali None.

import collections
def deep_merge(d, u):
   """Do a deep merge of one dict into another.

   This will update d with values in u, but will not delete keys in d
   not found in u at some arbitrary depth of d. That is, u is deeply
   merged into d.

   Args -
     d, u: dicts

   Note: this is destructive to d, but not u.

   Returns: None
   """
   stack = [(d,u)]
   while stack:
      d,u = stack.pop(0)
      for k,v in u.items():
         if not isinstance(v, collections.Mapping):
            # u[k] is not a dict, nothing to merge, so just set it,
            # regardless if d[k] *was* a dict
            d[k] = v
         else:
            # note: u[k] is a dict

            # get d[k], defaulting to a dict, if it doesn't previously
            # exist
            dv = d.setdefault(k, {})

            if not isinstance(dv, collections.Mapping):
               # d[k] is not a dict, so just set it to u[k],
               # overriding whatever it was
               d[k] = v
            else:
               # both d[k] and u[k] are dicts, push them on the stack
               # to merge
               stack.append((dv, v))

Cukup gunakan python-benedict (saya lakukan) , ia memiliki mergemetode utilitas (deepupdate) dan banyak lainnya. Ia bekerja dengan python 2 / python 3 dan sudah teruji dengan baik.

from benedict import benedict

dictionary1=benedict({'level1':{'level2':{'levelA':0,'levelB':1}}})
update={'level1':{'level2':{'levelB':10}}}
dictionary1.merge(update)
print(dictionary1)
# >> {'level1':{'level2':{'levelA':0,'levelB':10}}}

Instalasi: pip install python-benedict

Dokumentasi: https://github.com/fabiocaccamo/python-benedict

Dalam kedua jawaban ini penulis tampaknya memahami konsep memperbarui objek yang disimpan dalam kamus atau bahkan iterasi item kamus (sebagai lawan dari kunci). Jadi saya harus menulis yang tidak membuat toko kamus tautologis dan pengambilan. Dicts diasumsikan menyimpan dicts lain atau tipe sederhana.

def update_nested_dict(d, other):
    for k, v in other.items():
        if isinstance(v, collections.Mapping):
            d_v = d.get(k)
            if isinstance(d_v, collections.Mapping):
                update_nested_dict(d_v, v)
            else:
                d[k] = v.copy()
        else:
            d[k] = v

Atau bahkan yang lebih sederhana bekerja dengan jenis apa pun:

def update_nested_dict(d, other):
    for k, v in other.items():
        d_v = d.get(k)
        if isinstance(v, collections.Mapping) and isinstance(d_v, collections.Mapping):
            update_nested_dict(d_v, v)
        else:
            d[k] = deepcopy(v) # or d[k] = v if you know what you're doing

Perbarui ke jawaban @Alex Martelli untuk memperbaiki bug dalam kode untuk membuat solusi lebih kuat:

def update_dict(d, u):
    for k, v in u.items():
        if isinstance(v, collections.Mapping):
            default = v.copy()
            default.clear()
            r = update_dict(d.get(k, default), v)
            d[k] = r
        else:
            d[k] = v
    return d

Kuncinya adalah kita sering ingin membuat tipe yang sama saat rekursi, jadi di sini kita gunakan v.copy().clear()tetapi tidak {}. Dan ini sangat berguna jika di dictsini adalah tipe collections.defaultdictyang dapat memiliki berbagai jenis default_factory.

Perhatikan juga bahwa u.iteritems()telah diubah ke u.items()dalam Python3.

Saya menggunakan solusi yang disarankan @Alex Martelli, tetapi gagal

TypeError 'bool' object does not support item assignment

ketika dua kamus berbeda dalam tipe data pada tingkat tertentu.

Dalam kasus pada tingkat yang sama, elemen kamus dhanyalah skalar (mis. Bool) Sedangkan elemen kamus umasih berupa kamus, pergantian tugas gagal karena tidak ada tugas kamus yang dimungkinkan menjadi skalar (seperti True[k]).

Satu kondisi tambahan memperbaiki bahwa:

from collections import Mapping

def update_deep(d, u):
    for k, v in u.items():
        # this condition handles the problem
        if not isinstance(d, Mapping):
            d = u
        elif isinstance(v, Mapping):
            r = update_deep(d.get(k, {}), v)
            d[k] = r
        else:
            d[k] = u[k]

    return d

Kode di bawah ini harus menyelesaikan update({'k1': 1}, {'k1': {'k2': 2}})masalah dalam jawaban @Alex Martelli dengan cara yang benar.

def deepupdate(original, update):
    """Recursively update a dict.

    Subdict's won't be overwritten but also updated.
    """
    if not isinstance(original, abc.Mapping):
        return update
    for key, value in update.items():
        if isinstance(value, abc.Mapping):
            original[key] = deepupdate(original.get(key, {}), value)
        else:
            original[key] = value
    return original

def update(value, nvalue):
    if not isinstance(value, dict) or not isinstance(nvalue, dict):
        return nvalue
    for k, v in nvalue.items():
        value.setdefault(k, dict())
        if isinstance(v, dict):
            v = update(value[k], v)
        value[k] = v
    return value

gunakan dictataucollections.Mapping

Saya tahu pertanyaan ini cukup lama, tetapi masih memposting apa yang saya lakukan ketika saya harus memperbarui kamus bersarang. Kita dapat menggunakan fakta bahwa dicts dilewatkan dengan referensi dalam python Dengan asumsi bahwa jalur kunci diketahui dan dipisahkan oleh titik. Valas jika kita memiliki data bernama dict:

{
"log_config_worker": {
    "version": 1, 
    "root": {
        "handlers": [
            "queue"
        ], 
        "level": "DEBUG"
    }, 
    "disable_existing_loggers": true, 
    "handlers": {
        "queue": {
            "queue": null, 
            "class": "myclass1.QueueHandler"
        }
    }
}, 
"number_of_archived_logs": 15, 
"log_max_size": "300M", 
"cron_job_dir": "/etc/cron.hourly/", 
"logs_dir": "/var/log/patternex/", 
"log_rotate_dir": "/etc/logrotate.d/"
}

Dan kami ingin memperbarui kelas antrian, jalur kuncinya adalah - log_config_worker.handlers.queue.class

Kita dapat menggunakan fungsi berikut untuk memperbarui nilai:

def get_updated_dict(obj, path, value):
    key_list = path.split(".")

    for k in key_list[:-1]:
        obj = obj[k]

    obj[key_list[-1]] = value

get_updated_dict(data, "log_config_worker.handlers.queue.class", "myclass2.QueueHandler")

Ini akan memperbarui kamus dengan benar.

Bisa jadi Anda menemukan kamus yang tidak standar, seperti saya hari ini, yang tidak memiliki atribut-iteritem. Dalam hal ini mudah untuk menafsirkan jenis kamus ini sebagai kamus standar. Misalnya: Python 2.7:

    import collections
    def update(orig_dict, new_dict):
        for key, val in dict(new_dict).iteritems():
            if isinstance(val, collections.Mapping):
                tmp = update(orig_dict.get(key, { }), val)
                orig_dict[key] = tmp
            elif isinstance(val, list):
                orig_dict[key] = (orig_dict[key] + val)
            else:
                orig_dict[key] = new_dict[key]
        return orig_dict

    import multiprocessing
    d=multiprocessing.Manager().dict({'sample':'data'})
    u={'other': 1234}

    x=update(d, u)
    x.items()

Python 3.8:

    def update(orig_dict, new_dict):
        orig_dict=dict(orig_dict)
        for key, val in dict(new_dict).items():
            if isinstance(val, collections.abc.Mapping):
                tmp = update(orig_dict.get(key, { }), val)
                orig_dict[key] = tmp
            elif isinstance(val, list):
                orig_dict[key] = (orig_dict[key] + val)
            else:
                orig_dict[key] = new_dict[key]
        return orig_dict

    import collections
    import multiprocessing
    d=multiprocessing.Manager().dict({'sample':'data'})
    u={'other': 1234, "deeper": {'very': 'deep'}}

    x=update(d, u)
    x.items()

Iya! Dan solusi lain. Solusi saya berbeda pada tombol yang sedang diperiksa. Dalam semua solusi lain, kami hanya melihat kunci di dict_b. Namun di sini kita melihat penyatuan kedua kamus.

Lakukan dengan itu sesukamu

def update_nested(dict_a, dict_b):
    set_keys = set(dict_a.keys()).union(set(dict_b.keys()))
    for k in set_keys:
        v = dict_a.get(k)
        if isinstance(v, dict):
            new_dict = dict_b.get(k, None)
            if new_dict:
                update_nested(v, new_dict)
        else:
            new_value = dict_b.get(k, None)
            if new_value:
                dict_a[k] = new_value

Jika Anda ingin mengganti "kamus bersarang penuh dengan array", Anda dapat menggunakan potongan ini:

Ini akan mengganti "old_value" dengan "new_value". Secara kasar melakukan pembangunan kembali kamus yang mendalam. Ia bahkan dapat bekerja dengan List atau Str / int yang diberikan sebagai parameter input level pertama.

def update_values_dict(original_dict, future_dict, old_value, new_value):
    # Recursively updates values of a nested dict by performing recursive calls

    if isinstance(original_dict, Dict):
        # It's a dict
        tmp_dict = {}
        for key, value in original_dict.items():
            tmp_dict[key] = update_values_dict(value, future_dict, old_value, new_value)
        return tmp_dict
    elif isinstance(original_dict, List):
        # It's a List
        tmp_list = []
        for i in original_dict:
            tmp_list.append(update_values_dict(i, future_dict, old_value, new_value))
        return tmp_list
    else:
        # It's not a dict, maybe a int, a string, etc.
        return original_dict if original_dict != old_value else new_value

Cara lain menggunakan rekursi:

def updateDict(dict1,dict2):
    keys1 = list(dict1.keys())
    keys2= list(dict2.keys())
    keys2 = [x for x in keys2 if x in keys1]
    for x in keys2:
        if (x in keys1) & (type(dict1[x]) is dict) & (type(dict2[x]) is dict):
            updateDict(dict1[x],dict2[x])
        else:
            dict1.update({x:dict2[x]})
    return(dict1)

sebuah Q baru Bagaimana dengan rantai kunci

dictionary1={'level1':{'level2':{'levelA':0,'levelB':1}},'anotherLevel1':{'anotherLevel2':{'anotherLevelA':0,'anotherLevelB':1}}}
update={'anotherLevel1':{'anotherLevel2':1014}}
dictionary1.update(update)
print dictionary1
{'level1':{'level2':{'levelA':0,'levelB':1}},'anotherLevel1':{'anotherLevel2':1014}}

Anda dapat mencoba ini, ini berfungsi dengan daftar dan murni:

def update_keys(newd, dic, mapping):
  def upsingle(d,k,v):
    if k in mapping:
      d[mapping[k]] = v
    else:
      d[k] = v
  for ekey, evalue in dic.items():
    upsingle(newd, ekey, evalue)
    if type(evalue) is dict:
      update_keys(newd, evalue, mapping)
    if type(evalue) is list:
      upsingle(newd, ekey, [update_keys({}, i, mapping) for i in evalue])
  return newd

Saya merekomendasikan untuk mengganti {}dengan type(v)()untuk menyebarkan jenis objek dari setiap subclass dict disimpan utetapi tidak ada d. Misalnya, ini akan melestarikan jenis seperti koleksi.OrderedDict:

Python 2:

import collections

def update(d, u):
    for k, v in u.iteritems():
        if isinstance(v, collections.Mapping):
            d[k] = update(d.get(k, type(v)()), v)
        else:
            d[k] = v
    return d

Python 3:

import collections.abc

def update(d, u):
    for k, v in u.items():
        if isinstance(v, collections.abc.Mapping):
            d[k] = update(d.get(k, type(v)()), v)
        else:
            d[k] = v
    return d

Itu agak ke samping tetapi apakah Anda benar-benar membutuhkan kamus bersarang? Bergantung pada masalahnya, terkadang kamus datar mungkin cukup ... dan terlihat bagus:

>>> dict1 = {('level1','level2','levelA'): 0}
>>> dict1['level1','level2','levelB'] = 1
>>> update = {('level1','level2','levelB'): 10}
>>> dict1.update(update)
>>> print dict1
{('level1', 'level2', 'levelB'): 10, ('level1', 'level2', 'levelA'): 0}

Jika Anda menginginkan one-liner:

{**dictionary1, **{'level1':{**dictionary1['level1'], **{'level2':{**dictionary1['level1']['level2'], **{'levelB':10}}}}}}