Изменить значения в dict для вложенных dicts, используя элементы в списке?

Question

Как бы вы изменили / создали ключи / значения в диктовке вложенных диктов на основе значений списка, в котором последний элемент списка является значением для диктанта, а остальные элементы реферрируют к ключам внутри диктов? Это был бы список:

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

Это будет проблемой только в ситуациях, например, при разборе аргументов командной строки. Очевидно, что изменение / создание этого значения в скрипте было бы довольно легко dict_nested["key1"]["key1.2"]["key1.2.1"]["value"],

Это будет вложенный диктат:

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

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

Я предполагаю, что в этом случае потребуется что-то вроде рекурсивной функции или понимания списка.

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

Кроме того, если предметы в list_address будет ссылаться на ключи в несуществующих словарях, они должны быть созданы.

Answer 1

Один лайнер:

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

Замечания: dict.get а также operator.getitem будет производить неправильные исключения здесь.

Явный цикл for, как в ответе Джоэла Корнетта, может быть более читабельным.

Если вы хотите создать несуществующие промежуточные словари:

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

Если вы хотите переопределить существующие промежуточные значения, которые не являются словарями, например, строки, целые числа:

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

пример

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]

тесты

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

Answer 2

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]

Answer 3

Я думаю, что это работает, как вы после.

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]

я использую isinstance, что является проверкой типа, и обычно это не то, что вы делаете в Python, но оно устанавливает значение, как и ожидалось.

- Отредактировано -

Добавлена ​​проверка отсутствующего ключа для установки вложенных значений, если оригинал nested_dict не полностью заселен.

Answer 4

Вот рекурсивное решение.

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

Answer 5

Чтобы вставить новую пару ключ-значение или обновить значение пары:

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

тестовое задание:

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