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

我最有意义的是将这个问题分成两部分（好吧，我第一次误解了这个问题......'）

转化

第一部分将[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):

到

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

你也可以让它适用于任何迭代，但这需要一点点重组。

合并

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

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)

Python：将几个嵌套列表组合到一个字典中

3 个答案:

转化

合并