Python中的多字典

我有一本多功能词典：

{'a': {'b': {'c': {'d': '2'}}},
 'b': {'b': {'c': {'d': '7'}}},
 'c': {'b': {'c': {'d': '3'}}},
 'f': {'d': {'c': {'d': '1'}}}}

如何根据值“2”“3”“7”“1”对其进行排序 因此，我的输出将是：

f.d.c.d.1
a.b.c.d.2
c.b.c.d.3
b.b.c.d.7

---

您可以递归地执行此操作：

d = {'a': {'b': {'c': {'d': '2'}}}, 'c': {'b': {'c': {'d': '3'}}}, 'b': {'b': {'c': {'d': '7'}}}, 'f': {'d': {'c': {'d': '1'}}}}

def nested_to_string(item):

    if hasattr(item, 'items'):
        out = ''
        for key in item.keys():
            out += '%s.' % key + nested_to_string(item[key])
        return out
    else:
        return item + '\n'

print nested_to_string(d)

或

---

为什么要这样做。

您有一个固定的形状结构，排序非常简单：

>>> d = {'a': {'b': {'c': {'d': '2'}}}, 'c': {'b': {'c': {'d': '3'}}}, 'b': {'b': {'c': {'d': '7'}}}, 'f': {'d': {'c': {'d': '1'}}}}
>>> sorted(d, key=lambda x: d[x].values()[0].values()[0].values()[0])
['f', 'a', 'c', 'b']
>>> sorted(d.items(), key=lambda x: x[1].values()[0].values()[0].values()[0])
[('f', {'d': {'c': {'d': '1'}}}),
 ('a', {'b': {'c': {'d': '2'}}}),
 ('c', {'b': {'c': {'d': '3'}}}),
 ('b', {'b': {'c': {'d': '7'}}})]

是的，这有点丑陋和笨拙，但这只是因为你的结构天生丑陋和笨拙

事实上，除了d['f']有一个键“d”而不是“b”之外，它更简单。我怀疑这可能是一个打字错误，在这种情况下，事情就更容易了：

>>> d = {'a': {'b': {'c': {'d': '2'}}}, 'c': {'b': {'c': {'d': '3'}}}, 'b': {'b': {'c': {'d': '7'}}}, 'f': {'b': {'c': {'d': '1'}}}}
>>> sorted(d.items(), key=lambda x:x[1]['b']['c']['d'])
[('f', {'b': {'c': {'d': '1'}}}),
 ('a', {'b': {'c': {'d': '2'}}}),
 ('c', {'b': {'c': {'d': '3'}}}),
 ('b', {'b': {'c': {'d': '7'}}})]

正如其他人所指出的，无论您试图做什么，这几乎肯定不是正确的数据结构。但是，如果是的话，这就是如何处理它

---

顺便说一句，把它称为多字典是很混乱的。该术语通常意味着每个键可能有多个值的字典，在Python中，您可能会将其实现为默认值为list或set的defaultdict。恰好包含字典的单值字典最好命名为嵌套字典。

在我看来，这种设计很难阅读和维护。你能考虑用字符串名称替换内部字典吗？ 例如：

这本书更容易分类，也更容易阅读

现在，由于字典的性质，它是不可排序的。因此，您必须对其进行排序，例如列表表示：

my_sorted_dict_as_list = sorted(mydict.items(), 
                                key=lambda kv_pair: kv_pair[1])

---

您的数据结构基本上是一个多级树，因此，要实现您想要的功能，一个好方法是对其进行所谓的深度优先遍历（可以递归地进行遍历），然后稍微调整中间结果，将其排序并格式化为所需的格式

multidict = {'a': {'b': {'c': {'d': '2'}}},
             'b': {'b': {'c': {'d': '7'}}},
             'c': {'b': {'c': {'d': '3'}}},
             'f': {'d': {'c': {'d': '1'}}}}

def nested_dict_to_string(nested_dict):
    chains = []
    for key,value in nested_dict.items():
        chains.append([key] + visit(value))
    chains = ['.'.join(chain) for chain in sorted(chains, key=lambda chain: chain[-1])]
    return '\n'.join(chains)

def visit(node):
    result = []
    try:
        for key,value in node.items():
            result += [key] + visit(value)
    except AttributeError:
        result = [node]
    return result

print nested_dict_to_string(multidict)

输出：

f、 d.c.d.1 a、 b.c.d.2 c、 b.c.d.3 b、 公元前7年

---

你为什么不用f.d.c.d.和a.b.c.d.等作为钥匙呢？筑巢有什么意义？你试过什么？你是怎么得到这么复杂的结构的？你需要弄清楚你到底是什么…嗨，我试过了，但没用。。+：“dict”和“str”的操作数类型不受支持

my_sorted_dict_as_list = sorted(mydict.items(), 
                                key=lambda kv_pair: kv_pair[1])

multidict = {'a': {'b': {'c': {'d': '2'}}},
             'b': {'b': {'c': {'d': '7'}}},
             'c': {'b': {'c': {'d': '3'}}},
             'f': {'d': {'c': {'d': '1'}}}}

def nested_dict_to_string(nested_dict):
    chains = []
    for key,value in nested_dict.items():
        chains.append([key] + visit(value))
    chains = ['.'.join(chain) for chain in sorted(chains, key=lambda chain: chain[-1])]
    return '\n'.join(chains)

def visit(node):
    result = []
    try:
        for key,value in node.items():
            result += [key] + visit(value)
    except AttributeError:
        result = [node]
    return result

print nested_dict_to_string(multidict)