Aktualisiere den Wert eines verschachtelten Wörterbuchs mit unterschiedlicher Tiefe

@FM-Antwort hat das Recht Allgemeine Idee, d.h. eine rekursive Lösung, aber etwas eigenartig Codierung und mindestens ein bug. Ich würde empfehlen, stattdessen:

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

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

Den Fehler zeigt sich, wenn die "update" hat eine k, v Element, wo v ist ein dict und k ist ursprünglich nicht ein Schlüssel im dictionary wird aktualisiert -- @FM ' s code "springt" dieser Teil des Updates (denn es führt ihn auf eine neue, leere dict was nicht gespeichert oder zurückgegeben überall, nur verloren, wenn der rekursive Aufruf liefert).

Meine anderen änderungen sind gering: es gibt keinen Grund für die if/else konstruieren, wenn .get macht die gleiche Arbeit schneller und sauberer, und die isinstance ist am besten angewendet, um abstrakte Basisklassen (nicht Beton) für die Allgemeinheit.

InformationsquelleAutor der Antwort Alex Martelli

@Alex ' s Antwort ist gut, aber funktioniert nicht beim ersetzen ein element wie eine Ganzzahl mit einem Wörterbuch, wie update({'foo':0},{'foo':{'bar':1}}). Dieses update behebt es:

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

InformationsquelleAutor der Antwort bscan

Dieselbe Lösung wie das angenommen, aber klarer Benennung von Variablen, docstring, und es wurde ein Fehler behoben {} als würde der Wert nicht überschreiben.

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

Hier sind ein paar test-Fälle:

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

Dieser Funktionen erhalten Sie in der Scharlatan Paket, in charlatan.utils.

InformationsquelleAutor der Antwort charlax

Update zu @Alex Martelli Antwort fix ein Fehler in seinem Quelltext zu machen, die Lösung robuster:

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

Der Schlüssel ist, dass wir oft erstellen möchten gleichen Typ bei der Rekursion, also wir nutzen hier v.copy().clear() aber nicht {}. Und dies ist besonders nützlich, wenn die dict hier ist der Typ collections.defaultdict die können unterschiedliche Arten von default_factorys.

Beachten Sie auch, dass die u.iteritems() wurde geändert, um u.items() im Python3.

InformationsquelleAutor der Antwort thuzhf

Benutzte ich die Lösung @Alex Martelli schlägt, aber es schlägt fehl,

TypeError 'bool' object does not support item assignment

wenn die beiden Wörterbücher unterscheiden sich im Datentyp auf einer Ebene.

Fall auf der gleichen Ebene, die element-Wörterbuch d ist nur ein Skalar (dh. Bool ), während das element Wörterbuch u ist noch Wörterbuch die Neuzuweisung fehlschlägt, da kein dictionary-Zuordnung möglich ist, in scalar (wie True[k]).

Einer zusätzlichen Bedingung fixes:

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

InformationsquelleAutor der Antwort helvete

Dass ein wenig an der Seite aber brauchen Sie wirklich verschachtelte dictionaries? Je nach problem, mal flacher Wörterbuch ausreichen kann... und gut Aussehen auf Sie:

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

InformationsquelleAutor der Antwort Nas Banov