给出一个以元组为键(而数字/标量为值)的字典,用Python方式转换为嵌套字典的方式是什么?问题在于从输入到输入,元组的长度是任意的。
下面的d1
,d2
和d3
展示了越来越多的嵌套:
from itertools import product
d1 = dict(zip(product('AB', [0, 1]), range(2*2)))
d2 = dict(zip(product('AB', [0, 1], [True, False]), range(2*2*2)))
d3 = dict(zip(product('CD', [0, 1], [True, False], 'AB'), range(2*2*2*2)))
它们的嵌套版本将是:
# For d1
{'A': {0: 0, 1: 1}, 'B': {0: 2, 1: 3}}
# For d2
{'A': {0: {True: 0, False: 1}, 1: {True: 2, False: 3}},
'B': {0: {True: 4, False: 5}, 1: {True: 6, False: 7}}}
# Beginning of result for d3
{
'C': {
0: {
True: {
'A': 0
'B': 1
},
False: {
'A': 2,
'B': 3
},
1: # ...
我的尝试:我喜欢这种用于初始化空数据结构的技巧,该结构在许多其他的SO答案中给出:
from collections import defaultdict
def nested_dict():
return defaultdict(nested_dict)
但是由于级别数不确定,因此难以实现。我可以使用类似的东西:
def nest(d: dict) -> dict:
res = nested_dict()
for (i, j, k), v in d.items():
res[i][j][k] = v
return res
但这仅对d2
有效,因为它的键在上面有3个层(i,j,k)。
这是我尝试将其推广的解决方案,但我想这里有一条更简单的路线。
def set_arbitrary_nest(keys, value):
"""
>>> keys = 1, 2, 3
>>> value = 5
result --> {1: {2: {3: 5}}}
"""
it = iter(keys)
last = next(it)
res = {last: {}}
lvl = res
while True:
try:
k = next(it)
lvl = lvl[last]
lvl[k] = {}
last = k
except StopIteration:
lvl[k] = value
return res
>>> set_arbitrary_nest([1, 2, 3], 5)
{1: {2: {3: 5}}}
答案 0 :(得分:2)
仅循环遍历每个键,并使用键的最后一个元素(除了键之外)添加字典。保留对如此设置的最后一个字典的引用,然后使用键元组中的最后一个元素在输出字典中实际设置一个键值对:
def nest(d: dict) -> dict:
result = {}
for key, value in d.items():
target = result
for k in key[:-1]: # traverse all keys but the last
target = target.setdefault(k, {})
target[key[-1]] = value
return result
您可以使用functools.reduce()
来处理字典的遍历工作:
from functools import reduce
def nest(d: dict) -> dict:
result = {}
traverse = lambda r, k: r.setdefault(k, {})
for key, value in d.items():
reduce(traverse, key[:-1], result)[key[-1]] = value
return result
我使用了dict.setdefault()
而不是自动执行defaultdict(nested_dict)
选项,因为这会生成一个常规字典,当它们不存在时,它不会进一步隐式添加键。
演示:
>>> from pprint import pprint
>>> pprint(nest(d1))
{'A': {0: 0, 1: 1}, 'B': {0: 2, 1: 3}}
>>> pprint(nest(d2))
{'A': {0: {False: 1, True: 0}, 1: {False: 3, True: 2}},
'B': {0: {False: 5, True: 4}, 1: {False: 7, True: 6}}}
>>> pprint(nest(d3))
{'C': {0: {False: {'A': 2, 'B': 3}, True: {'A': 0, 'B': 1}},
1: {False: {'A': 6, 'B': 7}, True: {'A': 4, 'B': 5}}},
'D': {0: {False: {'A': 10, 'B': 11}, True: {'A': 8, 'B': 9}},
1: {False: {'A': 14, 'B': 15}, True: {'A': 12, 'B': 13}}}}
请注意,上述解决方案是一个干净的O(N)循环(N是输入字典的长度),而Ajax1234提出的groupby解决方案必须对输入进行 sort 才能工作,使之成为O(NlogN)解决方案。这意味着对于具有1000个元素的字典,groupby()
将需要10.000步才能生成输出,而O(N)线性循环仅需1000步。对于一百万个键,这将增加到2000万步,等等。
此外,Python中的递归速度很慢,因为Python无法针对迭代方法优化此类解决方案。函数调用相对昂贵,因此使用递归会带来可观的性能成本,因为大大增加了函数调用的数量和扩展框架堆栈操作。
时间试用显示这有多重要;使用示例d3
并运行100k,我们很容易看到5倍的速度差:
>>> from timeit import timeit
>>> timeit('n(d)', 'from __main__ import create_nested_dict as n, d3; d=d3.items()', number=100_000)
8.210276518017054
>>> timeit('n(d)', 'from __main__ import nest as n, d3 as d', number=100_000)
1.6089267160277814
答案 1 :(得分:0)
您可以将itertools.groupby
用于递归:
from itertools import groupby
def create_nested_dict(d):
_c = [[a, [(c, d) for (_, *c), d in b]] for a, b in groupby(sorted(d, key=lambda x:x[0][0]), key=lambda x:x[0][0])]
return {a:b[0][-1] if not any([c for c, _ in b]) else create_nested_dict(b) for a, b in _c}
from itertools import product
d1 = dict(zip(product('AB', [0, 1]), range(2*2)))
d2 = dict(zip(product('AB', [0, 1], [True, False]), range(2*2*2)))
d3 = dict(zip(product('CD', [0, 1], [True, False], 'AB'), range(2*2*2*2)))
print(create_nested_dict(d1.items()))
print(create_nested_dict(d2.items()))
print(create_nested_dict(d3.items()))
输出:
{'A': {0: 0, 1: 1}, 'B': {0: 2, 1: 3}}
{'A': {0: {False: 1, True: 0}, 1: {False: 3, True: 2}}, 'B': {0: {False: 5, True: 4}, 1: {False: 7, True: 6}}}
{'C': {0: {False: {'A': 2, 'B': 3}, True: {'A': 0, 'B': 1}}, 1: {False: {'A': 6, 'B': 7}, True: {'A': 4, 'B': 5}}}, 'D': {0: {False: {'A': 10, 'B': 11}, True: {'A': 8, 'B': 9}}, 1: {False: {'A': 14, 'B': 15}, True: {'A': 12, 'B': 13}}}}