是的，我知道这个主题以前已经被讨论过：
但据我所知，除了一个解决方案外，所有的解决方案都不能处理像[[[1, 2, 3], [4, 5]], 6]这样的列表，期望的输出是[1, 2, 3, 4, 5, 6]（或者更好的方式是迭代器）。
我看到的唯一一个可以处理任意嵌套的解决方案在这个问题中找到：
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
这是最好的方法吗？我有遗漏了什么吗？有什么问题吗？
compiler.ast.flatten的实现代码：
def flatten(seq):
l = []
for elt in seq:
t = type(elt)
if t is tuple or t is list:
for elt2 in flatten(elt):
l.append(elt2)
else:
l.append(elt)
return l
有更好、更快的方法（如果你已经到这里，你已经看到它们了）
另外注意：
自Python 3版本起，编译器包已被删除。自2.6版本起已废弃。
def flatten_deep(arr: list):
""" Flattens arbitrarily-nested list `arr` into single-dimensional. """
while arr:
if isinstance(arr[0], list): # Checks whether first element is a list
arr = arr[0] + arr[1:] # If so, flattens that first element one level
else:
yield arr.pop(0) # Otherwise yield as part of the flat array
flatten_deep(L)
more_itertools.collapse：# pip install more-itertools
from more_itertools import collapse
out = list(collapse([[[1, 2, 3], [4, 5]], 6]))
# [1, 2, 3, 4, 5, 6]
list(collapse([[[1, 2, 3, 'abc'], [4, 5]], 6, 'def']))
# [1, 2, 3, 'abc', 4, 5, 6, 'def']
list(collapse([[[1, 2, 3], [4, 5]], 6], levels=1))
# [[1, 2, 3], [4, 5], 6]
def collapse(iterable, base_type=None, levels=None):
def walk(node, level):
if (
((levels is not None) and (level > levels))
or isinstance(node, (str, bytes))
or ((base_type is not None) and isinstance(node, base_type))
):
yield node
return
try:
tree = iter(node)
except TypeError:
yield node
return
else:
for child in tree:
yield from walk(child, level + 1)
yield from walk(iterable, 0)
more_itertools 是一个非常好的库，如果它不在那里，那就太可惜了。 - undefinedpip install morph 命令安装即可。import morph
list = [[[1, 2, 3], [4, 5]], 6]
flattened_list = morph.flatten(list) # returns [1, 2, 3, 4, 5, 6]
我在这里没有看到类似的帖子，刚从一个关闭的有关相同主题的问题中来到这里，但为什么不像这样做（如果您知道要拆分的列表类型）：
>>> a = [1, 2, 3, 5, 10, [1, 25, 11, [1, 0]]]
>>> g = str(a).replace('[', '').replace(']', '')
>>> b = [int(x) for x in g.split(',') if x.strip()]
你需要知道元素的类型，但我认为这可以泛化，并且在速度方面会更快。
ints列表，那么“假设”在这里并不适用，如果提问者另有说明，但他没有，所以根据所给出的信息，这是最简单和最有效的答案之一。 - Zion我是一个蠢人，所以我会提供一个“蠢”的解决方案。所有这些递归让我的大脑疼痛。
flattened_list = []
nested_list = [[[1, 2, 3], [4, 5]], 6]
def flatten(nested_list, container):
for item in nested_list:
if isintance(item, list):
flatten(item, container)
else:
container.append(item)
>>> flatten(nested_list, flattened_list)
>>> flattened_list
[1, 2, 3, 4, 5, 6]
没有花哨，只有刺激。
recursive_list_of_lists = [1,2,3,[1,2,[[3,4,[5]],7,0,1,10],100,[101,[101,[[101]],2]],0]]
k = []
def flatten(subl):
for i in subl:
if type(i) != type([1]):
k.append(i)
else:
flatten(i)
flatten(recursive_list_of_lists)
print(k)
[1，2，3，1，2，3，4，5，7，0，1，10，100，101，101，101，2，0]
这是我使用递归解决的方法：
def flatten(x):
if not any(isinstance(e, list) for e in x):
return x
while type(x[-1]) == int:
x = [x[-1]] + [x[:-1]]
return flatten(x = x + x.pop(-1))
甚至更好：
def flatten(x):
if not any(isinstance(e, list) for e in x):
return x
return flatten(x = x + x.pop([isinstance(e, list) for e in x].index(1)))
这里是另一种基于py2的方法，我不确定它是否最快、最优雅或最安全...
from collections import Iterable
from itertools import imap, repeat, chain
def flat(seqs, ignore=(int, long, float, basestring)):
return repeat(seqs, 1) if any(imap(isinstance, repeat(seqs), ignore)) or not isinstance(seqs, Iterable) else chain.from_iterable(imap(flat, seqs))
def flat(seqs, ignore={int, long, float, str, unicode}):
return repeat(seqs, 1) if type(seqs) in ignore or not isinstance(seqs, Iterable) else chain.from_iterable(imap(flat, seqs))
str，unicode，因此请谨慎使用...
测试：
import random
def test_flat(test_size=2000):
def increase_depth(value, depth=1):
for func in xrange(depth):
value = repeat(value, 1)
return value
def random_sub_chaining(nested_values):
for values in nested_values:
yield chain((values,), chain.from_iterable(imap(next, repeat(nested_values, random.randint(1, 10)))))
expected_values = zip(xrange(test_size), imap(str, xrange(test_size)))
nested_values = random_sub_chaining((increase_depth(value, depth) for depth, value in enumerate(expected_values)))
assert not any(imap(cmp, chain.from_iterable(expected_values), flat(chain(((),), nested_values, ((),)))))
>>> test_flat()
>>> list(flat([[[1, 2, 3], [4, 5]], 6]))
[1, 2, 3, 4, 5, 6]
>>>
$ uname -a
Darwin Samys-MacBook-Pro.local 13.3.0 Darwin Kernel Version 13.3.0: Tue Jun 3 21:27:35 PDT 2014; root:xnu-2422.110.17~1/RELEASE_X86_64 x86_64
$ python --version
Python 2.7.5
虽然很粗糙，但我认为它可以工作（取决于数据类型）
flat_list = ast.literal_eval("[%s]"%re.sub("[\[\]]","",str(the_list)))
list应该是同质的）并不意味着这是Python的问题，我们需要为这样的任务建立一个内置功能。 - Azat Ibrakov