遍历嵌套字典的意外层

Question

So my situation is as follows. I have a dictionary (shown below) of which I want to iterate through potentially large numbers of iterations, without having to manually define 'for i in dictionary[x][y][...]'. I intend to iterate through each layer and create a large string of html for other purposes. For my dictionary there are potentially unknown amounts of subfolders and files, which is currently making it very hard to iterate through.

This is my dictionary

{'A Folder': {
    'Another Folder': {
         'Stacked_File': 'secretid'
         'Another Stacked_File': 'anothersecretid'
    }

}, 'Another File':'moreids'...
}

Which I hope to convert to...

<ul>
    <ul>
        <i class="fi-folder"></i>&nbsp;&nbsp;A_Folder
    </ul>

    <br>

    <ul>
        <i class="fi-folder"></i>&nbsp;&nbsp;Another_Folder
        <ul>
            <ul>
                <i class="fi-folder"></i>&nbsp;&nbsp;Folder_Stacked
                <ul>
                    <ul><i class="fi-page"></i>&nbsp;&nbsp;Stacked_File
                    <ul><i class="fi-page"></i>&nbsp;&nbsp;Another_Stacked_File
                </ul>
            </ul>
        </ul>
    </ul>

How would I go about doing this?

Answer 1

Since you're looking at filesystems, if you're running this code on the system where the filesystem resides, you could handle it with recursion using os.listdir() and os.path.isdir(). Here's a basic example:

def iter_folder(folder):
    if not os.path.isdir(folder):
        return
    print "folder: " + folder
    for item in os.listdir(folder):
        if os.path.isdir(item):
            iter_folder(item)
        else:
            print "file: " + item

Answer 2

It's hard for me to tell what you are actually trying to do with the output, but using recursion to flatten the nested dictionary is one good possibility:

d = {'A Folder': {
    'Another Folder': {
         'Stacked_File': 'secretid',
         'Another Stacked_File': 'anothersecretid'
    }

}, 'Another File':'moreids'
}

def nested_dict_flattener(d, level=0):
    l = []
    for k,v in d.items():
        if isinstance(v, basestring):
            l.append((level, k, v))
        elif isinstance(v, dict):
            l.append((level, k, 'START-FOLDER'))
            l.extend(nested_dict_flattener(v, level+1))
            l.append((level, k, 'END-FOLDER'))
    return l

import pprint
pprint.pprint( nested_dict_flattener(d) )

Output:

[(0, 'A Folder', 'START-FOLDER'),
 (1, 'Another Folder', 'START-FOLDER'),
 (2, 'Stacked_File', 'secretid'),
 (2, 'Another Stacked_File', 'anothersecretid'),
 (1, 'Another Folder', 'END-FOLDER'),
 (0, 'A Folder', 'END-FOLDER'),
 (0, 'Another File', 'moreids')]

Notice what's going on here: your nested dict s have been converted to a flat list of tuple s. You could then iterate through this list and look for the START-FOLDER / END-FOLDER markers to decide when to output opening and closing <ul> tags.