web-dev-qa-db-fra.com

Conversion de liste de listes en dictionnaire de dictionnaires en Python

J'essaye de convertir une liste de structure de données de listes en dictionnaire de dictionnaires.

La liste est définie comme suit:

l = [
  ['PP','Ear-rings', 'Holesovice', 2000],
  ['PP','Skirts', 'Holesovice', 1000],
  ['PP','Dresses', 'E-shop', 1500],
  ['BM','Butterfly', 'Holesovice', 1600]
]

Mon but est d'avoir la structure du dictionnaire comme suit:

#{'PP' : {'Holesovice' : {'Ear-rings' : 2000, 'Skirts' : 1000},
#         'E-shop' : {'Dresses' : 1500}},
# 'BM' : {'Holesovice' : {'Butterfly' : 1600}}
#}

Ce bit de code ne renvoie pas la sortie souhaitée:

labels_d = {}
items_d = {}
shops_d = {}

for index, row in enumerate(l):
  items_d[row[1]] = row[3]
  shops_d[row[2]] = items_d
  labels_d[row[0]] = shops_d

print(labels_d)

J'ai trouvé quelques articles traitant de la conversion de listes en dictionnaires ici et ici mais je ne l'ai pas fait fonctionner comme je le voulais. Existe-t-il un moyen "propre" de réaliser la structure indiquée ci-dessus?

pythonpython-3.xlistdictionarynested
20
New2Python

Utiliser dict.setdefault(key, {}) est un bon moyen d’aborder la création de dictionnaires imbriqués de profondeur fixe.

l = [
  ['PP','Ear-rings', 'Holesovice', 2000],
  ['PP','Skirts', 'Holesovice', 1000],
  ['PP','Dresses', 'E-shop', 1500],
  ['BM','Butterfly', 'Holesovice', 1600]
]

d = {}

for tag, item, source, qty in l:
    d.setdefault(tag, {}).setdefault(source, {})[item] = qty

Sortie

{'BM': {'Holesovice': {'Butterfly': 1600}},
 'PP': {'E-shop': {'Dresses': 1500},
        'Holesovice': {'Ear-rings': 2000, 'Skirts': 1000}}}

Généralisation

La solution ci-dessus peut être généralisée en construisant une classe de dictionnaire imbriqué, en supprimant les exigences relatives à une profondeur fixe.

class NestedDict(dict):
    def __getitem__(self, item):
        if item not in self:
            self[item] = NestedDict()
        return super().__getitem__(item)

d = NestedDict()

for tag, item, source, qty in l:
    d[tag][source][item] = qty

Notez également que l'approche de classe est créée afin de ne créer un objet que si la clé n'existe pas alors que l'approche setdefault a créé un dict vide sur chaque accès.

25
Olivier Melançon

Vous pouvez utiliser l'astuce defaultdict infiniment imbriquée:

from collections import defaultdict

def nested_dict():
    return defaultdict(nested_dict)

nd = nested_dict()
for a, b, c, d in l:
    nd[a][c][b] = d
17
schwobaseggl

Vous pouvez utiliser collections.defaultdict et itérer. Dans ce cas, vous pouvez définir avec précision un dictionnaire imbriqué pour refléter votre structure de données.

from collections import defaultdict

L = [['PP','Ear-rings', 'Holesovice', 2000],
     ['PP','Skirts', 'Holesovice', 1000],
     ['PP','Dresses', 'E-shop', 1500],
     ['BM','Butterfly', 'Holesovice', 1600]]

d = defaultdict(lambda: defaultdict(lambda: defaultdict(int)))

for code, item, shop, value in L:
    d[code][shop][item] = value

Résultat 

defaultdict({'BM': defaultdict({'Holesovice': defaultdict(int, {'Butterfly': 1600})}),
             'PP': defaultdict({'E-shop': defaultdict(int, {'Dresses': 1500}),
                                'Holesovice': defaultdict(int,
                                {'Ear-rings': 2000, 'Skirts': 1000})})})
6
jpp
def toNested1(l):
    def addKeyDict(map,key):    
        if key not in map:
            item = map[key] = {}
            return item            
        return map[key]

    zz = {}
    for a0,a1,a2,a3 in l :
        addKeyDict( addKeyDict( zz, a0) , a2 )[a1] = a3
    return zz
0
napuzba

Voici un moyen simple de composer un nouveau dictionnaire:

Si les éléments de chaque ligne de la liste ne se trouvent pas dans la profondeur du dictionnaire, ajoutez/ajoutez simplement la paire clé-valeur au dict.

code: 

list = [
    ['PP','Ear-rings', 'Holesovice', 2000],
    ['PP','Skirts', 'Holesovice', 1000],
    ['PP','Dresses', 'E-shop', 1500],
    ['BM','Butterfly', 'Holesovice', 1600]
]

dicta = {}
for row in list:
    if row[0] not in dicta.keys():
        dicta[row[0]] = {row[2]:{row[1]:row[3]}}
        continue
    if row[2] not in dicta[row[0]].keys():
        dicta[row[0]][row[2]] = {row[1]:row[3]}
        continue
    if row[1] not in dicta[row[0]][row[2]].keys():
        dicta[row[0]][row[2]][row[1]] = row[3]

print(dicta)

sortie: 

{'BM': {'Holesovice': {'Butterfly': 1600}},
 'PP': {'E-shop': {'Dresses': 1500},
        'Holesovice': {'Ear-rings': 2000, 'Skirts': 1000}}}
0
josephzhong