Comment mettre à jour les valeurs dans le dictionnaire imbriqué si les clés sont dans une liste?

Je suppose que vous pouvez parcourir vos clés comme ceci:

d = {}
a = d
for i in key_lst: 
    a[i] = {}
    if i == key_lst[-1]:
        a[i] = value
    else:
        a = a[i]
print(d)
# {'key1': {'key2': {'key3': 'my_value'}}}

Edit: Je suppose que j'ai mal lu la question et répondu comme si le dictionnaire n'existait pas déjà. La réponse jpp est plutôt chouette sinon je suppose!

Voici ce que vous voulez:

from collections import defaultdict

nest = lambda: defaultdict(nest)
d = nest()

def update(d, key_lst , val):
    for k in key_lst[:-1]:
        d = d[k]
    d[key_lst[-1]] = val

update(d, 'qwer', 0)

Vous pouvez aussi utiliser defaultdict , c'est bien dans un sens mais imprime plutôt moche ...:

def update(d, key_lst , val):
    for k in key_lst[:-1]:
        if k not in d:
            d[k] = {}
        d = d[k]
    d[key_lst[-1]] = val

d = {}

update(d, list('qwer'), 0)
# d = {'q': {'w': {'e': {'r': 0}}}}

Vous pouvez créer / accéder de manière itérative aux niveaux en utilisant setdefault dans une boucle:

d = {}
d2 = d
for k in key_lst[:-1]:
    d2 = d2.setdefault(k, {})

d2[key_lst[-1]] = value
print(d)
# {'key1': {'key2': {'key3': 'my_value'}}}

d est la référence à votre dictionnaire, et d2 est une référence jetable qui accède aux niveaux internes à chaque itération.

Structure de dictionnaire prédéfinie: functools.reduce code >

Vous pouvez définir une fonction en utilisant functools.reduce pour appliquer getitem à plusieurs reprises, puis définir une valeur fournie:

from collections import defaultdict

def dd_rec():
    return defaultdict(dd_rec)

def defaultify(d):
    if not isinstance(d, dict):
        return d
    return defaultdict(dd_rec, {k: defaultify(v) for k, v in d.items()})

dd = defaultify(d)

key_lst = ["key1", "key2", "key5", "key6"]
value = "my_value2"
dd = set_nested_item(dd, key_lst, value)

print(dd)

# defaultdict(<function __main__.<lambda>>,
#             {'key1': defaultdict(<function __main__.<lambda>>,
#                          {'key2': defaultdict(<function __main__.<lambda>>,
#                                       {'key3': 'my_value',
#                                        'key5': defaultdict(<function __main__.<lambda>>,
#                                                    {'key6': 'my_value2'})})})})

Remarque operator.getitem est utilisé pour accéder à dict .__ getitem__ , ou à son sucre syntaxique plus couramment utilisé dict [] . Dans ce cas, functools.reduce appelle getitem de manière récursive sur dataDict , en utilisant successivement chaque valeur de mapList [: - 1] code> comme argument. Avec [: -1] , nous omettons intentionnellement la dernière valeur, nous pouvons donc utiliser __setitem__ via dict [key] = valeur pour le clé finale.

---

Imbrication arbitraire du dictionnaire: collections.defaultdict

Si vous souhaitez ajouter des éléments à des branches arbitraires non encore définies, vous pouvez construire un defaultdict . Pour cela, vous pouvez d'abord defaultify votre entrée de dictionnaire habituelle, puis utiliser set_nested_item comme avant:

from functools import reduce
from operator import getitem

def set_nested_item(dataDict, mapList, val):
    """Set item in nested dictionary"""
    reduce(getitem, mapList[:-1], dataDict)[mapList[-1]] = val
    return dataDict

key_lst = ["key1", "key2", "key3"]
value = "my_value"
d = {"key1": {"key2": {"key3": "some_value"}}}

d = set_nested_item(d, key_lst, value)

print(d)
# {'key1': {'key2': {'key3': 'my_value'}}}

key_lst = ["key1", "key2", "key3"]
my_dict={
"key1": {
    "key2": {
        "key3": "some_value"
        }
    },
}

val=my_dict
#loop gets second to last key in chain(path) and assigns it to val
for x in key_lst[:-1]:
    val=val[x]
#now we can update value of last key, cause dictionary key is passed by reference
val[key_lst[-1]]="new value"

print (my_dict)

#{'key1': {'key2': {'key3': 'new value'}}}