La définition de la valeur dans une étude python dictionnaire donné une liste d'indices et de la valeur

Désolé si cette question a été répondu avant, j'ai été à la recherche de solutions mais je suis peut-être pas en utilisant les bons termes de recherche.

De toute façon, ce que j'essaie de faire est de définir par programmation d'une valeur dans un dictionnaire, éventuellement imbriquées, étant donné une liste d'indices et d'une valeur.

Ainsi, par exemple, disons que ma liste d'indices est:

['person', 'address', 'city']

et la valeur est

'New York'

Je veux comme résultat un objet dictionary comme:

{ 'Person': { 'address': { 'city': 'New York' } }

Fondamentalement, la liste représente un "chemin" imbriquée dans un dictionnaire.

Je pense que je peux construire le dictionnaire lui-même, mais là où je suis d'achoppement est de savoir comment définir la valeur. Évidemment, si je viens d'écrire du code pour ce qui est manuel, il serait:

dict['Person']['address']['city'] = 'New York'

Mais comment puis-je l'index dans le dictionnaire et définir la valeur comme programme si j'ai juste une liste des indices et de la valeur?

Espère que cela a un sens et n'est pas trop con une question... 🙂 Merci pour toute aide.

Quel est le problème avec dict[x][y][z] = value? Où obtenez-vous value à partir de? C'est quoi ce bizarre format?
C'est faux parce qu'il peut avoir de longueur variable nombre de clés imbriquées.
Vous pouvez être en mesure d'éviter de nidification par l'aide de n-uplet clés: d[tuple(da_list)] = value
Pour plus de contexte, je dois prendre de nombreuses chaînes de caractères dans le format 'key1:key2:key3=valeur" et la transformer en un imbriquée dictionnaire, où key1 est au premier niveau, key2 à la deuxième, etc. Les chaînes peuvent avoir une touche, deux touches, trois touches. Donc un peu de ficelle de fractionnement me met une liste de clés, et une valeur et où je vais, à partir de là est la question suivante...
La question est: "pourquoi avez-vous transformer cela en un imbriquée dictionnaire?" Êtes-vous sûr que vous avez vraiment besoin d'un imbriquée dictionnaire? Des choses comme cela peut souvent être codé mieux avec tuple clés, ou d'autres structures de données.
En fin de compte l'objet construit sera cracher comme JSON...où la hiérarchie est nécessaire. Mais si il ya une meilleure façon d'aller de mes chaînes de caractères à un stringified objet JSON je suis très ouvert à ça 🙂 j'ai peut-être le génie de la solution!?
Quel est le problème avec juste d["key1:key2:cle3"] = valeur?
Si le problème est le json conversion, vous pouvez être en mesure d'utiliser un tuple-clés à l'interne et à seulement convertir à une structure imbriquée lorsque vous devez produire le json. @ekhumoro j'imagine que le programme qui reçoit les données s'attend à quelque chose de imbriqués, comme indiqué dans la question, donc, à l'aide d'une chaîne ne serait pas produire une production utilisable de toute façon(même si json valide).
Oui, mon commentaire était un peu rhétorique: l'OP n'a pas entièrement défini son vrai problème.

InformationsquelleAutor peterk | 2012-12-03

43

Quelque chose comme cela pourrait aider:
```
def nested_set(dic, keys, value):
    for key in keys[:-1]:
        dic = dic.setdefault(key, {})
    dic[keys[-1]] = value
```
Et vous pouvez l'utiliser comme ceci:
```
>>> d = {}
>>> nested_set(d, ['person', 'address', 'city'], 'New York')
>>> d
{'person': {'address': {'city': 'New York'}}}
```
- Aucune idée svp pourquoi cela fonctionne? (Je l'ai essayé et travaux) Et pourquoi un pur de boucle ne fonctionne pas?
- Cela fonctionne parce que l'intérieur de la for look que vous ré-attribuer le dic variable à point à l'intérieur du dictionnaire. Dans l'exemple, lorsque nested_set est de définir, d'abord, vous avez dic == d. Puis le for boucle effectue l'appel dic = dic.setdefault("person", {}) qui ajoute la paire "person": {} à d et également renvoie le référencés {}. Maintenant dic is d["person"], de sorte que la boucle suivante définit la clé address à l'intérieur du dictionnaire, définition dic à point à l'intérieur de l'intérieur dictionnaire. Etc. La dernière touche est traitée d'une manière particulière, parce que vous ne voulez pas créer des dictionnaires plus.
- Il va se casser pour le cas ci-jointes comme il n'a pas le remplacer pour un pré-désigné. Reportez-vous mon de mise en œuvre pour le comportement correct imgur.com/a/pST93yQ
- C'est un comportement différent de ce que la question nécessaire. Comme vous pouvez le voir, il ajoute un peu de complexité dans la mise en œuvre.
InformationsquelleAutor Bakuriu
4

Tout d'abord, vous devriez regarder setdefault

Comme une fonction que j'avais écris comme
```
def get_leaf_dict( dict, key_list):
    res=dict
    for key in key_list:
        res=dict.setdefault( key, {} )
    return res
```
Ce serait utilisée comme:
```
get_leaf_dict( dict, ['Person', 'address', 'city']) = 'New York'
```
Cela peut être nettoyé avec gestion des erreurs et ce, également à l'aide de *args plutôt que d'une seule touche-liste argument pourrait être agréable; mais l'idée est que
vous pouvez effectuer une itération sur les touches, tirant vers le haut le dictionnaire approprié à chaque niveau.
- Et merci pour ce...Bakuriu la réponse est un peu plus complet/concis, mais vous étiez sur la même piste et j'apprécie la façon dont rapidement vous a répondu.
InformationsquelleAutor Dave
2

Voici une autre possibilité:
```
from collections import defaultdict
recursivedict = lambda: defaultdict(recursivedict)
mydict = recursivedict()
```
J'ai d'abord obtenu ce à partir d'ici: https://stackoverflow.com/a/10218517/1530754.

Très intelligent et élégant si vous me demandez.
- C'est ce que je cherchais. thx
InformationsquelleAutor Ryan

Voici ma solution simple: il suffit d'écrire

terms = ['person', 'address', 'city'] 
result = nested_dict(3, str)
result[terms] = 'New York'  # as easy as it can be

Vous pouvez même le faire:

terms = ['John', 'Tinkoff', '1094535332']  # account in Tinkoff Bank
result = nested_dict(3, float)
result[terms] += 2375.30

Maintenant les coulisses:

from collections import defaultdict


class nesteddict(defaultdict):
    def __getitem__(self, key):
        if isinstance(key, list):
            d = self
            for i in key:
                d = defaultdict.__getitem__(d, i)
            return d
        else:
            return defaultdict.__getitem__(self, key)
    def __setitem__(self, key, value):
        if isinstance(key, list):
            d = self[key[:-1]]
            defaultdict.__setitem__(d, key[-1], value)
        else:
            defaultdict.__setitem__(self, key, value)


def nested_dict(n, type):
    if n == 1:
        return nesteddict(type)
    else:
        return nesteddict(lambda: nested_dict(n-1, type))

InformationsquelleAutor Fancy John

J'ai pris la liberté d'étendre le code de la réponse de Bakuriu. Donc upvotes sur ce sont facultatifs, car son code est en soi une comédie solution, qui je n'aurais pas pensé.

def nested_set(dic, keys, value, create_missing=True):
    d = dic
    for key in keys[:-1]:
        if key in d:
            d = d[key]
        elif create_missing:
            d = d.setdefault(key, {})
        else:
            return dic
    if keys[-1] in d or create_missing:
        d[keys[-1]] = value
    return dic

Lors de la configuration de create_missing pour Vrai, vous êtes en s'assurant de ne déjà existant valeurs:

# Trying to set a value of a nonexistent key DOES NOT create a new value
print(nested_set({"A": {"B": 1}}, ["A", "8"], 2, False))
>>> {'A': {'B': 1}}

# Trying to set a value of an existent key DOES create a new value
print(nested_set({"A": {"B": 1}}, ["A", "8"], 2, True))
>>> {'A': {'B': 1, '8': 2}}

# Set the value of an existing key
print(nested_set({"A": {"B": 1}}, ["A", "B"], 2))
>>> {'A': {'B': 2}}

InformationsquelleAutor user3469861

L'utilisation de ces paire de méthodes

def gattr(d, *attrs):
    """
    This method receives a dict and list of attributes to return the innermost value of the give dict
    """
    try:
        for at in attrs:
            d = d[at]
        return d
    except:
        return None


def sattr(d, *attrs):
    """
    Adds "val" to dict in the hierarchy mentioned via *attrs
    For ex:
    sattr(animals, "cat", "leg","fingers", 4) is equivalent to animals["cat"]["leg"]["fingers"]=4
    This method creates necessary objects until it reaches the final depth
    This behaviour is also known as autovivification and plenty of implementation are around
    This implementation addresses the corner case of replacing existing primitives
    https://gist.github.com/hrldcpr/2012250#gistcomment-1779319
    """
    for attr in attrs[:-2]:
        # If such key is not found or the value is primitive supply an empty dict
        if d.get(attr) is None or isinstance(d.get(attr), dict):
            d[attr] = {}
        d = d[attr]
    d[attrs[-2]] = attrs[-1]

N'utilisez pas de nu except:, il devrait jamais apparaissent dans le code. Vous souhaitez utiliser except KeyError à la place. Aussi votre solution casse si quelqu'un utilise un autre type de mappage de dict. Vous pouvez utiliser abc.MutableMapping ou abc.Mapping

InformationsquelleAutor nehemiah

Voici une variante de Bakuriu réponse qui ne repose pas sur une fonction spécifique:

keys = ['Person', 'address', 'city']
value = 'New York'

nested_dict = {}

# Build nested dictionary up until 2nd to last key
# (Effectively nested_dict['Person']['address'] = {})
sub_dict = nested_dict
for key_ind, key in enumerate(keys[:-1]):
    if not key_ind:
        # Point to newly added piece of dictionary
        sub_dict = nested_dict.setdefault(key, {})
    else:
        # Point to newly added piece of sub-dictionary
        # that is also added to original dictionary
        sub_dict = sub_dict.setdefault(key, {})
# Add value to last key of nested structure of keys 
# (Effectively nested_dict['Person']['address']['city'] = value)
sub_dict[keys[-1]] = value

print(nested_dict)

>>> {'Person': {'address': {'city': 'New York'}}}

InformationsquelleAutor Christopher Shymansky

Vous devez vous connecter pour publier un commentaire.