给定索引和值列表，在嵌套的 Python 字典中设置一个值

Question

我正在尝试以编程方式在字典中设置一个值，可能是嵌套的，给定一个索引列表和一个值。

因此，例如，假设我的索引列表是：

['person', 'address', 'city']

价值是

'New York'

结果我想要一本字典 object，例如：

{ 'Person': { 'address': { 'city': 'New York' } }

基本上，该列表表示进入嵌套字典的“路径”。

我想我可以自己构建字典，但我遇到的问题是如何设置值。 显然，如果我只是手动为此编写代码，那将是：

dict['Person']['address']['city'] = 'New York'

但是，如果我只有索引和值的列表，我该如何索引到字典中并以编程方式设置值呢？

Python

Answer 1

这样的事情可能会有所帮助：

def nested_set(dic, keys, value):
    for key in keys[:-1]:
        dic = dic.setdefault(key, {})
    dic[keys[-1]] = value

你可以像这样使用它：

>>> d = {}
>>> nested_set(d, ['person', 'address', 'city'], 'New York')
>>> d
{'person': {'address': {'city': 'New York'}}}

Answer 2

我从Bakuriu 的回答中自由地扩展了代码。 因此，对此的支持是可选的，因为他的代码本身就是一个机智的解决方案，这是我没想到的。

def nested_set(dic, keys, value, create_missing=True):
    d = dic
    for key in keys[:-1]:
        if key in d:
            d = d[key]
        elif create_missing:
            d = d.setdefault(key, {})
        else:
            return dic
    if keys[-1] in d or create_missing:
        d[keys[-1]] = value
    return dic

将create_missing设置为 True 时，您确保仅设置已存在的值：

# Trying to set a value of a nonexistent key DOES NOT create a new value
print(nested_set({"A": {"B": 1}}, ["A", "8"], 2, False))
>>> {'A': {'B': 1}}

# Trying to set a value of an existent key DOES create a new value
print(nested_set({"A": {"B": 1}}, ["A", "8"], 2, True))
>>> {'A': {'B': 1, '8': 2}}

# Set the value of an existing key
print(nested_set({"A": {"B": 1}}, ["A", "B"], 2))
>>> {'A': {'B': 2}}

Answer 3

首先，您可能想查看setdefault 。

作为一个函数，我会把它写成

def get_leaf_dict( dict, key_list):
    res=dict
    for key in key_list:
        res=dict.setdefault( key, {} )
    return res

这将用作：

get_leaf_dict( dict, ['Person', 'address', 'city']) = 'New York'

这可以通过错误处理等来清理。 同样使用*args而不是单个键列表参数可能会很好； 但我们的想法是您可以迭代键，在每个级别拉出适当的字典。

Answer 4

这是另一种选择：

from collections import defaultdict
recursivedict = lambda: defaultdict(recursivedict)
mydict = recursivedict()

我最初是从这里得到的： 设置嵌套的字典值并创建中间键。

如果你问我，它非常聪明和优雅。

Answer 5

这是我的简单解决方案：只需编写

terms = ['person', 'address', 'city'] 
result = nested_dict(3, str)
result[terms] = 'New York'  # as easy as it can be

你甚至可以这样做：

terms = ['John', 'Tinkoff', '1094535332']  # account in Tinkoff Bank
result = nested_dict(3, float)
result[terms] += 2375.30

现在后台：

from collections import defaultdict


class nesteddict(defaultdict):
    def __getitem__(self, key):
        if isinstance(key, list):
            d = self
            for i in key:
                d = defaultdict.__getitem__(d, i)
            return d
        else:
            return defaultdict.__getitem__(self, key)
    def __setitem__(self, key, value):
        if isinstance(key, list):
            d = self[key[:-1]]
            defaultdict.__setitem__(d, key[-1], value)
        else:
            defaultdict.__setitem__(self, key, value)


def nested_dict(n, type):
    if n == 1:
        return nesteddict(type)
    else:
        return nesteddict(lambda: nested_dict(n-1, type))

Answer 6

这是Bakuriu 答案的一个变体，它不依赖于单独的函数：

keys = ['Person', 'address', 'city']
value = 'New York'

nested_dict = {}

# Build nested dictionary up until 2nd to last key
# (Effectively nested_dict['Person']['address'] = {})
sub_dict = nested_dict
for key_ind, key in enumerate(keys[:-1]):
    if not key_ind:
        # Point to newly added piece of dictionary
        sub_dict = nested_dict.setdefault(key, {})
    else:
        # Point to newly added piece of sub-dictionary
        # that is also added to original dictionary
        sub_dict = sub_dict.setdefault(key, {})
# Add value to last key of nested structure of keys
# (Effectively nested_dict['Person']['address']['city'] = value)
sub_dict[keys[-1]] = value

print(nested_dict)

>>> {'Person': {'address': {'city': 'New York'}}}

Answer 7

Python 3 的dotty_dict库可以做到这一点。 请参阅文档Dotty Dict以获得更清晰的信息。

from dotty_dict import dotty

dot = dotty()
string = '.'.join(['person', 'address', 'city'])
dot[string] = 'New York'

print(dot)

输出：

{'person': {'address': {'city': 'New York'}}}

Answer 8

使用这对方法

def gattr(d, *attrs):
    """
    This method receives a dict and list of attributes to return the innermost value of the give dict
    """
    try:
        for at in attrs:
            d = d[at]
        return d
    except:
        return None


def sattr(d, *attrs):
    """
    Adds "val" to dict in the hierarchy mentioned via *attrs
    For ex:
    sattr(animals, "cat", "leg","fingers", 4) is equivalent to animals["cat"]["leg"]["fingers"]=4
    This method creates necessary objects until it reaches the final depth
    This behaviour is also known as autovivification and plenty of implementation are around
    This implementation addresses the corner case of replacing existing primitives
    https://gist.github.com/hrldcpr/2012250#gistcomment-1779319
    """
    for attr in attrs[:-2]:
        # If such key is not found or the value is primitive supply an empty dict
        if d.get(attr) is None or isinstance(d.get(attr), dict):
            d[attr] = {}
        d = d[attr]
    d[attrs[-2]] = attrs[-1]

Answer 9

这是递归 function 的一个很好的用例。所以你可以这样做：

def parse(l: list, v: str) -> dict:
    copy = dict()
    k, *s = l
    if len(s) > 0:
        copy[k] = parse(s, v)
    else:
        copy[k] = v
    return copy

这有效地弹出了传递列表l的第一个值作为我们初始化的 dict copy的键，然后通过相同的 function 运行剩余列表，在该键下创建一个新键，直到列表中没有任何内容，于是它将最后一个值分配给v参数。

Answer 10

这在 Perl 中要容易得多：

my %hash;
$hash{"aaa"}{"bbb"}{"ccc"}=1;  # auto creates each of the intermediate levels
                               # of the hash (aka: dict or associated array)