Question

关于翻译这本字典最简单的方法是什么：

{'item':{'w':{'c':1, 'd':2}, 'x':120, 'y':240, 'z':{'a':100, 'b':200}}}

进入这一个：

{'item':{'y':240, 'z':{'b':200}}}

只是在保持字典结构的同时需要变量y和b？项目的大小或数量或字典的深度应该无关紧要，因为我正在使用的那个可以是2到5级深度。

编辑：我为之前的类型道歉，为了澄清，我得到了一个字符串数组（例如['y'，'b']），我需要在字典中找到它然后只保留'y'和'b'以及任何其他键以保持原始字典的结构，在这种情况下，它将是'z'

可以找到一个更好的例子here我需要芯片组模型，VRAM和分辨率。

关于评论，输入将是作为起始字典的上述链接以及作为保持列表的['chipset model'，'vram'，'resolution']的数组。它应该返回：

{'Graphics/Displays':{'NVIDIA GeForce 7300 GT':{'Chipset Model':'NVIDIA GeForce 7300 GT', 'Displays':{'Resolution':'1440 x 900 @ 75 Hz'}, 'VRAM (Total)':'256 Mb'}}

Answer 1

假设您想要分配给超级词典元素的词典是foo，您可以这样做：

my_dictionary['keys']['to']['subdict']=foo

关于你的编辑 - 除了特定列表上的那些键之外你需要删除所有键 - 这个函数应该可以解决这个问题：

def drop_keys(recursive_dict,keep_list):
    key_list=recursive_dict.keys()
    for key in key_list:
        if(type(recursive_dict[key]) is dict):
            drop_keys(recursive_dict[key], keep_list)
        elif(key not in keep_list):
            del recursive_dict[key]

Answer 2

这样的东西？

d = {'item': {'w': {'c': 1, 'd': 2}, 'x': 120, 'y': 240, 'z': {'a': 100, 'b': 200}}}
l = ['y', 'z']
def do_dict(d, l):
    return {k: v for k, v in d['item'].items() if k in l}

Answer 3

这是我为递归解决方案所得到的，最终类似于@Dan发布的内容：

def recursive_del(d,keep):
    for k in d.copy():
        if type(d[k]) == dict:
            recursive_del(d[k],keep)
            if len(d[k]) == 0: #all keys were deleted, clean up empty dict
                del d[k]
        elif k not in keep:
            del d[k]

演示：

>>> keepset = {'y','b'}
>>> a = {'item':{'w':{'c':1, 'd':2}, 'x':120, 'y':240, 'z':{'a':100, 'b':200}}}
>>> recursive_del(a,keepset)
>>> a
{'item': {'z': {'b': 200}, 'y': 240}}

我认为他唯一遗漏的是你需要有时需要清理已删除所有密钥的词条;即，如果没有进行调整，您的示例输出中最终会出现残余'w':{}。

Answer 4

使用你的第二个例子我做了这样的事情，它不是很漂亮，但应该很容易扩展。如果你的树开始变大，你可以定义一些规则来解析字典。

这里的每条规则实际上都是“当我处于哪个州时应该怎么做”。

def rule2(key, value):
    if key == 'VRAM (Total)':
        return (key, value)
    elif key == 'Chipset Model':
        return (key, value)

def rule1(key, value):
    if key == "Graphics/Displays":
        if isinstance(value, dict):
            return (key, recursive_checker(value, rule1))
        else:
            return (key, value)
    else:
        return (key, recursive_checker(value, rule2))

def recursive_checker(dat, rule):

    def inner(item):
        key = item[0]
        value = item[1]

        return rule(key, value)

    return dict(filter(lambda x: x!= None, map(inner, dat.items())))

# Important bits    
print recursive_checker(data, rule1)

在你的情况下，由于状态不是很多，所以不值得这样做但是如果你有多张牌并且你不必知道应该遍历哪个键但只知道你想要某些键来自树。此方法可用于轻松搜索树。它可以应用于很多东西。

python中的递归字典修改

4 个答案: