当试图回答这样的问题时，您确实需要给出您提议作为解决方案的代码的限制。如果只考虑性能，我不会太在意，但是提议作为解决方案的大多数代码（包括可接受的答案）都无法使深度大于1000的列表变平。
当我说大多数代码我指的是所有使用任何形式的递归的代码（或调用递归的标准库函数）。所有这些代码都会失败，因为对于每个递归调用，（调用）堆栈都增加一个单位，而（默认）python调用堆栈的大小为1000。
如果您不太熟悉调用堆栈，那么以下内容可能会有所帮助（否则，您可以滚动到Implementation）。
调用堆栈大小和递归编程（类似于地下城）
寻找宝藏并退出
想象一下，您进入一个带编号房间的巨大地牢，寻找宝藏。您不知道这个地方，但是对于如何找到宝藏有一些指示。每个指示都是一个谜（难度各不相同，但是您无法预测它们的难易程度）。您决定对节省时间的策略进行一点思考，然后进行两个观察：
- 很难（很长）找到宝藏，因为您必须解决（可能很难）谜团才能到达那里。
- 找到宝藏后，返回入口可能很容易，您只需要在另一个方向上使用相同的路径即可（尽管这需要一点记忆才能调用您的路径）。
进入地牢时，您会在这里注意到一个小笔记本。您决定使用它来写下谜题（当进入新房间时）之后退出的每个房间，这样您就可以返回到入口。那是个天才的主意，您甚至都不会花一分钱实施自己的策略。
您进入了地牢，成功地解决了前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函数而永远不会返回的可能性很小。同样重要的是要了解，从函数返回后，调用栈将从使用的地址中释放出来（因此，名称“栈”，返回地址在进入函数之前就被压入，并在返回时被拉出）。在简单递归的特殊情况下（一个函数ffff
如何避免这个问题？
这实际上很简单：“如果您不知道递归的深度，请不要使用递归”。并非总是如此，因为在某些情况下，可以优化尾调用递归（TCO）。但是在python中，情况并非如此，即使“写得很好”的递归函数也无法优化堆栈的使用。Guido有一个有趣的帖子，关于这个问题：尾递归消除。
您可以使用一种技术来迭代任何递归函数，我们可以称之为自带笔记本。例如，在我们的特定情况下，我们只是在探索一个列表，进入一个房间等同于进入一个子列表，您应该问自己的问题是如何从列表返回其父列表？答案并不那么复杂，请重复以下操作，直到stack为空：
- 推送当前列表，
address并index在stack进入新的子列表时将其推入（请注意，列表地址+索引也是地址，因此我们只使用调用堆栈使用的完全相同的技术）；
- 每次找到一个项目
yield（或将它们添加到列表中）；
- 完全浏览列表后，请使用
stack return 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_likeI have中isinstance(item, list)，可以将其更改为处理更多输入类型，在这里，我只想拥有最简单的版本，其中（可迭代）只是一个列表。但是您也可以这样做：
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]]]]]。