以此为本,以此为本,以此为本,以此为本,以此为本,以此为本,以此为本。
如果您的列表来自列表理解,问题可以通过纠正理解更简单/直接解决;请参见Python列表理解;压缩列表?
在这里,最受欢迎的解决方案通常只包含一个“层”的清单。 查看清单不规则(自愿清单)的清单,解决方案完全清单一个深度清单的结构(重复,一般)。
以此为本,以此为本,以此为本,以此为本,以此为本,以此为本,以此为本。
如果您的列表来自列表理解,问题可以通过纠正理解更简单/直接解决;请参见Python列表理解;压缩列表?
在这里,最受欢迎的解决方案通常只包含一个“层”的清单。 查看清单不规则(自愿清单)的清单,解决方案完全清单一个深度清单的结构(重复,一般)。
当前回答
注意: 下面适用于 Python 3.3+ 因为它使用 yield_from. six 也是第三方包,尽管它是稳定的。
在obj = [1, 2,], [3, 4], [5, 6]的情况下,这里的所有解决方案都很好,包括列表理解和 itertools.chain.from_iterable。
但是,考虑这个稍微复杂的案例:
>>> obj = [[1, 2, 3], [4, 5], 6, 'abc', [7], [8, [9, 10]]]
这里有几个问题:
您可以以以下方式解决此问题:
>>> from collections import Iterable
>>> from six import string_types
>>> def flatten(obj):
... for i in obj:
... if isinstance(i, Iterable) and not isinstance(i, string_types):
... yield from flatten(i)
... else:
... yield i
>>> list(flatten(obj))
[1, 2, 3, 4, 5, 6, 'abc', 7, 8, 9, 10]
在这里,您可以检查(一)的子元素(一)与(一)的Iterable(一)无效,从(一)的ABC,但也希望确保(二)的元素(一)不是“类似于(一)的”。
其他回答
你可以使用列表扩展方法. 它显示是最快的:
flat_list = []
for sublist in l:
flat_list.extend(sublist)
表演:
import functools
import itertools
import numpy
import operator
import perfplot
def functools_reduce_iconcat(a):
return functools.reduce(operator.iconcat, a, [])
def itertools_chain(a):
return list(itertools.chain.from_iterable(a))
def numpy_flat(a):
return list(numpy.array(a).flat)
def extend(a):
n = []
list(map(n.extend, a))
return n
perfplot.show(
setup = lambda n: [list(range(10))] * n,
kernels = [
functools_reduce_iconcat, extend, itertools_chain, numpy_flat
],
n_range = [2**k for k in range(16)],
xlabel = 'num lists',
)
出口:
此分類上一篇
考虑到列表L的列表,
flat_list = [item for sublist in l for item in sublist]
意思是:
flat_list = []
for sublist in l:
for item in sublist:
flat_list.append(item)
它比迄今为止发布的短篇文章更快(l 是表格的列表)。
下面是相应的功能:
def flatten(l):
return [item for sublist in l for item in sublist]
作为证据,您可以在标准图书馆中使用时间模块:
$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99' '[item for sublist in l for item in sublist]'
10000 loops, best of 3: 143 usec per loop
$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99' 'sum(l, [])'
1000 loops, best of 3: 969 usec per loop
$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99' 'reduce(lambda x,y: x+y,l)'
1000 loops, best of 3: 1.1 msec per loop
解释:基于 + 的缩写(包括在总中使用)是必然的 O(L**2)当有 L 列表时 - 因为中间结果列表保持长,每个步骤都会分配一个新的中间结果列表对象,前中间结果中的所有对象都必须复制(以及在结尾添加一些新的对象)。
列表理解只产生一个列表,一次,并复制每个项目(从其原始居住地到结果列表)也准确一次。
我创建了一点功能,基本上可以平滑任何东西. 你可以用管道:管道安装平滑一切
from flatten_everything import flatten_everything
withoutprotection=list(
flatten_everything(
[
1,
1,
2,
[3, 4, 5, [6, 3, [2, 5, ["sfs", "sdfsfdsf",]]]],
1,
3,
34,
[
55,
{"brand": "Ford", "model": "Mustang", "year": 1964, "yearxx": 2020},
pd.DataFrame({"col1": [1, 2], "col2": [3, 4]}),
{"col1": [1, 2], "col2": [3, 4]},
55,
{"k32", 34},
np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]),
(np.arange(22), np.eye(2, 2), 33),
],
]
)
)
print(withoutprotection)
output:
[1, 1, 2, 3, 4, 5, 6, 3, 2, 5, 'sfs', 'sdfsfdsf', 1, 3, 34, 55, 'Ford', 'Mustang', 1964, 2020, 1, 2, 3, 4, 1, 2, 3, 4, 55, 34, 'k32', 1, 2, 3, 4, 5, 6, 7, 8, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 1.0, 0.0, 0.0, 1.0, 33]
你甚至可以保护物体免受闪烁:
from flatten_everything import ProtectedDict,ProtectedList,ProtectedTuple
withprotection=list(
flatten_everything(
[
1,
1,
2,
[3, 4, 5, [6, 3, [2, 5, ProtectedList(["sfs", "sdfsfdsf",])]]],
1,
3,
34,
[
55,
ProtectedDict({"brand": "Ford", "model": "Mustang", "year": 1964, "yearxx": 2020}),
pd.DataFrame({"col1": [1, 2], "col2": [3, 4]}),
{"col1": [1, 2], "col2": [3, 4]},
55,
{"k32", 34},
np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]),
ProtectedTuple((np.arange(22), np.eye(2, 2), 33)),
],
]
)
)
print(withprotection)
output:
[1, 1, 2, 3, 4, 5, 6, 3, 2, 5, ['sfs', 'sdfsfdsf'], 1, 3, 34, 55, {'brand': 'Ford', 'model': 'Mustang', 'year': 1964, 'yearxx': 2020}, 1, 2, 3, 4, 1, 2, 3, 4, 55, 34, 'k32', 1, 2, 3, 4, 5, 6, 7, 8, (array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,17, 18, 19, 20, 21]), array([[1., 0.], [0., 1.]]), 33)]
一个非回归功能,以便在任何深度的列表列表:
def flatten_list(list1):
out = []
inside = list1
while inside:
x = inside.pop(0)
if isinstance(x, list):
inside[0:0] = x
else:
out.append(x)
return out
l = [[[1,2],3,[4,[[5,6],7],[8]]],[9,10,11]]
flatten_list(l)
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
我会建议使用发电机与产量声明和产量从。
from collections.abc import Iterable
def flatten(items, ignore_types=(bytes, str)):
"""
Flatten all of the nested lists to the one. Ignoring flatting of iterable types str and bytes by default.
"""
for x in items:
if isinstance(x, Iterable) and not isinstance(x, ignore_types):
yield from flatten(x)
else:
yield x
values = [7, [4, 3, 5, [7, 3], (3, 4), ('A', {'B', 'C'})]]
for v in flatten(values):
print(v)