展平列表的字典字典（2 级深）

Question

我正在努力解决这个问题，但它不够灵活。

在我的 Python 脚本中，我有一个列表字典。 （实际上它变得更深了，但这个问题不涉及这个级别。）我想把所有这些都压缩成一个长列表，扔掉所有的字典键。

所以我想变身

{1: {'a': [1, 2, 3], 'b': [0]},
 2: {'c': [4, 5, 1], 'd': [3, 8]}}

到

[1, 2, 3, 0, 4, 5, 1, 3, 8]

我可能会设置一个 map-reduce 来迭代外部字典的项目，以从每个子字典构建一个子列表，然后将所有子列表连接在一起。

但这对于大型数据集来说似乎效率低下，因为中间数据结构（子列表）会被丢弃。有没有办法一次性完成？

除此之外，我很乐意接受一个有效的两级实现......我的 map-reduce 生锈了！

更新： 对于那些感兴趣的人，下面是我最终使用的代码。

请注意，尽管我在上面要求一个列表作为输出，但我真正需要的是一个排序列表；即展平的输出可以是任何可以排序的迭代。

def genSessions(d):
    """Given the ipDict, return an iterator that provides all the sessions,
    one by one, converted to tuples."""
    for uaDict in d.itervalues():
        for sessions in uaDict.itervalues():
            for session in sessions:
                yield tuple(session)

...

# Flatten dict of dicts of lists of sessions into a list of sessions.
# Sort that list by start time
sessionsByStartTime = sorted(genSessions(ipDict), key=operator.itemgetter(0))
# Then make another copy sorted by end time.
sessionsByEndTime = sorted(sessionsByStartTime, key=operator.itemgetter(1))

再次感谢所有提供帮助的人。

[更新：将nthGetter() 替换为operator.itemgetter()，感谢@intuited。]

Answer 1

我希望你意识到你在字典中看到的任何顺序都是偶然的——它的存在只是因为当屏幕上显示时，必须选择一些顺序，但绝对不能保证。

各个子列表之间的排序问题得到连接，

[x for d in thedict.itervalues()
   for alist in d.itervalues()
   for x in alist]

做你想做的事，没有任何低效或中间列表。

Answer 2

编辑：重新阅读原始问题并修改答案以假设所有非字典都是要展平的列表。

如果您不确定字典的深度，您可能需要使用递归函数。 @Arrieta 已经有 posted 一个递归构建非字典值列表的函数。

这是一个生成器，在字典树中产生连续的非字典值：

def flatten(d):
    """Recursively flatten dictionary values in `d`.

    >>> hat = {'cat': ['images/cat-in-the-hat.png'],
    ...        'fish': {'colours': {'red': [0xFF0000], 'blue': [0x0000FF]},
    ...                 'numbers': {'one': [1], 'two': [2]}},
    ...        'food': {'eggs': {'green': [0x00FF00]},
    ...                 'ham': ['lean', 'medium', 'fat']}}
    >>> set_of_values = set(flatten(hat))
    >>> sorted(set_of_values)
    [1, 2, 255, 65280, 16711680, 'fat', 'images/cat-in-the-hat.png', 'lean', 'medium']
    """
    try:
        for v in d.itervalues():
            for nested_v in flatten(v):
                yield nested_v
    except AttributeError:
        for list_v in d:
            yield list_v

doctest 将生成的迭代器传递给set 函数。这很可能是您想要的，因为正如 Martelli 先生指出的那样，字典的值没有内在的顺序，因此没有理由跟踪它们被发现的顺序。

您可能希望跟踪每个值的出现次数；如果您将迭代器传递给set，此信息将丢失。如果你想跟踪它，只需将flatten(hat) 的结果传递给其他函数而不是set。在 Python 2.7 下，其他函数可能是 collections.Counter。为了与进化较少的 python 兼容，您可以编写自己的函数或（在效率上有所损失）将 sorted 与 itertools.groupby 结合起来。

Answer 3

递归函数可能会起作用：

def flat(d, out=[]):
 for val in d.values():
  if isinstance(val, dict):
    flat(d, out)
  else:
    out+= val

如果您尝试使用：

>>> d = {1: {'a': [1, 2, 3], 'b': [0]}, 2: {'c': [4, 5, 6], 'd': [3, 8]}}
>>> out = []
>>> flat(d, out)
>>> print out
[1, 2, 3, 0, 4, 5, 6, 3, 8]

注意字典没有顺序，所以列表是随机顺序的。

您也可以return out（在循环结束时）并且不要使用列表参数调用该函数。

def flat(d, out=[]):
 for val in d.values():
  if isinstance(val, dict):
    flat(d, out)
  else:
    out+= val
 return out

调用为：

my_list = flat(d)