Değişen derinlikte iç içe bir sözlüğün değerini güncelleme

Üzerine yazma düzeyi olmadan dict güncellemesinin içeriği ile dict dictionary1'i güncellemenin bir yolunu arıyorum

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

Güncellemenin en düşük anahtar seviye1'i güncellediği için level2'deki değerleri sildiğini biliyorum.

Sözlük1 ve güncellemenin herhangi bir uzunluğu olabileceği göz önüne alındığında, bununla nasıl başa çıkabilirim?

@ FM'nin cevabı doğru genel fikre, yani özyinelemeli bir çözüme sahiptir, ancak biraz tuhaf kodlama ve en az bir hata vardır. Bunun yerine tavsiye ederim:

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

"Güncelleme" bir olduğunda yukarı böcek gösterileri k, vöğeyi vbir olduğunu dictve kboş bir yeni üzerinde gerçekleştirir çünkü (FM'in kod "geçiş" @ güncelleme bu kısmı - aslen güncellenmektedir sözlükten bir anahtar değildirdict olan kaydedilmez veya herhangi bir yere geri gönderilmez, yinelemeli arama geri döndüğünde kaybolur).

Diğer değişikliklerim önemsiz: aynı işi daha hızlı ve daha temiz yapan if/ elseyapının bir nedeni yoktur .getve isinstancegenel olarak soyut temel sınıflara (somut olanlara değil) uygulanır.

Bu konuda bana biraz aldı, ama @ Alex'in mesajı sayesinde, eksik olduğum boşluğu doldurdu. Özyinelemeli içinde bir değer, ancak ben bir sorun rastladım dictbir olur listben paylaşabilir ve onun cevabını uzatmak düşündüm bu yüzden.

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

@ Alex'in yanıtı iyidir, ancak tamsayı gibi bir öğeyi sözlük gibi bir sözlükle değiştirirken çalışmaz update({'foo':0},{'foo':{'bar':1}}). Bu güncelleme aşağıdakileri ele almaktadır:

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

Kabul edilen ile aynı çözüm, ancak daha net değişken adlandırma, öğretme ve {}bir değerin geçersiz kılınmayacağı bir hata düzeltildi .

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

İşte birkaç test örneği:

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

Bu işlev, içindeki charlatan paketinde bulunur charlatan.utils.

İşte herkesin ihtiyaç duyması durumunda özyinelemeli sözlük birleştirmenin Değişmeyen bir sürümü.

@Alex Martelli en dayanarak cevap .

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

@ Alex'in cevabında , farklı derinliklerde sözlüklerin güncellenmesini sağlayan ve güncellemenin orijinal iç içe sözlükte daldığı derinliği sınırlayan küçük iyileştirmeler (ancak güncelleme sözlüğü derinliği sınırlı değildir). Sadece birkaç vaka test edildi:

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

Bu soru eski, ama ben bir "derin birleşme" çözümü ararken buraya indi. Yukarıdaki cevaplar takip edenlere ilham verdi. Test ettiğim tüm sürümlerde hatalar olduğu için kendim yazdım. Kaçırılan kritik nokta, iki giriş dikiminin keyfi bir derinliğinde, bazı anahtarlar için, d [k] veya u [k] bir diksiyon olmadığında karar ağacı hatalıydı.

Ayrıca, bu çözüm, nasıl dict.update()çalıştığı ve geri döndüğü ile daha simetrik olan özyineleme gerektirmez 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))

Sadece python-benedict (yaptım) kullanın , bir merge(derin güncelleme) yarar yöntemi ve diğerleri vardır. Python 2 / python 3 ile çalışır ve iyi test edilmiştir.

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

Kurulum: pip install python-benedict

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

Bu cevapların hiçbirinde yazarlar, sözlükte depolanan bir nesneyi güncelleme veya hatta sözlük öğeleri üzerinde yineleme (anahtarların aksine) kavramını anlamıyor gibi görünüyor. Bu yüzden anlamsız totolojik sözlük mağazaları ve alımlar yapmayan bir tane yazmak zorunda kaldım. Bu dikmelerin diğer dikmeleri veya basit türleri sakladığı varsayılmaktadır.

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

Ya da herhangi bir türle çalışmak daha basit:

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

@Alex Martelli'nin çözümü daha sağlam hale getirmek için kodundaki bir hatayı düzeltmek için verdiği cevaba güncelleyin:

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

Anahtar, özyinelemede genellikle aynı türü oluşturmak istediğimizdir , bu yüzden burada kullanıyoruz v.copy().clear()ama kullanmıyoruz {}. Ve bu, eğer dictburada collections.defaultdictfarklı türde olabilirdefault_factory s .

Ayrıca fark u.iteritems()olarak değiştirildi u.items()içinde Python3.

@Alex Martelli'nin önerdiği çözümü kullandım, ancak başarısız oluyor

TypeError 'bool' object does not support item assignment

iki sözlük veri düzeyinde bir düzeyde farklılık gösterdiğinde.

Aynı seviyede ise sözlük unsuru dsadece bir skalerdir (yani. Bool)u öğesi hala sözlük iken, skalere hiçbir sözlük ataması mümkün olmadığından (atama) yeniden atama başarısız olur True[k].

Eklenen bir koşul şunları düzeltir:

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

Aşağıdaki kod update({'k1': 1}, {'k1': {'k2': 2}}), @Alex Martelli'nin cevabındaki doğru şekilde sorunu çözmelidir.

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

kullan dictya dacollections.Mapping

Bu sorunun oldukça eski olduğunu biliyorum, ama yine de iç içe bir sözlüğü güncellemem gerektiğinde yaptığım şeyi gönderiyorlar. Anahtarların yolunun bilindiği ve noktadan ayrıldığı varsayılarak, dikmelerin python'da referansla geçirildiği gerçeğini kullanabiliriz. Forex, data adında bir sözümüz varsa:

{
"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/"
}

Ve kuyruk sınıfını güncellemek istiyoruz, anahtarın yolu - log_config_worker.handlers.queue.class

Değeri güncellemek için aşağıdaki işlevi kullanabiliriz:

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

Bu, sözlüğü doğru şekilde güncelleyecektir.

Bugün benim gibi standart olmayan bir sözlük üzerinde rastlamanız olabilir, bu da iteritems-Attribute içermez. Bu durumda bu sözlük türünü standart sözlük olarak yorumlamak kolaydır. Örn: 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()

Evet! Ve başka bir çözüm. Benim çözümüm kontrol edilen tuşlardan farklı. Diğer tüm çözümlerde sadece anahtarlara bakıyoruz dict_b. Ancak burada her iki sözlüğün birliğine bakıyoruz.

İstediğiniz gibi yapın

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

"Tam iç içe bir sözlüğü dizilerle" değiştirmek istiyorsanız bu snippet'i kullanabilirsiniz:

"Old_value" ifadesi "new_value" ile değiştirilir. Kabaca sözlüğün derinlik-ilk yeniden inşasını yapıyor. Birinci seviyenin giriş parametresi olarak verilen List veya Str / int ile bile çalışabilir.

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

Özyineleme kullanmanın başka bir yolu:

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)

yeni bir Q nasıl yapılır bir anahtar zinciri tarafından

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

bunu deneyebilir, listelerle çalışır ve saftır:

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

Ben yerine tavsiye {}ile type(v)()herhangi dict alt sınıfının saklanan bir Propagate nesne türü için uama eksik d. Örneğin, bu koleksiyonlar gibi türleri koruyacaktır.

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

Bu biraz yan ama gerçekten iç içe sözlüklere ihtiyacınız var mı? Soruna bağlı olarak, bazen düz sözlük yeterli olabilir ... ve iyi görünebilir:

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

Tek astar istiyorsanız:

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