Python 使用单个对象遍历嵌套列表

我有一大堆清单。嵌套深度是在运行时确定的，我只想将它们访问到特定的（运行时确定的）深度，以便以任意方式操纵该级别的内容

理想情况下，我希望能够做到以下几点：

for x in access_list(nested_list, d)
    # do stuff at nesting-depth d

访问列表

应该做什么：

>>> mylist = [[[0, 1], [2, 3]], [[4, 5], [6, 7]]]
>>> for d in range(4):
...     for l in access_list(mylist, d):
...         print((d, l))
(0, [[[0, 1], [2, 3]], [[4, 5], [6, 7]]])
(1, [[[0, 1], [2, 3]])
(1, [[4, 5], [6, 7]]])
(2, [0, 1])
(2, [2, 3])
(2, [4, 5])
(2, [6, 7])
(3, 0)
(3, 1)
(3, 2)
(3, 3)
(3, 4)
(3, 5)
(3, 6)
(3, 7)

我的尝试结果基本上什么也没做：

def access_list(lists, d):
    if not d:
        return lists
    return [access_list(_list, d-1) for _list in lists]

它只是再次返回整个列表结构。

---

我该怎么做才能使其工作？

此生成器函数应适用于嵌套列表并节省内存，因为它本身并不构建列表，而是惰性地生成以下项：

def access_list(nested_list):
    if not isinstance(nested_list, list):
    # if not isinstance(nested_list, (list, set)): you get the idea
        yield nested_list
    else:
        for item in nested_list:
            for x in access_list(item):
                yield x
            # in Python 3, you can replace that loop by:
            # yield from access_list(item)
    return

> l = [1, 2, [3, [4, 5], 6]]
> list(access_list(l))
[1, 2, 3, 4, 5, 6]

如果您希望访问嵌套深度，以下操作将生成对

（项，深度）

：

---

此生成器函数应适用于嵌套列表并节省内存，因为它本身不构建列表，而是惰性地生成项：

def access_list(nested_list):
    if not isinstance(nested_list, list):
    # if not isinstance(nested_list, (list, set)): you get the idea
        yield nested_list
    else:
        for item in nested_list:
            for x in access_list(item):
                yield x
            # in Python 3, you can replace that loop by:
            # yield from access_list(item)
    return

> l = [1, 2, [3, [4, 5], 6]]
> list(access_list(l))
[1, 2, 3, 4, 5, 6]

如果您希望访问嵌套深度，以下操作将生成对

（项，深度）

：

---

考虑这个解决方案：

def access_list(lists, d):
    if not d:
        return lists
    else:
        return sum(access_list(lists, d-1), [])

例如，使用此列表：

l=[[1,2]，[3]，[4]，[5,6,7]]]

：

>>> access_list(l, 0)
[[1, 2], [3]]
[[4], [5, [6, 7]]]

>>> access_list(l, 1)
[1, 2]
[3]
[4]
[5, [6, 7]]

>>> access_list(l, 1)
1
2
3
4
5
[6, 7]

---

考虑这个解决方案：

def access_list(lists, d):
    if not d:
        return lists
    else:
        return sum(access_list(lists, d-1), [])

例如，使用此列表：

l=[[1,2]，[3]，[4]，[5,6,7]]]

：

>>> access_list(l, 0)
[[1, 2], [3]]
[[4], [5, [6, 7]]]

>>> access_list(l, 1)
[1, 2]
[3]
[4]
[5, [6, 7]]

>>> access_list(l, 1)
1
2
3
4
5
[6, 7]

---

您可以使用numpy阵列，它可能会起作用

import numpy
def access_list(lists, d):
    _lists=numpy.array(lists)
    if not d:
        L=[]
        for index in range(len(_lists)):
            L.append(_lists[index])
        return L
    return _lists[:]

---

您可以使用numpy阵列，它可能会起作用

import numpy
def access_list(lists, d):
    _lists=numpy.array(lists)
    if not d:
        L=[]
        for index in range(len(_lists)):
            L.append(_lists[index])
        return L
    return _lists[:]

---

非常接近！尝试将列表细分为越来越小的块

def access_list(x, d):
    if d and isinstance(x, list) and x:
       return access_list(x[0], d-1) + access_list(x[1:], d-1)
    return [x]

好的，我们希望避免这种情况，因为它有点复杂，但这给出了您希望的确切输出：

def access_list(x, d):
    def _access_list(x, d):
        if d and isinstance(x, types.ListType) and x:
            return access_list(x[0], d-1) + access_list(x[1:], d)
        return [x]
    return filter(lambda x: x, _access_list(x, d))

---

非常接近！尝试将列表细分为越来越小的块

def access_list(x, d):
    if d and isinstance(x, list) and x:
       return access_list(x[0], d-1) + access_list(x[1:], d-1)
    return [x]

好的，我们希望避免这种情况，因为它有点复杂，但这给出了您希望的确切输出：

def access_list(x, d):
    def _access_list(x, d):
        if d and isinstance(x, types.ListType) and x:
            return access_list(x[0], d-1) + access_list(x[1:], d)
        return [x]
    return filter(lambda x: x, _access_list(x, d))

---

---

太多的文字。大多数人不会读这篇文章来回答这个问题。请让你的问题更简洁。我同意@pyNoob-举个简单的例子。输入和预期输出。这个问题的标题很简单，为什么需要这么多的文字才能让大家理解这个想法？我同意@pyNoob的观点。您确实需要递归，所以只需将问题集中在不起作用的代码上，并显示一些输入和输出。大多数人不会读这篇文章来回答这个问题。请让你的问题更简洁。我同意@pyNoob-举个简单的例子。输入和预期输出。这个问题的标题很简单，为什么需要这么多的文字才能让大家理解这个想法？我同意@pyNoob的观点。您确实需要递归，因此只需将您的问题集中在不起作用的代码上，并显示一些输入和输出。现在编辑问题考虑列表可以包含自身，在这种情况下，您需要一个集合来跟踪已看到的列表。您能将不可哈希的列表放在一个集合中吗？不能直接，你可以把它们的

id

放在一个集合中，或者转换成

tuple

problem@kram1032您可以只更改为以下内容：“如果不是isinstance（嵌套列表，列表）或d>=2:yield nested\u list”，请考虑列表可以包含自身，在这种情况下，您需要一个集合来跟踪所看到的列表。您可以将不可散列的列表放在一个集合中吗？不直接，您可以将它们的

id

放在一个集合中，或者转换为

tuple

。在我的情况下，列表不会包含它们自己，因此不应该是一个列表problem@kram1032您可以只更改为以下内容：'如果不是isinstance（嵌套列表，list）或d>=2:yield嵌套列表使用

sum

进行展平是很有趣的，当你第一次看到它时，它是O（n^2）。很有趣，尽管我实际上不想/不需要这样展平，如果这确实是O（n²）我宁愿使用另一种方法。虽然它看起来确实是一个很好的简单解决方案。当你第一次看到它时，使用

sum

进行展平是很有趣的，但它是O（n^2）。很有趣，尽管我实际上不希望/需要这样展平，如果这确实是O（n²）我更愿意使用另一种方法。不过它看起来确实是一个很好的简单解决方案。你的方法似乎做了一些奇怪的事情，从

d=2开始，递归是奇怪的，我同意：/因此，不要忘了在你的示例中，你打印出的是循环迭代，而不是嵌套深度。它们不是同一件事。你必须选择是否需要函数o与循环迭代或递归深度相对应，否则您需要编写单独的函数：）足够公平：）-基本上我希望
d
是要平展的级别数，因此
d=0
不应该改变任何东西，
d=1
应该平展顶层，等等，就像我的输出中发生的一样。是的，在我完成抱怨之后，我添加了第二个函数。我觉得它有点作弊，但它完成了任务：）你的方法似乎做了一些奇怪的事情，从
d=2开始，递归是奇怪的，我同意：/所以，不要忘记在你的例子中，你是在打印循环迭代，而不是嵌套深度。他们不是一回事。您必须选择是否希望函数与循环迭代或递归深度相对应，否则您需要编写单独的函数：）足够公平：）-基本上我希望
d
是要展平的级别数，因此
d=0
不应该改变任何内容，
d=1
应该展平顶层，等等。，就像在我的输出中发生的一样。是的，在我完成抱怨之后，我添加了第二个函数。我觉得这有点作弊，但它完成了任务：）