Python Générer un dictionnaire dynamique dans la liste des clés

J'ai une liste donnée ci-dessous -

keyList1 = ["Person", "Male", "Boy", "Student", "id_123", "Name"]
value1 = "Roger"

Comment puis-je générer dictionnaire dynamique qui peut être récupéré comme ci-dessous -

mydict["Person"]["Male"]["Boy"]["Student"]["id_123"]["Name"] = value

La liste pourrait être n'importe quoi; ou de Longueur Variable, composé de "N" nombre d'éléments inconnus pour moi...

Maintenant j'ai une autre liste, de sorte que Mon dictionnaire doit être mis à jour en conséquence

keyList2 = ["Person", "Male", "Boy", "Student", "id_123", "Age"]
value2 = 25

c'est à dire Si les Touches "Personne", "Male", "Garçon", "Étudiant", "id_123" existe déjà, la nouvelle clé de "l'âge" doit être ajouté ...

Je suggère d'ajouter tous les éléments de la liste et d'utiliser la chaîne résultante en tant que clé. Il serait beaucoup plus facile.
Les réponses à cette question peut aider: stackoverflow.com/questions/16384174/...

OriginalL'auteur Abhishek Kulkarni | 2013-07-04

  1. 8

    Je suis en train d'apprendre python, donc mon code est peut être pas très pythonic, mais voici mon code

    d = {}

keyList1 = ["Person", "Male", "Boy", "Student", "id_123", "Name"]
keyList2 = ["Person", "Male", "Boy", "Student", "id_123", "Age"]
value1 = "Roger"
value2 = 3

def insert(cur, list, value):
    if len(list) == 1:
        cur[list[0]] = value
        return
    if not cur.has_key(list[0]):
        cur[list[0]] = {}
    insert(cur[list[0]], list[1:], value)

insert(d, keyList1, value1)
insert(d, keyList2, value2)

{'Person': {'Male': {'Boy': {'Student': {'id_123': {'Age': 3, 'Name': 'Roger'}}}}}}
    Cela finit par être assez similaire à la mienne. Une suggestion simple: éviter .has_key chaque fois que possible; préférez le plus rapide et plus compréhensible if list[0] not in cur.
    merci, je suis d'accord que c'est plus lisible et la lisibilité des comptes, mais pourquoi c'est plus rapide?
    Essayez à l'aide de timeit. Sur mon ordinateur, in est deux fois plus rapide que .has_key (0.0672 µs vs 0.117 µs). .has_key est une méthode de recherche, alors que in est un builtin qui est distribuée beaucoup plus rapide.
    .has_key est obsolète et n'existe pas dans Python3

    OriginalL'auteur Roman Pekar

  2. 4

    Vous pouvez le faire en faisant imbriquée defaultdicts:

    from collections import defaultdict

def recursive_defaultdict():
    return defaultdict(recursive_defaultdict)

def setpath(d, p, k):
    if len(p) == 1:
        d[p[0]] = k
    else:
        setpath(d[p[0]], p[1:], k)

mydict = recursive_defaultdict()

setpath(mydict, ["Person", "Male", "Boy", "Student", "id_123", "Name"], 'Roger')

print mydict["Person"]["Male"]["Boy"]["Student"]["id_123"]["Name"]
# prints 'Roger'

    Cela a l'avantage agréable d'être capable d'écrire

    mydict['a']['b'] = 4

    sans nécessairement avoir à utiliser le setpath helper.

    Vous pouvez le faire sans récursive defaultdicts:

    def setpath(d, p, k):
    if len(p) == 1:
        d[p[0]] = k
    else:
        setpath(d.setdefault(p[0], {}), p[1:], k)

    OriginalL'auteur nneonneo

  3. 3

    Vous pourriez peut-être sous-classe dict:

    class ChainDict(dict):
    def set_key_chain(self, keyList, value):
        t = self
        for k in keyList[:-1]:
            t = t.setdefault(k, {})
        t.setdefault(keyList[-1], value)

c = ChainDict()
c.set_key_chain(['Person', 'Male', 'Boy', 'Student', 'id_123', 'Name'], 'Roger')
print c
>>{'Person': {'Male': {'Boy': {'Student': {'id_123': {'Name': 'Roger'}}}}}}

c.set_key_chain(['Person', 'Male', 'Boy', 'Student', 'id_123', 'Age'], 25)
print c
>>{'Person': {'Male': {'Boy': {'Student': {'id_123': {'Age': 25,
      'Name': 'Roger'}}}}}}

    OriginalL'auteur Rao

  4. 1

    Créer votre propre classe dérivée de l'dict où la init méthode prend une liste et une seule valeur en tant qu'entrées et parcourir la liste définissant les clés de la valeur, de définir une méthode de mise à jour qui prend une liste et une nouvelle valeur, et pour chaque élément qui n'est pas déjà un jeu de clé à la nouvelle valeur (en supposant que c'est ce dont vous avez besoin).

    Oublier l'idée de

    mydict["Personne"]["Male"]["Garçon"]["Étudiant"]["id_123"]["Nom"] = valeur1`

    comme il est source de confusion avec subindexes.

    OriginalL'auteur Steve Barnes

  5. 0

    Je suis en train de faire face à des choses, si je peux vous suggérer quelques lignes directrices, mais encore une fois je suis naïf en Python, donc c'est juste une ligne directrice...

    vous avez une liste de clés
    de sorte que vous pouvez certainement commencer avec une boucle d'itération pour chaque valeur, puis affectez la valeur

    comme

    for i in keylist:
if type(keylist[i]) == dict:
        do something
    else:
        keylist[i] = {}

    en faire quelque chose, vous devez incrémenter i et l'indice de changement de [i][i+1], puis suivez les mêmes jusqu'à i+n = len(keylist)

    OriginalL'auteur Shruti Joshi

  6. 0

    Utilisation tuple(keyList1) en tant que clé. (les tuples sont immuables et ne peut donc être dict touches).

    Vous aurez un monde de mal de tête avec le imbriquée dict approche. (boucles imbriquées pour l'énumération, de l'héritage de données lors de la hiérarchie des besoins de changement, etc.).

    Sur une seconde pensée, peut-être, vous devez définir une classe de personne

    class Person(object):
    gender = "Male"
    group = "Student"
    id = 123
    Name = "John Doe"

    puis utiliser une liste de toutes les personnes et filtre avec, par exemple,

    male_students = [s for s in  ALL_PERSONS where s.gender=="Male" and s.group="Student"]

    ... pour <= 10000 étudiants, vous devez être bien performancewise.

    OriginalL'auteur Torben Klein

  7. -2
    >>> mydict = {}
>>> keyList1 = ["Person", "Male", "Boy", "Student", "id_123", "Name"]
>>> value1 = "Roger"
>>> reduce(lambda x, y: x.setdefault(y, {}), keyList1, mydict)
{}
>>> mydict["Person"]["Male"]["Boy"]["Student"]["id_123"]["Name"] = value1

    Vous pouvez aussi le faire en une seule étape, comme ce

    >>> keyList2 = ["Person", "Male", "Boy", "Student", "id_123", "Age"]
>>> value2 = 25
>>> reduce(lambda x,y: x.setdefault(y,{}), keyList2[:-1], mydict).update({keyList2[-1]: value2})
    >>> mydict {"Personne": {"Masculin": {"Garçon": {"Étudiant": {'id_123': {'Name': 'Roger'}}}}}}
    er.. d'où reduce(lambda x, y: x.setdefault(y, {}), keyList1, mydict) dépendent du nombre d'éléments ou de les touches spécifiques?

    OriginalL'auteur John La Rooy