Pylab提供了一个flatten: 链接到numpy flatten

性能结果。修改。

import itertools
def itertools_flatten( aList ):
    return list( itertools.chain(*aList) )

from operator import add
def reduce_flatten1( aList ):
    return reduce(add, map(lambda x: list(x), [mi for mi in aList]))

def reduce_flatten2( aList ):
    return reduce(list.__add__, map(list, aList))

def comprehension_flatten( aList ):
    return list(y for x in aList for y in x)

我将一个包含30个道具的2级列表平铺了1000次

itertools_flatten     0.00554
comprehension_flatten 0.00815
reduce_flatten2       0.01103
reduce_flatten1       0.01404

减少总是一个糟糕的选择。

如果您只是希望迭代一个扁平的数据结构版本，并且不需要可索引序列，请考虑itertools。连锁店和公司。

>>> list_of_menuitems = [['image00', 'image01'], ['image10'], []]
>>> import itertools
>>> chain = itertools.chain(*list_of_menuitems)
>>> print(list(chain))
['image00', 'image01', 'image10']

它可以在任何可迭代的东西上工作，其中应该包括Django的可迭代QuerySets，它似乎是你在问题中使用的。

编辑:无论如何，这可能和reduce一样好，因为reduce将有相同的开销将项复制到正在扩展的列表中。如果你在最后运行list(Chain)， Chain只会引起这种(相同的)开销。

Meta-Edit:实际上，它的开销比问题提出的解决方案要少，因为当您使用临时列表扩展原始列表时，会丢弃您创建的临时列表。

编辑:正如J.F.塞巴斯蒂安说itertools.chain.from_iterable避免解包，你应该使用它来避免*魔术，但timeit应用程序显示可以忽略的性能差异。

Sum (list_of_lists，[])将使它变平。

l = [['image00', 'image01'], ['image10'], []]
print sum(l,[]) # prints ['image00', 'image01', 'image10']

似乎与operator.add!当你将两个列表相加时，正确的术语是concat，而不是add. operator。你需要使用Concat。

如果你考虑的是功能性的，它就像这样简单:

>>> from functools import reduce
>>> import operator
>>> list2d = ((1,2,3),(4,5,6), (7,), (8,9))
>>> reduce(operator.concat, list2d)
(1, 2, 3, 4, 5, 6, 7, 8, 9)

你看，reduce尊重序列类型，所以当你提供一个元组时，你得到一个元组。让我们尝试一个列表::

>>> list2d = [[1,2,3],[4,5,6], [7], [8,9]]
>>> reduce(operator.concat, list2d)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

啊哈，你会得到一个列表。

性能如何?

>>> list2d = [[1,2,3],[4,5,6], [7], [8,9]]
>>> %timeit list(itertools.chain.from_iterable(list2d))
1000000 loops, best of 3: 1.36 µs per loop

From_iterable非常快!但是reduce和concat并不是一个可比性。

>>> list2d = ((1,2,3),(4,5,6), (7,), (8,9))
>>> %timeit reduce(operator.concat, list2d)
1000000 loops, best of 3: 492 ns per loop

这个解决方案适用于任意的嵌套深度——而不仅仅是一些(所有?)其他解决方案所限制的“列表的列表”深度:

def flatten(x):
    result = []
    for el in x:
        if hasattr(el, "__iter__") and not isinstance(el, basestring):
            result.extend(flatten(el))
        else:
            result.append(el)
    return result

它是递归，允许任意深度嵌套-直到你达到最大递归深度，当然…