是的，我知道这个主题以前已经被讨论过：
但据我所知，除了一个解决方案外，所有的解决方案都不能处理像[[[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
这是最好的方法吗？我有遗漏了什么吗？有什么问题吗？
使用生成器函数可以使您的示例更易于阅读并提高性能。
在2.6中添加的Iterable ABC可用:
from collections import Iterable
def flatten(xs):
for x in xs:
if isinstance(x, Iterable) and not isinstance(x, basestring):
for item in flatten(x):
yield item
else:
yield x
Python 3中，basestring已经不存在，但是元组(str, bytes)可以达到相同的效果。另外，yield from操作符会逐个从生成器中返回项。
from collections.abc import Iterable
def flatten(xs):
for x in xs:
if isinstance(x, Iterable) and not isinstance(x, (str, bytes)):
yield from flatten(x)
else:
yield x
list(flatten(l)) 后迅速将此列表 l = ([[chr(i),chr(i-32)] for i in xrange(ord('a'), ord('z')+1)] + range(0,9)) 扁平化。而其他所有建议都会开始运行但需要很长时间才能完成！ - JWLcollections.Sequence 而不是 collections.Iterable？ - joschfor i in flatten(42): print (i)。通过将isinstance测试和else语句移出for el循环可以解决这个问题。（然后您可以将任何东西放入其中，并将其制作成一个扁平化的列表） - RolKaucollections.Iterable已被弃用。请改用collections.abc.Iterable。 - dawg我的解决方案：
import collections
def flatten(x):
if isinstance(x, collections.Iterable):
return [a for i in x for a in flatten(i)]
else:
return [x]
更为简洁，但基本相同。
try: iter(x)，这样就不需要导入任何模块。但是我认为没有必要避免导入标准库模块。 - abarnertdef flatten(x): return [a for i in x for a in flatten(i)] if isinstance(x, collections.Iterable) else [x] - 但是可读性可能因人而异。 - Zeroif isinstance(x, collections.Iterable) and not isinstance(x, basestring)来替换。 - aandis使用递归和鸭子类型的生成器（已更新为Python 3）：
def flatten(L):
for item in L:
try:
yield from flatten(item)
except TypeError:
yield item
list(flatten([[[1, 2, 3], [4, 5]], 6]))
>>>[1, 2, 3, 4, 5, 6]
for i in flatten(item): yield i - dansalmo这是我的递归展平函数版本，可以处理元组和列表，并允许您投入任何混合的位置参数。返回一个生成器，按顺序产生整个序列，逐个参数进行：
flatten = lambda *n: (e for a in n
for e in (flatten(*a) if isinstance(a, (tuple, list)) else (a,)))
使用方法：
l1 = ['a', ['b', ('c', 'd')]]
l2 = [0, 1, (2, 3), [[4, 5, (6, 7, (8,), [9]), 10]], (11,)]
print list(flatten(l1, -2, -1, l2))
['a', 'b', 'c', 'd', -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
args代替n，使用intermediate(或更短的mid或您可能更喜欢element)代替a，并且使用result代替e，因此：flatten = lambda *args: (result for mid in args for result in (flatten(*mid) if isinstance(mid, (tuple, list)) else (mid,)))。 - Dennis Williamsoncompiler.ast.flatten 快得多。非常棒的、紧凑的代码，适用于任何（我认为）对象类型。 - bcdan根据@ Andrew在评论中的请求，这是@ unutbu的非递归解决方案的生成器版本：
def genflat(l, ltypes=collections.Sequence):
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]
yield l[i]
i += 1
这个生成器的稍微简化版本：
def genflat(l, ltypes=collections.Sequence):
l = list(l)
while l:
while l and isinstance(l[0], ltypes):
l[0:1] = l[0]
if l: yield l.pop(0)
此版本的flatten避免了Python的递归限制（因此可以处理任意深度、嵌套的可迭代对象）。它是一个生成器，可以处理字符串和任意可迭代对象（甚至是无限迭代对象）。
import itertools
import collections
def flatten(iterable, ltypes=collections.Iterable):
remainder = iter(iterable)
while True:
try:
first = next(remainder)
except StopIteration:
break
if isinstance(first, ltypes) and not isinstance(first, (str, bytes)):
remainder = itertools.chain(first, remainder)
else:
yield first
print(list(itertools.islice(flatten(itertools.repeat(1)),10)))
# [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
print(list(itertools.islice(flatten(itertools.chain(itertools.repeat(2,3),
{10,20,30},
'foo bar'.split(),
itertools.repeat(1),)),10)))
# [2, 2, 2, 10, 20, 30, 'foo', 'bar', 1, 1]
print(list(flatten([[1,2,[3,4]]])))
# [1, 2, 3, 4]
seq = ([[chr(i),chr(i-32)] for i in range(ord('a'), ord('z')+1)] + list(range(0,9)))
print(list(flatten(seq)))
# ['a', 'A', 'b', 'B', 'c', 'C', 'd', 'D', 'e', 'E', 'f', 'F', 'g', 'G', 'h', 'H',
# 'i', 'I', 'j', 'J', 'k', 'K', 'l', 'L', 'm', 'M', 'n', 'N', 'o', 'O', 'p', 'P',
# 'q', 'Q', 'r', 'R', 's', 'S', 't', 'T', 'u', 'U', 'v', 'V', 'w', 'W', 'x', 'X',
# 'y', 'Y', 'z', 'Z', 0, 1, 2, 3, 4, 5, 6, 7, 8]
def infinitely_nested():
while True:
yield itertools.chain(infinitely_nested(), itertools.repeat(1))
print(list(itertools.islice(flatten(infinitely_nested()), 10)))
# hangs
sets、dicts、deques、listiterators、generators、文件句柄以及定义了__iter__的自定义类都是collections.Iterable的实例，但不是collections.Sequence的实例。将dict展平的结果有点棘手，但除此之外，我认为collections.Iterable比collections.Sequence更好作为默认值。它绝对更自由。 - unutbucollections.Iterable的一个问题是它包括无限生成器。我已经更改了我的答案来处理这种情况。 - unutbutry-except StopIteration块中封装flatten的主体来解决。 - badukerdef flatten(xs):
res = []
def loop(ys):
for i in ys:
if isinstance(i, list):
loop(i)
else:
res.append(i)
loop(xs)
return res
Pandas有一个函数可以做到这一点。它会像你提到的那样返回一个迭代器。
In [1]: import pandas
In [2]: pandas.core.common.flatten([[[1, 2, 3], [4, 5]], 6])
Out[2]: <generator object flatten at 0x7f12ade66200>
In [3]: list(pandas.core.common.flatten([[[1, 2, 3], [4, 5]], 6]))
Out[3]: [1, 2, 3, 4, 5, 6]
这里有另一个更有趣的答案...
import re
def Flatten(TheList):
a = str(TheList)
b,_Anon = re.subn(r'[\[,\]]', ' ', a)
c = b.split()
d = [int(x) for x in c]
return(d)
这个函数将嵌套列表转换为字符串，使用正则表达式删除嵌套语法，最后将结果转换回（已平铺的）列表。
[['C=64', 'APPLE ]['], ['Amiga', 'Mac', 'ST']] :) 另一方面，如果给定一个包含自身的列表，它会比其他答案做得更好，抛出一个异常而不是仅仅循环直到内存耗尽/递归直到堆栈耗尽... - abarnert[x for x in c] 只是一种缓慢而冗长的复制 c 的方式，那么你为什么要这样做呢？其次，你的代码显然会将 'APPLE ][' 转换为 'APPLE '，因为它没有处理引号，只是假设任何括号都是列表括号。 - abarnertarr_str = str(arr)，然后运行 [int(s) for s in re.findall(r'\d+', arr_str)] 即可。详见 https://github.com/jorgeorpinel/flatten_nested_lists/blob/master/flatten.py#L20-L26 - Jorge Orpinel Pérez您可以使用第三方软件包iteration_utilities中的deepflatten：
>>> from iteration_utilities import deepflatten
>>> L = [[[1, 2, 3], [4, 5]], 6]
>>> list(deepflatten(L))
[1, 2, 3, 4, 5, 6]
>>> list(deepflatten(L, types=list)) # only flatten "inner" lists
[1, 2, 3, 4, 5, 6]
这是一个迭代器，所以您需要对其进行迭代（例如通过使用list将其包装或在循环中使用它）。它在内部使用迭代方法而不是递归方法，并且编写为C扩展，因此可以比纯Python方法更快：
>>> %timeit list(deepflatten(L))
12.6 µs ± 298 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
>>> %timeit list(deepflatten(L, types=list))
8.7 µs ± 139 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
>>> %timeit list(flatten(L)) # Cristian - Python 3.x approach from https://dev59.com/THI95IYBdhLWcg3wyBCc#2158532
86.4 µs ± 4.42 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
>>> %timeit list(flatten(L)) # Josh Lee - https://dev59.com/THI95IYBdhLWcg3wyBCc#2158522
107 µs ± 2.99 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
>>> %timeit list(genflat(L, list)) # Alex Martelli - https://dev59.com/THI95IYBdhLWcg3wyBCc#2159079
23.1 µs ± 710 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
我是 iteration_utilities 库的作者。
list应该是同质的）并不意味着这是Python的问题，我们需要为这样的任务建立一个内置功能。 - Azat Ibrakov