Python：将多个嵌套列表组合成一个字典

Question

我有一堆类似以下两个的列表：

['a', ['b', ['x', '1'], ['y', '2']]]
['a', ['c', ['xx', '4'], ['gg', ['m', '3']]]]

将所有这些列表组合成一个字典的最简单方法是什么，如下所示：

{'a': {
    'b': {
        'x':1,
        'y':2
    }
    'c': {
        'xx':4,
        'gg': {
            'm':3
        }
    }
}

嵌套的深度是可变的。

Answer 1

这是一个非常粗略的实现，它不处理奇怪的情况，例如少于两个元素的列表，并且它会覆盖重复的键，但它可以帮助您开始：

l1 = ['a', ['b', ['x', '1'], ['y', '2']]]
l2 = ['a', ['c', ['xx', '4'], ['gg', ['m', '3']]]]

def combine(d, l):
    if not l[0] in d:
        d[l[0]] = {}

    for v in l[1:]:
        if type(v) == list:
            combine(d[l[0]],v)
        else:
            d[l[0]] = v

h = {}
combine(h, l1)
combine(h, l2)
print h

输出：

{'a': {'c': {'gg': {'m': '3'}, 'xx': '4'}, 'b': {'y': '2', 'x': '1'}}}

Answer 2

这并不是真正的“Pythonic”，但我没有找到一种无需递归即可做到这一点的好方法

def listToDict(l):
    if type(l) != type([]): return l
    return {l[0] : listToDict(l[1])}

Answer 3

对我来说，将这个问题分成两部分是最有意义的（好吧，我第一次通过......'S读错了这个问题）

转换

第一部分转换[key, list1, list2] 数据结构嵌套字典：

def recdict(elements):
    """Create recursive dictionaries from [k, v1, v2, ...] lists.

    >>> import pprint, functools
    >>> pprint = functools.partial(pprint.pprint, width=2)
    >>> pprint(recdict(['a', ['b', ['x', '1'], ['y', '2']]]))
    {'a': {'b': {'x': '1',
                 'y': '2'}}}
    >>> pprint(recdict(['a', ['c', ['xx', '4'], ['gg', ['m', '3']]]]))
    {'a': {'c': {'gg': {'m': '3'},
                 'xx': '4'}}}
    """

    def rec(item):
        if isinstance(item[1], list):
            return [item[0], dict(rec(e) for e in item[1:])]

        return item

    return dict([rec(elements)])

要求

• 每个列表至少有两个元素，
• 每个列表的第一个元素是键，
• 如果列表的第二个元素是列表，则所有后续元素也是列表；这些被组合成一本字典。

棘手的一点（至少对我来说）是意识到你必须从递归函数返回一个列表而不是字典。否则，您无法组合形成某些列表的第二个和第三个元素的并行列表。

为了使其更普遍有用（即对于元组和其他序列），我将更改为

if isinstance(item[1], list):

You

if (isinstance(item[1], collections.Sequence)
    and not isinstance(item[1], basestring)):

can also make it work for any iterable 但这需要一点重组。

合并

第二部分合并在两个给定数据结构上运行第一个例程所产生的字典。我认为这将递归地合并任意数量的没有冲突键的字典，尽管除了这个用例之外我没有真正测试它。

def mergedicts(*dicts):
    """Recursively merge an arbitrary number of dictionaries.
    >>> import pprint
    >>> d1 = {'a': {'b': {'x': '1',
    ...                   'y': '2'}}}
    >>> d2 = {'a': {'c': {'gg': {'m': '3'},
    ...                   'xx': '4'}}}
    >>> pprint.pprint(mergedicts(d1, d2), width=2)
    {'a': {'b': {'x': '1',
                 'y': '2'},
           'c': {'gg': {'m': '3'},
                 'xx': '4'}}}
    """

    keys = set(k for d in dicts for k in d)

    def vals(key):
        """Returns all values for `key` in all `dicts`."""
        withkey = (d for d in dicts if d.has_key(key))
        return [d[key] for d in withkey]

    def recurse(*values):
        """Recurse if the values are dictionaries."""
        if isinstance(values[0], dict):
            return mergedicts(*values)
        if len(values) == 1:
            return values[0]
        raise TypeError("Multiple non-dictionary values for a key.")

    return dict((key, recurse(*vals(key))) for key in keys)