Ändern Sie die Werte in dict von verschachtelten dicts mit Elemente in eine Liste?

Wie würden Sie ändern/erstellen-Schlüssel/- Werte in einem dict von verschachtelten dicts auf der Grundlage der Werte einer Liste, in der das Letzte Element der Liste ist ein Wert für den dict, und der rest der Elemente, die reefer-keys in dicts?
Das wäre die Liste:

list_adddress = [ "key1", "key1.2", "key1.2.1", "value" ]

Dies wäre nur ein problem in Situationen wie beim Parsen von Kommandozeilen-Argumenten. Es ist offensichtlich, dass das ändern/erstellen dieser Wert in einem script wäre ziemlich einfach mit dict_nested["key1"]["key1.2"]["key1.2.1"]["value"].

Wäre dies ein verschachteltes dict von dicts:

dict_nested = { 
    "key1": {
                "key1.1": { 
                            "...": "...",
                },
                "key1.2": { 
                            "key1.2.1": "change_this",
                },
            },

    "key2": {
                "...": "..."
            },
}

Ich denke, dass in diesem Fall so etwas wie eine rekursive Funktion oder eine Liste Verständnis erforderlich wäre.

def ValueModify(list_address, dict_nested):
    ...
    ...
    ValueModify(..., ...)

Auch, wenn Elemente in list_address würde reefer Schlüssel in die nicht vorhandene Wörterbücher, die Sie erstellt werden soll.

InformationsquelleAutor | 2012-08-12
  1. 9

    One-liner:

    keys, (newkey, newvalue) = list_address[:-2], list_address[-2:]
reduce(dict.__getitem__, keys, dict_nested)[newkey] = newvalue

    Hinweis: dict.get und operator.getitem produzieren würde falsch hier Ausnahmen.

    Eine explizite for-Schleife wie in Joel Cornett Antwort vielleicht mehr lesbar.

    Wenn Sie möchten, erstellen Sie den nicht-vorhandenen zwischen-Wörterbücher:

    reduce(lambda d,k: d.setdefault(k, {}), keys, dict_nested)[newkey] = newvalue

    Wenn Sie möchten, um die bestehende zu überschreiben Zwischenwerte, die nicht Wörterbücher, z.B., strings, Ganzzahlen:

    from collections import MutableMapping

def set_value(d, keys, newkey, newvalue, default_factory=dict):
    """
    Equivalent to `reduce(dict.get, keys, d)[newkey] = newvalue`
    if all `keys` exists and corresponding values are of correct type
    """
    for key in keys:
        try:
            val = d[key]
        except KeyError:
            val = d[key] = default_factory()
        else:
            if not isinstance(val, MutableMapping):
                val = d[key] = default_factory()
        d = val
    d[newkey] = newvalue

    Beispiel

    list_address = ["key1", "key1.2", "key1.2.1", "key1.2.1.1", "value"]
dict_nested = {
    "key1": {
                "key1.1": {
                            "...": "...",
                },
                "key1.2": {
                            "key1.2.1": "change_this",
                },
            },

    "key2": {
                "...": "..."
            },
}

set_value(dict_nested, list_address[:-2], *list_address[-2:])
assert reduce(dict.get, list_address[:-1], dict_nested) == list_address[-1]

    Tests

    >>> from collections import OrderedDict
>>> d = OrderedDict()
>>> set_value(d, [], 'a', 1, OrderedDict) # non-existent key
>>> d.items()
[('a', 1)]
>>> set_value(d, 'b', 'a', 2) # non-existent intermediate key
>>> d.items()
[('a', 1), ('b', {'a': 2})]
>>> set_value(d, 'a', 'b', 3) # wrong intermediate type
>>> d.items()
[('a', {'b': 3}), ('b', {'a': 2})]
>>> d = {}
>>> set_value(d, 'abc', 'd', 4)
>>> reduce(dict.get, 'abcd', d) == d['a']['b']['c']['d'] == 4
True
>>> from collections import defaultdict
>>> autovivify = lambda: defaultdict(autovivify)
>>> d = autovivify()
>>> set_value(d, 'abc', 'd', 4)
>>> reduce(dict.get, 'abcd', d) == d['a']['b']['c']['d'] == 4
True
>>> set_value(1, 'abc', 'd', 4) #doctest:+IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
TypeError:
>>> set_value([], 'abc', 'd', 4) #doctest:+IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
TypeError:
>>> L = [10]
>>> set_value(L, [0], 2, 3)
>>> L
[{2: 3}]
    • dies könnte die beste Antwort, wirft aber TypeError beim erstellen von nicht-vorhandenen zwischen-Wörterbücher, wenn der Wert str zum Beispiel list_address = ["key1", "key1.2", "key1.2.1", "key1.2.1.1", "value"]
    • TypeError korrekt ist. Der Schlüssel vorhanden ist, so sollte es nicht sein KeyError.
    • Sebastian, wenn vorhanden, sollte geändert werden 🙂
    • Ich habe die Lösung für das überschreiben von intermediate-non-Wörterbücher.
    • das funktioniert perfekt, vielen Dank!
    • sehr gut gemacht, und die oneliner ist ein echter Augenöffner

    InformationsquelleAutor jfs
  2. 3
    address_list = ["key1", "key1.1", "key1.2", "value"]

def set_value(dict_nested, address_list):
    cur = dict_nested
    for path_item in address_list[:-2]:
        try:
            cur = cur[path_item]
        except KeyError:
            cur = cur[path_item] = {}
    cur[address_list[-2]] = address_list[-1]
    • nicht schaffen nicht-vorhandenen zwischen-Wörterbücher entweder...
    InformationsquelleAutor Joel Cornett
  3. 1

    Ich denke, das funktioniert so, du bist nach.

    def ValueModify(l, d):
  if l[0] not in d:
    d[l[0]] = dict()
  if isinstance(d[l[0]], dict):
    ValueModify(l[1:], d[l[0]])
  else:
    d[l[0]] = l[1]

    Ich bin mit isinstance, die Typ-Prüfung, und im Allgemeinen nicht etwas, das Sie in Python, aber es hat den Wert als erwartet.

    -- Bearbeitet --

    Hinzugefügt, um die fehlenden Schlüssel überprüfen zu setzen verschachtelte Werte, wenn die ursprüngliche nested_dict ist nicht vollständig aufgefüllt.

    • alles in Ordnung! aber dies würde nicht den Schlüssel erstellen, wenn es nicht existieren würde
    • Wäre es nicht, aber es könnte geändert werden, um so zu tun. Ich werde zu aktualisieren.
    • +1 für eine einzigartige rekursive Lösung.
    • hmm keine nicht-vorhandenen zwischen-Wörterbücher
    InformationsquelleAutor g.d.d.c
  4. 0

    Hier eine rekursive Lösung.

    def unravel(d, keys):
    i = keys[0]
    keys = keys[1:]
    tmpDict = d[i]
    if type(tmpDict) != type({}):
        return tmpDict
    else:
        return unravel(tmpDict, keys)
    InformationsquelleAutor Makoto
  5. 0

    Einfügen eines neuen Schlüssel-Wert-paar oder aktualisieren Sie den Wert von ein paar:

    import copy
def update_nested_map(d, u, *keys):
    d = copy.deepcopy(d)
    keys = keys[0]
    if len(keys) > 1:
        d[keys[0]] = update_nested_map(d[keys[0]], u, keys[1:])
    else:
        d[keys[0]] = u
    return d

    test:

        >>> d = {'m': {'d': {'v': {'w': 1}}}}

    >>> update_nested_map(d, 999, ['m', 'd', 'v', 'w'])
    {'m': {'d': {'v': {'w': 999}}}}

    >>> update_nested_map(d, 999, ['m', 'd', 'v', 'z'])
    {'m': {'d': {'v': {'z': 999, 'w': 1}}}}

    >>> update_nested_map(d, 999, ['m', 'd', 'l'])
    {'m': {'d': {'v': {'w': 1}, 'l': 999}}}

    >>> update_nested_map(d, 999, ['m','d'])
    {'m': {'d': 999}}
    InformationsquelleAutor Saeid BK
Schreibe einen Kommentar