在python中将列表列表加入单个列表（或迭代器）的简短语法是什么？
例如，我有一个如下列表，我想迭代a，b和c。
x = [["a","b"], ["c"]]
我能想出的最好成绩如下。
result = []
[ result.extend(el) for el in x]
for el in result:
print el
答案 0 :(得分：397)
import itertools
a = [["a","b"], ["c"]]
print list(itertools.chain.from_iterable(a))
答案 1 :(得分：157)
如果你只是深入一级，嵌套的理解也会起作用：
>>> x = [["a","b"], ["c"]]
>>> [inner
... for outer in x
... for inner in outer]
['a', 'b', 'c']
在一行中，它变为：
>>> [j for i in x for j in i]
['a', 'b', 'c']
答案 2 :(得分：130)
x = [["a","b"], ["c"]]
result = sum(x, [])
答案 3 :(得分：28)
这被称为展平，并且有很多实现：
这个怎么样，虽然它只适用于1级深度嵌套：
>>> x = [["a","b"], ["c"]]
>>> for el in sum(x, []):
... print el
...
a
b
c
从这些链接中，显然最完整，快速优雅等实现如下：
def flatten(l, ltypes=(list, tuple)):
ltype = type(l)
l = list(l)
i = 0
while i < len(l):
while isinstance(l[i], ltypes):
if not l[i]:
l.pop(i)
i -= 1
break
else:
l[i:i + 1] = l[i]
i += 1
return ltype(l)
答案 4 :(得分：27)
答案 5 :(得分：15)
这对于无限嵌套元素递归工作：
def iterFlatten(root):
if isinstance(root, (list, tuple)):
for element in root:
for e in iterFlatten(element):
yield e
else:
yield root
结果：
>>> b = [["a", ("b", "c")], "d"]
>>> list(iterFlatten(b))
['a', 'b', 'c', 'd']
答案 6 :(得分：8)
绩效比较：
import itertools
import timeit
big_list = [[0]*1000 for i in range(1000)]
timeit.repeat(lambda: list(itertools.chain.from_iterable(big_list)), number=100)
timeit.repeat(lambda: list(itertools.chain(*big_list)), number=100)
timeit.repeat(lambda: (lambda b: map(b.extend, big_list))([]), number=100)
timeit.repeat(lambda: [el for list_ in big_list for el in list_], number=100)
[100*x for x in timeit.repeat(lambda: sum(big_list, []), number=1)]
产：
>>> import itertools
>>> import timeit
>>> big_list = [[0]*1000 for i in range(1000)]
>>> timeit.repeat(lambda: list(itertools.chain.from_iterable(big_list)), number=100)
[3.016212113769325, 3.0148865239060227, 3.0126415732791028]
>>> timeit.repeat(lambda: list(itertools.chain(*big_list)), number=100)
[3.019953987082083, 3.528754223385439, 3.02181439266457]
>>> timeit.repeat(lambda: (lambda b: map(b.extend, big_list))([]), number=100)
[1.812084445152557, 1.7702404451095965, 1.7722977998725362]
>>> timeit.repeat(lambda: [el for list_ in big_list for el in list_], number=100)
[5.409658160700605, 5.477502077679354, 5.444318360412744]
>>> [100*x for x in timeit.repeat(lambda: sum(big_list, []), number=1)]
[399.27587954973444, 400.9240571138051, 403.7521153804846]
这是在Windows XP 32位上的Python 2.7.1，但上面评论中的@temoto使from_iterable比map+extend更快，因此它非常依赖于平台和输入。
远离sum(big_list, [])
答案 7 :(得分：6)
晚会但是......
我是python的新手，来自lisp背景。这就是我提出的（查看lulz的var名称）：
def flatten(lst):
if lst:
car,*cdr=lst
if isinstance(car,(list,tuple)):
if cdr: return flatten(car) + flatten(cdr)
return flatten(car)
if cdr: return [car] + flatten(cdr)
return [car]
似乎工作。测试：
flatten((1,2,3,(4,5,6,(7,8,(((1,2)))))))
返回：
[1, 2, 3, 4, 5, 6, 7, 8, 1, 2]
答案 8 :(得分：5)
您所描述的内容被称为展平列表，凭借这些新知识，您将能够在Google上找到许多解决方案（没有内置的展平方法） 。以下是其中一个，来自http://www.daniel-lemire.com/blog/archives/2006/05/10/flattening-lists-in-python/：
def flatten(x):
flat = True
ans = []
for i in x:
if ( i.__class__ is list):
ans = flatten(i)
else:
ans.append(i)
return ans
答案 9 :(得分：5)
如果您需要列表而不是生成器，请使用list():
from itertools import chain
x = [["a","b"], ["c"]]
y = list(chain(*x))
答案 10 :(得分：3)
总是减少（被弃用到functools）：
>>> x = [ [ 'a', 'b'], ['c'] ]
>>> for el in reduce(lambda a,b: a+b, x, []):
... print el
...
__main__:1: DeprecationWarning: reduce() not supported in 3.x; use functools.reduce()
a
b
c
>>> import functools
>>> for el in functools.reduce(lambda a,b: a+b, x, []):
... print el
...
a
b
c
>>>
不幸的是，列表连接的加号运算符不能用作函数 - 或者幸运，如果你更喜欢使用lambdas来提高可见性。
答案 11 :(得分：2)
或递归操作：
def flatten(input):
ret = []
if not isinstance(input, (list, tuple)):
return [input]
for i in input:
if isinstance(i, (list, tuple)):
ret.extend(flatten(i))
else:
ret.append(i)
return ret
答案 12 :(得分：1)
可悲的是，Python没有简单的方法来压缩列表。试试这个：
def flatten(some_list):
for element in some_list:
if type(element) in (tuple, list):
for item in flatten(element):
yield item
else:
yield element
将以递归方式展平列表;然后你可以做
result = []
[ result.extend(el) for el in x]
for el in flatten(result):
print el
答案 13 :(得分：1)
对于单级展平，如果你关心速度，这比我尝试的所有条件下的任何先前的答案都要快。 （也就是说，如果您需要将结果作为列表。如果您只需要动态迭代它，那么链示例可能更好。）它的工作原理是预先分配最终大小的列表并复制部分by slice（这是一个比任何迭代器方法更低级的块副本）：
def join(a):
"""Joins a sequence of sequences into a single sequence. (One-level flattening.)
E.g., join([(1,2,3), [4, 5], [6, (7, 8, 9), 10]]) = [1,2,3,4,5,6,(7,8,9),10]
This is very efficient, especially when the subsequences are long.
"""
n = sum([len(b) for b in a])
l = [None]*n
i = 0
for b in a:
j = i+len(b)
l[i:j] = b
i = j
return l
带有评论的排序时间列表：
[(0.5391559600830078, 'flatten4b'), # join() above.
(0.5400412082672119, 'flatten4c'), # Same, with sum(len(b) for b in a)
(0.5419249534606934, 'flatten4a'), # Similar, using zip()
(0.7351131439208984, 'flatten1b'), # list(itertools.chain.from_iterable(a))
(0.7472689151763916, 'flatten1'), # list(itertools.chain(*a))
(1.5468521118164062, 'flatten3'), # [i for j in a for i in j]
(26.696547985076904, 'flatten2')] # sum(a, [])
答案 14 :(得分：1)
当我必须创建一个包含数组元素及其计数的字典时，我遇到了类似的问题。答案是相关的，因为我将列表列表展平，获得我需要的元素，然后进行分组计数。我使用Python的map函数生成一个元素元组，它在数组上计数和分组。请注意，groupby将数组元素本身作为keyfunc。作为一个相对较新的Python编码器，我发现它更易于理解，同时也是Pythonic。
在我讨论代码之前，这里是我必须首先展平的数据样本：
{ "_id" : ObjectId("4fe3a90783157d765d000011"), "status" : [ "opencalais" ],
"content_length" : 688, "open_calais_extract" : { "entities" : [
{"type" :"Person","name" : "Iman Samdura","rel_score" : 0.223 },
{"type" : "Company", "name" : "Associated Press", "rel_score" : 0.321 },
{"type" : "Country", "name" : "Indonesia", "rel_score" : 0.321 }, ... ]},
"title" : "Indonesia Police Arrest Bali Bomb Planner", "time" : "06:42 ET",
"filename" : "021121bn.01", "month" : "November", "utctime" : 1037836800,
"date" : "November 21, 2002", "news_type" : "bn", "day" : "21" }
这是来自Mongo的查询结果。下面的代码展示了这些列表的集合。
def flatten_list(items):
return sorted([entity['name'] for entity in [entities for sublist in
[item['open_calais_extract']['entities'] for item in items]
for entities in sublist])
首先，我将提取所有“实体”集合，然后为每个实体集合迭代字典并提取name属性。