Comment créer un dict imbriqué en Python?

J'ai 2 fichiers CSV: 'Data' et 'Mapping':

• Fichier 'Mapping' a 4 colonnes: Device_Name, GDN, Device_Typeet Device_OS. Les quatre colonnes sont remplies.
• Le fichier 'Données' a ces mêmes colonnes, avec une Device_Namecolonne remplie et les trois autres colonnes vides.
• Je veux que mon code Python pour ouvrir les fichiers et pour chaque Device_Namedans le fichier de données, la carte son GDN, Device_Typeet la Device_OSvaleur du fichier de mappage.

Je sais comment utiliser dict quand seulement 2 colonnes sont présentes (1 est nécessaire pour être mappé) mais je ne sais pas comment accomplir cela quand 3 colonnes doivent être mappées.

Voici le code à l'aide duquel j'ai essayé d'effectuer le mappage de Device_Type:

x = dict([])
with open("Pricing Mapping_2013-04-22.csv", "rb") as in_file1:
    file_map = csv.reader(in_file1, delimiter=',')
    for row in file_map:
       typemap = [row[0],row[2]]
       x.append(typemap)

with open("Pricing_Updated_Cleaned.csv", "rb") as in_file2, open("Data Scraper_GDN.csv", "wb") as out_file:
    writer = csv.writer(out_file, delimiter=',')
    for row in csv.reader(in_file2, delimiter=','):
         try:
              row[27] = x[row[11]]
         except KeyError:
              row[27] = ""
         writer.writerow(row)

Il revient Attribute Error.

Après quelques recherches, je pense que j'ai besoin de créer un dict imbriqué, mais je ne sais pas comment faire cela.

Un dict imbriqué est un dictionnaire dans un dictionnaire. Une chose très simple.

>>> d = {}
>>> d['dict1'] = {}
>>> d['dict1']['innerkey'] = 'value'
>>> d
{'dict1': {'innerkey': 'value'}}

Vous pouvez également utiliser un defaultdictdu collectionspackage pour faciliter la création de dictionnaires imbriqués.

>>> import collections
>>> d = collections.defaultdict(dict)
>>> d['dict1']['innerkey'] = 'value'
>>> d  # currently a defaultdict type
defaultdict(<type 'dict'>, {'dict1': {'innerkey': 'value'}})
>>> dict(d)  # but is exactly like a normal dictionary.
{'dict1': {'innerkey': 'value'}}

Vous pouvez le remplir comme vous le souhaitez.

Je recommanderais dans votre code quelque chose comme ce qui suit:

d = {}  # can use defaultdict(dict) instead

for row in file_map:
    # derive row key from something 
    # when using defaultdict, we can skip the next step creating a dictionary on row_key
    d[row_key] = {} 
    for idx, col in enumerate(row):
        d[row_key][idx] = col

Selon votre commentaire :

peut être au-dessus du code confond la question. Mon problème en bref: j'ai 2 fichiers a.csv b.csv, a.csv a 4 colonnes ijkl, b.csv a également ces colonnes. i est une sorte de colonnes clés pour ces csv. La colonne jkl est vide dans a.csv mais remplie dans b.csv. Je veux mapper les valeurs des colonnes jk l en utilisant 'i' comme colonne clé de b.csv vers un fichier.csv

Ma suggestion serait quelque chose comme ça (sans utiliser defaultdict):

a_file = "path/to/a.csv"
b_file = "path/to/b.csv"

# read from file a.csv
with open(a_file) as f:
    # skip headers
    f.next()
    # get first colum as keys
    keys = (line.split(',')[0] for line in f) 

# create empty dictionary:
d = {}

# read from file b.csv
with open(b_file) as f:
    # gather headers except first key header
    headers = f.next().split(',')[1:]
    # iterate lines
    for line in f:
        # gather the colums
        cols = line.strip().split(',')
        # check to make sure this key should be mapped.
        if cols[0] not in keys:
            continue
        # add key to dict
        d[cols[0]] = dict(
            # inner keys are the header names, values are columns
            (headers[idx], v) for idx, v in enumerate(cols[1:]))

Veuillez noter cependant que pour analyser les fichiers csv, il existe un module csv .

MISE À JOUR : Pour une longueur arbitraire d'un dictionnaire imbriqué, accédez à cette réponse .

Utilisez la fonction defaultdict des collections.

Performances élevées: «si la clé n'est pas dans dict» est très coûteux lorsque le jeu de données est volumineux.

Faible maintenance: rend le code plus lisible et peut être facilement étendu.

from collections import defaultdict

target_dict = defaultdict(dict)
target_dict[key1][key2] = val

Pour des niveaux arbitraires d'imbrication:

In [2]: def nested_dict():
   ...:     return collections.defaultdict(nested_dict)
   ...:

In [3]: a = nested_dict()

In [4]: a
Out[4]: defaultdict(<function __main__.nested_dict>, {})

In [5]: a['a']['b']['c'] = 1

In [6]: a
Out[6]:
defaultdict(<function __main__.nested_dict>,
            {'a': defaultdict(<function __main__.nested_dict>,
                         {'b': defaultdict(<function __main__.nested_dict>,
                                      {'c': 1})})})

Il est important de se rappeler lors de l'utilisation de defaultdict et de modules dict imbriqués similaires tels que nested_dict, que la recherche d'une clé inexistante peut créer par inadvertance une nouvelle entrée de clé dans le dict et causer beaucoup de ravages.

Voici un exemple Python3 avec nested_dictmodule:

import nested_dict as nd
nest = nd.nested_dict()
nest['outer1']['inner1'] = 'v11'
nest['outer1']['inner2'] = 'v12'
print('original nested dict: \n', nest)
try:
    nest['outer1']['wrong_key1']
except KeyError as e:
    print('exception missing key', e)
print('nested dict after lookup with missing key.  no exception raised:\n', nest)

# Instead, convert back to normal dict...
nest_d = nest.to_dict(nest)
try:
    print('converted to normal dict. Trying to lookup Wrong_key2')
    nest_d['outer1']['wrong_key2']
except KeyError as e:
    print('exception missing key', e)
else:
    print(' no exception raised:\n')

# ...or use dict.keys to check if key in nested dict
print('checking with dict.keys')
print(list(nest['outer1'].keys()))
if 'wrong_key3' in list(nest.keys()):

    print('found wrong_key3')
else:
    print(' did not find wrong_key3')

La sortie est:

original nested dict:   {"outer1": {"inner2": "v12", "inner1": "v11"}}

nested dict after lookup with missing key.  no exception raised:  
{"outer1": {"wrong_key1": {}, "inner2": "v12", "inner1": "v11"}} 

converted to normal dict. 
Trying to lookup Wrong_key2 

exception missing key 'wrong_key2' 

checking with dict.keys 

['wrong_key1', 'inner2', 'inner1']  
did not find wrong_key3