函数返回后将列表清空

Question

我现在正在做的程序有一个问题。我需要做一个函数，它将一个列表中的项目可以再次包含列表，变成一个简单的列表。函数获取一个列表作为参数，我需要使用递归返回新的扁平列表，而不更改主列表。你知道吗

这是我目前的尝试：

 result = []

def flatten(nested_list):
    for i in nested_list:
        if type(i) != list:
            result.append(i)
        else:
            flatten(i)
    return result

这里的问题是，只要我想再次运行这个函数，它就会记住最后一个结果，这意味着它会在最后附加所有内容。但我想创建一个新结果，只包含当前嵌套结果的简单列表。再次调用函数时如何删除最后一个结果？你知道吗

谢谢。你知道吗

Answer 1

出现此问题的原因是result位于错误的scope。您需要将result声明放在函数中，这样当函数结束时，它就超出了范围，不再存在。你知道吗

Answer 2

您不需要全局变量、额外参数、私有助手函数或闭包，只需知道何时使用append()和何时使用extend()：

def flatten(nested_list):
    result = []

    for i in nested_list:
        if isinstance(i, list):
            result.extend(flatten(i))
        else:
            result.append(i)

    return result

示例

>>> x = [[1, [2], [3, 4], 5]]
>>> flatten(x)
[1, 2, 3, 4, 5]
>>> x
[[1, [2], [3, 4], 5]]
>>> 

而且if type(i) != list:现在可能不是类型检查的首选isinstance()也可以处理子类。你知道吗

Answer 3

这里的问题是你总是使用一个全局变量。使用可变全局范围通常是一种反模式。保持代码基本相同。一种简单的方法是使用累加器并将其作为参数传递给递归调用：

In [4]: def flatten(nested_list, result=None):
   ...:     if result is None:
   ...:         result = []
   ...:     for i in nested_list:
   ...:         if type(i) != list:
   ...:             result.append(i)
   ...:         else:
   ...:             flatten(i, result)
   ...:     return result
   ...:
   ...:

In [5]: x = [[1,[2], [3,4],5]]

In [6]: flatten(x)
Out[6]: [1, 2, 3, 4, 5]

In [7]: x
Out[7]: [[1, [2], [3, 4], 5]]

In [8]: flatten(x)
Out[8]: [1, 2, 3, 4, 5]

In [9]: x
Out[9]: [[1, [2], [3, 4], 5]]

不过，通常情况下，您不想将result作为一个参数公开，等待您开枪打自己的脚。因此，您可以定义一个“私有”助手函数：

In [15]: def _flatten(nested_list, result):
    ...:     for i in nested_list:
    ...:         if type(i) != list:
    ...:             result.append(i)
    ...:         else:
    ...:             _flatten(i, result)
    ...:     return result
    ...:
    ...: def flatten(nested_list):
    ...:     return _flatten(nested_list, [])
    ...:
    ...:

In [16]: x = [[1,[2], [3,4],5]]

In [17]: flatten(x)
Out[17]: [1, 2, 3, 4, 5]

In [18]: x
Out[18]: [[1, [2], [3, 4], 5]]

In [19]: flatten(x)
Out[19]: [1, 2, 3, 4, 5]

或者，可以在main函数中定义助手，并将结果变量存储在闭包中：

In [26]: def flatten(nested_list):
    ...:     result = []
    ...:     def _flatten(nested_list):
    ...:         for i in nested_list:
    ...:             if type(i) != list:
    ...:                 result.append(i)
    ...:             else:
    ...:                 _flatten(i)
    ...:
    ...:     _flatten(nested_list)
    ...:     return result
    ...:
    ...:

In [27]: flatten(x)
Out[27]: [1, 2, 3, 4, 5]

In [28]: x
Out[28]: [[1, [2], [3, 4], 5]]

In [29]: flatten(x)
Out[29]: [1, 2, 3, 4, 5]