Marche/itération sur un imbriquée dictionnaire de profondeur arbitraire (le dictionnaire représente une arborescence de répertoires)

C'est un préliminaire du code. Aller à travers elle et dites-moi où vous confrontés à des problèmes.

Parents={ -1:"Root"}
def add_dir(level, parent, index, k):
    print "Directory"
    print "Level=%d, Parent=%s, Index=%d, value=%s" % (level, Parents[parent], index, k)
def add_file(parent, index, k):
    print "File"
    print "Parent=%s, Index=%d, value=%s" %  (Parents[parent], index, k)
def f(level=0, parent=-1, index=0, di={}):
    for k in di:
        index +=1
        if di[k]:
            Parents[index]=k
            add_dir(level, parent, index, k)
            f(level+1, index, index, di[k])
        else:
            add_file(parent, index, k)

a={
    'SomeRootDirectory': {
        'foo.txt': None,
        'bar.txt': None,
        'Stories': {
            'Horror': {
                'rickscott.txt' : None,
                'Trash' : {
                    'notscary.txt' : None,
                    },
                },
            'Cyberpunk' : None
            },
        'Poems' : {
            'doyoureadme.txt' : None
        }
    }
}

f(di=a)

OriginalL'auteur spicavigo

Je réalise que c'est une vieille question, mais je viens de regarder pour une solution simple, propre façon de marcher imbriquée dicts et c'est la chose la plus proche que mon peu de recherche a trouvé. oadams réponse n'est pas assez utile si vous voulez plus que juste les noms de fichiers et spicavigo la réponse semble compliqué.

J'ai fini juste de lancer mon propre que des actes semblables à comment os.pied traite répertoires, sauf qu'il retourne toutes les clés/valeur de l'information.

Il retourne un itérateur et pour chaque répertoire dans l'arborescence de imbriquée dicts, renvoie l'itérateur (chemin, sous-dicts, valeurs) où:

• path est le chemin d'accès à la dict
• sous-dicts est un n-uplet (clé,dict) paires pour chaque sous-dict en ce dict
• valeurs est un n-uplet (clé,valeur) paires pour chaque (non-dict) de l'élément dans ce dict

def walk(d):
    '''
    Walk a tree (nested dicts).

    For each 'path', or dict, in the tree, returns a 3-tuple containing:
    (path, sub-dicts, values)

    where:
    * path is the path to the dict
    * sub-dicts is a tuple of (key,dict) pairs for each sub-dict in this dict
    * values is a tuple of (key,value) pairs for each (non-dict) item in this dict
    '''
    # nested dict keys
    nested_keys = tuple(k for k in d.keys() if isinstance(d[k],dict))
    # key/value pairs for non-dicts
    items = tuple((k,d[k]) for k in d.keys() if k not in nested_keys)

    # return path, key/sub-dict pairs, and key/value pairs
    yield ('/', [(k,d[k]) for k in nested_keys], items)

    # recurse each subdict
    for k in nested_keys:
        for res in walk(d[k]):
            # for each result, stick key in path and pass on
            res = ('/%s' % k + res[0], res[1], res[2])
            yield res

Voici le code que j'ai utilisé pour le tester, si elle a un couple d'autres indépendants (mais joli) des choses:

import simplejson as json
from collections import defaultdict
# see https://gist.github.com/2012250
tree = lambda: defaultdict(tree)
def walk(d):
'''
Walk a tree (nested dicts).
For each 'path', or dict, in the tree, returns a 3-tuple containing:
(path, sub-dicts, values)
where:
* path is the path to the dict
* sub-dicts is a tuple of (key,dict) pairs for each sub-dict in this dict
* values is a tuple of (key,value) pairs for each (non-dict) item in this dict
'''
# nested dict keys
nested_keys = tuple(k for k in d.keys() if isinstance(d[k],dict))
# key/value pairs for non-dicts
items = tuple((k,d[k]) for k in d.keys() if k not in nested_keys)
# return path, key/sub-dict pairs, and key/value pairs
yield ('/', [(k,d[k]) for k in nested_keys], items)
# recurse each subdict
for k in nested_keys:
for res in walk(d[k]):
# for each result, stick key in path and pass on
res = ('/%s' % k + res[0], res[1], res[2])
yield res
# use fancy tree to store arbitrary nested paths/values
mem = tree()
root = mem['SomeRootDirectory']
root['foo.txt'] = None
root['bar.txt'] = None
root['Stories']['Horror']['rickscott.txt'] = None
root['Stories']['Horror']['Trash']['notscary.txt'] = None
root['Stories']['Cyberpunk']
root['Poems']['doyoureadme.txt'] = None
# convert to json string
s = json.dumps(mem, indent=2)
#print mem
print s
print
# json.loads converts to nested dicts, need to walk them
for (path, dicts, items) in walk(json.loads(s)):
# this will print every path
print '[%s]' % path
for key,val in items:
# this will print every key,value pair (skips empty paths)
print '%s = %s' % (path+key,val)
print

La sortie ressemble à ceci:

{
"SomeRootDirectory": {
"foo.txt": null,
"Stories": {
"Horror": {
"rickscott.txt": null,
"Trash": {
"notscary.txt": null
}
},
"Cyberpunk": {}
},
"Poems": {
"doyoureadme.txt": null
},
"bar.txt": null
}
}
[/]
[/SomeRootDirectory/]
/SomeRootDirectory/foo.txt = None
/SomeRootDirectory/bar.txt = None
[/SomeRootDirectory/Stories/]
[/SomeRootDirectory/Stories/Horror/]
/SomeRootDirectory/Stories/Horror/rickscott.txt = None
[/SomeRootDirectory/Stories/Horror/Trash/]
/SomeRootDirectory/Stories/Horror/Trash/notscary.txt = None
[/SomeRootDirectory/Stories/Cyberpunk/]
[/SomeRootDirectory/Poems/]
/SomeRootDirectory/Poems/doyoureadme.txt = None

OriginalL'auteur bj0

Vous pouvez marcher un imbriquée dictionnaire en utilisant la récursivité

def walk_dict(dictionary):
for key in dictionary:
if isinstance(dictionary[key], dict):
walk_dict(dictionary[key])
else:
#do something with dictionary[k]
pass

Espère que cela aide 🙂

OriginalL'auteur FintanH