python中嵌套字典的列表

我有一份清单如下

['item1', 'item2', 'item3', 'item4']

{
    "item1": {
        "item2": {
            "item3": "item4"
        }
    }
}

我想从上面的列表中构造一个字典，如下所示

['item1', 'item2', 'item3', 'item4']

{
    "item1": {
        "item2": {
            "item3": "item4"
        }
    }
}

列表中的项目数是动态的。在到达列表的最后一个元素之前，字典将是嵌套字典。 python中有什么方法可以做到这一点吗？

使用递归：

In [10]: src = ['item1', 'item2', 'item3','item4']

In [11]: def list2dict(src_list):
    if len(src_list) > 1:
        return {src_list[0] : list2dict(src_list[1:])}
    else:
        return src_list[0]
   ....:     

In [12]: 

In [12]: list2dict(src)
Out[12]: {'item1': {'item2': {'item3': 'item4'}}}

使用访问和设置元素：

try:
    # Python 3 moved reduce to the functools module
    from functools import reduce
except ImportError:
    # Python 2 reduce is a built-in
    pass

def get_target(d, keys):
    return reduce(lambda d, k: d.setdefault(k, {}), keys, d)

def set_target(d, keys, value):
    parent = get_target(d, keys[:-1])
    parent[keys[-1]] = value

result = {}
set_target(result, yourlist[:-1], yourlist[-1])

get\u target（）

和

set\u target（）

函数可在已构建的嵌套结构上重复使用，它们不限于从头构建字典。我从一个数据库中修改了

get_target（）

演示：

简单一行：

a = ['item1', 'item2', 'item3','item4']
print reduce(lambda x, y: {y: x}, reversed(a))

为了更好地理解上述代码，可以将其扩展为：

def nest_me(x, y):
    """
    Take two arguments and return a one element dict with first
    argument as a value and second as a key
    """
    return {y: x}

a = ['item1', 'item2', 'item3','item4']
rev_a = reversed(a) # ['item4', 'item3', 'item2','item1']
print reduce(
    nest_me, # Function applied until the list is reduced to one element list
    rev_a # Iterable to be reduced
)
# {'item1': {'item2': {'item3': 'item4'}}}

---

遗憾的是，@thefourtheye删除了他的答案-虽然这个解决方案更自然，但我必须说他的优点是消除了切片开销-这具有O（n！）的复杂性，他又是O（n）-这个解决方案具有复杂性的优点-递归是O（n！），一个是O（n）@martijn

set_target

在这种情况下会中断，因为它不会替换已分配的原语键@尼希米：那是因为你在这里混合树叶和树枝

a->b->c

引用一个叶节点（

hello

），因此不能将

c

转换为分支节点（其中

c

引用另一个字典）。在那里打电话，只是为了替换

c

，这是您需要为自己的用例做出的决定。您不能假设这里的冲突不是应用程序逻辑中的错误。@MartijnPieters将其保持为通用是最好的选择。对于dict/Hashmap来说，重写同一dict键上的数据是完全正确的行为。在经历了无数的场景之后，我不得不实现这个实现。以下是相关的详细答案：