是的,我知道这个主题已被覆盖过(here,here,here,here),但据我所知,除了一个之外,所有解决方案都在这样的列表中失败:
L = [[[1, 2, 3], [4, 5]], 6]
期望的输出是什么
[1, 2, 3, 4, 5, 6]
或者甚至更好,一个迭代器。我看到的唯一适用于任意嵌套的解决方案是in this question:
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
flatten(L)
这是最好的型号吗?我忽略了什么吗?任何问题?
使用生成器函数可以使您的示例更容易阅读,并可能提高性能。
def flatten(l):
for el in l:
if isinstance(el, collections.Iterable) and not isinstance(el, basestring):
for sub in flatten(el):
yield sub
else:
yield el
我使用了2.6中添加的Iterable ABC。
在Python 3中,basestring
已不复存在,但您可以使用str
和bytes
的元组来获得相同的效果。
yield from
运算符一次从一个生成器返回一个项目。这个syntax for delegating to a subgenerator在3.3中添加
def flatten(l):
for el in l:
if isinstance(el, collections.Iterable) and not isinstance(el, (str, bytes)):
yield from flatten(el)
else:
yield el
尝试创建一个可以在Python中压缩不规则列表的函数很有趣,但当然这就是Python的目的(使编程变得有趣)。以下生成器运行良好,但有一些注意事项:
def flatten(iterable):
try:
for item in iterable:
yield from flatten(item)
except TypeError:
yield iterable
它将展平您可能想要保留的数据类型(如bytearray
,bytes
和str
对象)。此外,代码依赖于从非迭代请求迭代器引发TypeError
的事实。
>>> L = [[[1, 2, 3], [4, 5]], 6]
>>> def flatten(iterable):
try:
for item in iterable:
yield from flatten(item)
except TypeError:
yield iterable
>>> list(flatten(L))
[1, 2, 3, 4, 5, 6]
>>>
编辑:
我不同意以前的实施。问题是你不应该能够压扁不可迭代的东西。这令人困惑,并给出了错误的论点印象。
>>> list(flatten(123))
[123]
>>>
以下生成器几乎与第一个生成器相同,但没有尝试展平不可迭代对象的问题。如果给出不恰当的论点,它会失败。
def flatten(iterable):
for item in iterable:
try:
yield from flatten(item)
except TypeError:
yield item
使用提供的列表测试生成器工作正常。但是,当给出不可迭代的对象时,新代码将引发TypeError
。示例显示在新行为的下方。
>>> L = [[[1, 2, 3], [4, 5]], 6]
>>> list(flatten(L))
[1, 2, 3, 4, 5, 6]
>>> list(flatten(123))
Traceback (most recent call last):
File "<pyshell#32>", line 1, in <module>
list(flatten(123))
File "<pyshell#27>", line 2, in flatten
for item in iterable:
TypeError: 'int' object is not iterable
>>>
虽然选择了一个优雅且非常pythonic的答案,但我会提出我的解决方案仅供审阅:
def flat(l):
ret = []
for i in l:
if isinstance(i, list) or isinstance(i, tuple):
ret.extend(flat(i))
else:
ret.append(i)
return ret
请告诉我们这段代码有多好或多坏?
我更喜欢简单的答案。没有发电机。没有递归或递归限制。只是迭代:
def flatten(TheList):
listIsNested = True
while listIsNested: #outer loop
keepChecking = False
Temp = []
for element in TheList: #inner loop
if isinstance(element,list):
Temp.extend(element)
keepChecking = True
else:
Temp.append(element)
listIsNested = keepChecking #determine if outer loop exits
TheList = Temp[:]
return TheList
这适用于两个列表:内部for循环和外部while循环。
内部for循环遍历列表。如果它找到一个列表元素,它(1)使用list.extend()来展平该部分嵌套级别和(2)将keepChecking切换为True。 keepchecking用于控制外部while循环。如果外部循环设置为true,则会触发内部循环以进行另一次传递。
这些传递继续发生,直到找不到更多的嵌套列表。当最终发生传递而没有找到时,keepChecking永远不会被跳转到true,这意味着listIsNested保持为false并且外部while循环退出。
然后返回展平列表。
测试运行
flatten([1,2,3,4,[100,200,300,[1000,2000,3000]]])
[1, 2, 3, 4, 100, 200, 300, 1000, 2000, 3000]
这是一个简单的函数,可以平滑任意深度的列表。没有递归,以避免堆栈溢出。
from copy import deepcopy
def flatten_list(nested_list):
"""Flatten an arbitrarily nested list, without recursion (to avoid
stack overflows). Returns a new list, the original list is unchanged.
>> list(flatten_list([1, 2, 3, [4], [], [[[[[[[[[5]]]]]]]]]]))
[1, 2, 3, 4, 5]
>> list(flatten_list([[1, 2], 3]))
[1, 2, 3]
"""
nested_list = deepcopy(nested_list)
while nested_list:
sublist = nested_list.pop(0)
if isinstance(sublist, list):
nested_list = sublist + nested_list
else:
yield sublist
这是2.7.5中的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
有更好,更快的方法(如果你到达这里,你已经看过它们)
另请注意:
从2.6版开始不推荐使用:Python 3中已删除了编译器包。
我很惊讶没人想到这个。该死的递归我没有得到高级人员在这里提出的递归答案。无论如何,这是我对此的尝试。警告这是OP的用例非常具体
import re
L = [[[1, 2, 3], [4, 5]], 6]
flattened_list = re.sub("[\[\]]", "", str(L)).replace(" ", "").split(",")
new_list = list(map(int, flattened_list))
print(new_list)
输出:
[1, 2, 3, 4, 5, 6]
我没有在这里找到所有已经提供的答案,但这里有一个我想出的单行,借用lisp的第一个方法和休息列表处理
def flatten(l): return flatten(l[0]) + (flatten(l[1:]) if len(l) > 1 else []) if type(l) is list else [l]
这是一个简单而不那么简单的案例 -
>>> flatten([1,[2,3],4])
[1, 2, 3, 4]
>>> flatten([1, [2, 3], 4, [5, [6, {'name': 'some_name', 'age':30}, 7]], [8, 9, [10, [11, [12, [13, {'some', 'set'}, 14, [15, 'some_string'], 16], 17, 18], 19], 20], 21, 22, [23, 24], 25], 26, 27, 28, 29, 30])
[1, 2, 3, 4, 5, 6, {'age': 30, 'name': 'some_name'}, 7, 8, 9, 10, 11, 12, 13, set(['set', 'some']), 14, 15, 'some_string', 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
>>>
完全hacky但我觉得它会起作用(取决于你的data_type)
flat_list = ast.literal_eval("[%s]"%re.sub("[\[\]]","",str(the_list)))
这是另一种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))
它可以忽略你想要的任何特定(或派生)类型,它返回一个迭代器,所以你可以将它转换为任何特定的容器,如list,tuple,dict或者只是消耗它以减少内存占用,无论好坏它可以处理初始的非可迭代对象,如int ...
注意大多数繁重的工作是用C语言完成的,因为据我所知,迭代工具是如何实现的,所以虽然它是递归的,但它不受python递归深度的限制,因为函数调用是在C中发生的,尽管并不意味着你受到内存的限制,特别是在OS X中,其堆栈大小目前有一个硬限制(OS X Mavericks)......
有一个稍微快一点的方法,但是更少的可移植方法,只有在你可以假设输入的基本元素可以明确确定的情况下才使用它,你将获得无限递归,并且OS X具有有限的堆栈大小,将快速抛出分段错误......
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))
这里我们使用集合来检查类型,因此需要O(1)vs O(类型数量)来检查是否应该忽略一个元素,尽管当然任何具有所述忽略类型的派生类型的值都将失败,这就是为什么它使用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
使用itertools.chain
:
import itertools
from collections import Iterable
def list_flatten(lst):
flat_lst = []
for item in itertools.chain(lst):
if isinstance(item, Iterable):
item = list_flatten(item)
flat_lst.extend(item)
else:
flat_lst.append(item)
return flat_lst
或者没有链接:
def flatten(q, final):
if not q:
return
if isinstance(q, list):
if not isinstance(q[0], list):
final.append(q[0])
else:
flatten(q[0], final)
flatten(q[1:], final)
else:
final.append(q)
我的解决方案
import collections
def flatten(x):
if isinstance(x, collections.Iterable):
return [a for i in x for a in flatten(i)]
else:
return [x]
更简洁,但几乎相同。
我使用递归来解决任何深度的嵌套列表
def combine_nlist(nlist,init=0,combiner=lambda x,y: x+y):
'''
apply function: combiner to a nested list element by element(treated as flatten list)
'''
current_value=init
for each_item in nlist:
if isinstance(each_item,list):
current_value =combine_nlist(each_item,current_value,combiner)
else:
current_value = combiner(current_value,each_item)
return current_value
所以在我定义了函数combine_nlist之后,很容易使用这个函数来做平整。或者您可以将它组合成一个功能。我喜欢我的解决方案,因为它可以应用于任何嵌套列表。
def flatten_nlist(nlist):
return combine_nlist(nlist,[],lambda x,y:x+[y])
结果
In [379]: flatten_nlist([1,2,3,[4,5],[6],[[[7],8],9],10])
Out[379]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
最简单的方法是使用morph使用pip install morph
库。
代码是:
import morph
list = [[[1, 2, 3], [4, 5]], 6]
flattened_list = morph.flatten(list) # returns [1, 2, 3, 4, 5, 6]
我知道已经有很多很棒的答案,但我想添加一个使用解决问题的函数式编程方法的答案。在这个答案中我使用双递归:
def flatten_list(seq):
if not seq:
return []
elif isinstance(seq[0],list):
return (flatten_list(seq[0])+flatten_list(seq[1:]))
else:
return [seq[0]]+flatten_list(seq[1:])
print(flatten_list([1,2,[3,[4],5],[6,7]]))
输出:
[1, 2, 3, 4, 5, 6, 7]
我不确定这是否更快或更有效,但这就是我所做的:
def flatten(lst):
return eval('[' + str(lst).replace('[', '').replace(']', '') + ']')
L = [[[1, 2, 3], [4, 5]], 6]
print(flatten(L))
这里的flatten
函数将列表转换为字符串,取出所有方括号,将方括号连接到末端,然后将其转回列表。
虽然,如果你知道你的列表中的方括号,如[[1, 2], "[3, 4] and [5]"]
,你将不得不做其他事情。
在尝试回答这样的问题时,您确实需要将您提出的代码限制作为解决方案。如果它只是关于表演我不会太在意,但提出的大多数代码作为解决方案(包括接受的答案)都不能压缩任何深度大于1000的列表。
当我说大多数代码时,我指的是所有使用任何形式的递归的代码(或调用递归的标准库函数)。所有这些代码都失败了,因为对于每个递归调用,(调用)堆栈增长一个单元,而(默认)python调用堆栈的大小为1000。
如果您对调用堆栈不太熟悉,那么以下内容可能会有所帮助(否则您只需滚动到实现)。
想象一下,你进入一个带有编号房间的巨大地牢,寻找宝藏。你不知道这个地方,但你有一些关于如何找到宝藏的迹象。每个指示都是一个谜语(难度各不相同,但你无法预测它们会有多难)。你决定考虑一下节省时间的策略,你做了两点观察:
进入地牢时,你会发现这里有一个小笔记本。在决定谜语(进入新房间)后,您决定使用它来记下您退出的每个房间,这样您就可以返回入口。这是一个天才的想法,你甚至不会花一分钱来实施你的策略。
你进入地下城,在前1001个谜语中取得了巨大的成功,但是这里有你没有计划过的东西,你借来的笔记本上没有空间。你决定放弃你的任务,因为你不喜欢拥有宝藏,而不是永远迷失在地牢里面(看起来确实很聪明)。
基本上,它与寻找宝藏完全相同。地下城是计算机的记忆,你现在的目标不是寻找宝藏,而是计算一些功能(找到给定x的f(x))。指示只是子程序,将帮助您解决f(x)。您的策略与调用堆栈策略相同,笔记本是堆栈,房间是函数的返回地址:
x = ["over here", "am", "I"]
y = sorted(x) # You're about to enter a room named `sorted`, note down the current room address here so you can return back: 0x4004f4 (that room address looks weird)
# Seems like you went back from your quest using the return address 0x4004f4
# Let's see what you've collected
print(' '.join(y))
你在地下城遇到的问题在这里是一样的,调用堆栈有一个有限的大小(这里是1000),因此,如果你输入太多函数而不返回,那么你将填充调用堆栈并出现一个错误喜欢
“亲爱的冒险家,我很抱歉,但你的笔记本已经满了”
:RecursionError: maximum recursion depth exceeded
。请注意,您不需要递归来填充调用堆栈,但是非递归程序调用1000的功能非常不可能在没有返回的情况下运行。重要的是要理解一旦从函数返回,调用堆栈将从使用的地址中释放(因此名称“stack”,返回地址在进入函数之前被推入并在返回时被拉出)。在一个简单递归的特殊情况下(一次调用自身的函数f
- 反复遍历),你将一遍又一遍地输入f
直到计算完成(直到找到宝藏)并从f
返回直到你去回到你首先打电话给f
的地方。调用堆栈永远不会被释放,直到它将从一个接一个地从所有返回地址中释放出来。
这实际上非常简单:“如果你不知道它有多深,就不要使用递归”。在某些情况下,这并不总是正确的,Tail Call recursion can be Optimized (TCO)。但是在python中,情况并非如此,甚至“写得好”的递归函数也不会优化堆栈的使用。 Guido有一个关于这个问题的有趣帖子:Tail Recursion Elimination。
有一种技术可以用来迭代任何递归函数,我们可以调用这种技术带你自己的笔记本。例如,在我们的特定情况下,我们只是在探索一个列表,进入一个房间相当于输入一个子列表,您应该问自己的问题是我如何从列表返回到其父列表?答案并不复杂,重复以下内容直到stack
为空:
address
和index
推入stack
(请注意,列表地址+索引也是一个地址,因此我们只使用调用堆栈使用的完全相同的技术);yield
它(或将它们添加到列表中);stack
返回address
(和index
)返回到父列表。另请注意,这相当于树中的DFS,其中一些节点是子列表A = [1, 2]
,有些是简单项:0, 1, 2, 3, 4
(对于L = [0, [1,2], 3, 4]
)。树看起来像这样:
L
|
-------------------
| | | |
0 --A-- 3 4
| |
1 2
DFS遍历预订是:L,0,A,1,2,3,4。请记住,为了实现迭代DFS,您还需要“堆栈”。我之前提出的实现导致具有以下状态(对于stack
和flat_list
):
init.: stack=[(L, 0)]
**0**: stack=[(L, 0)], flat_list=[0]
**A**: stack=[(L, 1), (A, 0)], flat_list=[0]
**1**: stack=[(L, 1), (A, 0)], flat_list=[0, 1]
**2**: stack=[(L, 1), (A, 1)], flat_list=[0, 1, 2]
**3**: stack=[(L, 2)], flat_list=[0, 1, 2, 3]
**3**: stack=[(L, 3)], flat_list=[0, 1, 2, 3, 4]
return: stack=[], flat_list=[0, 1, 2, 3, 4]
在此示例中,堆栈最大大小为2,因为输入列表(因此树)的深度为2。
对于实现,在python中,您可以通过使用迭代器而不是简单列表来简化一点。对(子)迭代器的引用将用于存储子列表返回地址(而不是同时具有列表地址和索引)。这不是一个很大的区别,但我觉得这更具可读性(也更快):
def flatten(iterable):
return list(items_from(iterable))
def items_from(iterable):
cursor_stack = [iter(iterable)]
while cursor_stack:
sub_iterable = cursor_stack[-1]
try:
item = next(sub_iterable)
except StopIteration: # post-order
cursor_stack.pop()
continue
if is_list_like(item): # pre-order
cursor_stack.append(iter(item))
elif item is not None:
yield item # in-order
def is_list_like(item):
return isinstance(item, list)
另外,请注意在is_list_like
中我有isinstance(item, list)
,可以更改为处理更多输入类型,在这里我只想拥有最简单的版本,其中(iterable)只是一个列表。但你也可以这样做:
def is_list_like(item):
try:
iter(item)
return not isinstance(item, str) # strings are not lists (hmm...)
except TypeError:
return False
这将字符串视为“简单项目”,因此flatten_iter([["test", "a"], "b])
将返回["test", "a", "b"]
而不是["t", "e", "s", "t", "a", "b"]
。请注意,在这种情况下,iter(item)
在每个项目上被调用两次,让我们假装这是一个让读者更清洁的练习。
最后,请记住,您无法使用L
打印无限嵌套列表print(L)
,因为在内部它将使用__repr__
(RecursionError: maximum recursion depth exceeded while getting the repr of an object
)的递归调用。出于同样的原因,涉及flatten
的str
解决方案将失败,并显示相同的错误消息。
如果需要测试解决方案,可以使用此函数生成一个简单的嵌套列表:
def build_deep_list(depth):
"""Returns a list of the form $l_{depth} = [depth-1, l_{depth-1}]$
with $depth > 1$ and $l_0 = [0]$.
"""
sub_list = [0]
for d in range(1, depth):
sub_list = [d, sub_list]
return sub_list
其中给出:build_deep_list(5)
>>> [4, [3, [2, [1, [0]]]]]
。
这是在python2上展平的简单工具
flatten=lambda l: reduce(lambda x,y:x+y,map(flatten,l),[]) if isinstance(l,list) else [l]
test=[[1,2,3,[3,4,5],[6,7,[8,9,[10,[11,[12,13,14]]]]]],]
print flatten(test)
#output [1, 2, 3, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
只需使用funcy
库:pip install funcy
import funcy
funcy.flatten([[[[1, 1], 1], 2], 3]) # returns generator
funcy.lflatten([[[[1, 1], 1], 2], 3]) # returns list
如果您喜欢递归,这可能是您感兴趣的解决方案:
def f(E):
if E==[]:
return []
elif type(E) != list:
return [E]
else:
a = f(E[0])
b = f(E[1:])
a.extend(b)
return a
我实际上是根据我之前写过的一些练习程序代码改编的。
请享用!
我是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]
我没有看到这里发布的任何类似内容,只是来自关于同一主题的封闭问题,但为什么不做这样的事情(如果你知道要拆分的列表类型):
>>> 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()]
您需要知道元素的类型,但我认为这可以推广,而且就速度而言,我认为它会更快。
根据@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)
不使用任何库:
def flat(l):
def _flat(l, r):
if type(l) is not list:
r.append(l)
else:
for i in l:
r = r + flat(i)
return r
return _flat(l, [])
# example
test = [[1], [[2]], [3], [['a','b','c'] , [['z','x','y']], ['d','f','g']], 4]
print flat(test) # prints [1, 2, 3, 'a', 'b', 'c', 'z', 'x', 'y', 'd', 'f', 'g', 4]
使用递归和duck typing的生成器(针对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]
这个版本的flatten
避免了python的递归限制(因此适用于任意深度,嵌套的iterables)。它是一个可以处理字符串和任意迭代(甚至是无限迭代)的生成器。
import itertools as IT
import collections
def flatten(iterable, ltypes=collections.Iterable):
remainder = iter(iterable)
while True:
first = next(remainder)
if isinstance(first, ltypes) and not isinstance(first, (str, bytes)):
remainder = IT.chain(first, remainder)
else:
yield first
以下是一些展示其用途的示例:
print(list(IT.islice(flatten(IT.repeat(1)),10)))
# [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
print(list(IT.islice(flatten(IT.chain(IT.repeat(2,3),
{10,20,30},
'foo bar'.split(),
IT.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]
虽然flatten
可以处理无限生成器,但它无法处理无限嵌套:
def infinitely_nested():
while True:
yield IT.chain(infinitely_nested(), IT.repeat(1))
print(list(IT.islice(flatten(infinitely_nested()), 10)))
# hangs
这是我的递归flatten的功能版本,它处理元组和列表,并允许你输入任何位置参数的混合。返回一个生成整个序列的生成器,arg by arg:
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]
这是另一个更有趣的答案......
import re
def Flatten(TheList):
a = str(TheList)
b,crap = re.subn(r'[\[,\]]', ' ', a)
c = b.split()
d = [int(x) for x in c]
return(d)
基本上,它将嵌套列表转换为字符串,使用正则表达式去除嵌套语法,然后将结果转换回(展平)列表。
def flatten(xs):
res = []
def loop(ys):
for i in ys:
if isinstance(i, list):
loop(i)
else:
res.append(i)
loop(xs)
return res
你可以使用第三方包deepflatten
中的iteration_utilities
:
>>> 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://stackoverflow.com/a/2158532/5393381
86.4 µs ± 4.42 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
>>> %timeit list(flatten(L)) # Josh Lee - https://stackoverflow.com/a/2158522/5393381
107 µs ± 2.99 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
>>> %timeit list(genflat(L, list)) # Alex Martelli - https://stackoverflow.com/a/2159079/5393381
23.1 µs ± 710 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
我是iteration_utilities
图书馆的作者。