Python 如何递归修改深层嵌套列表的每个值并返回另一个类似的列表？

我想要一个嵌套列表

[[[1,2],[4,5]], 1, [1,3,4],[2,3,4]]

递归地进入其中，修改每个值，然后返回一个类似的列表。例如，我想给输出的每个值加1

[[[2,3],[5,6]], 2, [2,4,5],[3,4,5]]

在做递归函数方面，我取得了一些进展，在这里我测试它是要修改的列表还是元素。当谈到如何重新编制这份清单时，我感到很困惑。有没有一个简单的方法可以做到这一点？下面的代码是我到目前为止的代码

def add1(nodelist):
    list_of_lists = []
    name_nodes.nodes = []
    def recurse_list(nodelist):
        name_nodes.nodes = []
        edit_list = False
        for r in nodelist:
            if type(r) == list:
                recurse_list(r)
            else:
                edit_list = True
                name_nodes.nodes.append(r+1)
        if edit_list == True:
            list_of_lists.append(name_nodes.nodes)
    recurse_list(nodelist)
    return list_of_lists

这段代码得到以下输出

[[2, 3], [5, 6, 2], [2, 4, 5], [3, 4, 5], [3, 4, 5]]

我很惊讶没有一些模块或内置功能来更好地处理嵌套列表，因为有太多问题处理相似但不同的行为。我能找到的最接近的问题是。但那并不是我想要的。谢谢你的回答

def add1(L):
    for i, elem in enumerate(L):
        if isinstance(elem, int):
            L[i] += 1
        else:
            L[i] = add1(elem)
    return L

输出：

>>> L = [[[1,2],[4,5]], 1, [1,3,4],[2,3,4]]
>>> add1(L)
[[[2, 3], [5, 6]], 2, [2, 4, 5], [3, 4, 5]]

---

事实上，我最近一直在想这个。这是我为此编写的代码的一部分，摘自一些演示。函数

nmap（）

import functools


def mapper_nester(function):
    @functools.wraps(function)
    def wrapper(*point):
        try:
            res = function(*point)
        except TypeError:
            res = map(mapper_nester(function), *point)
        return res
    return wrapper


def nmap(function, *seq):
    """nmap(funtion, seq[, seq ...]) -> nested list of similar structure."""
    return map(mapper_nester(function), *seq)

>>> nested_list = [0, [1], [[[[2]]]],
                   [3, [], [4, 5]],
                   [6, [7, 8],
                    9, [[[]], 10, []]], 11,
                   [], [], [12]]
>>> nmap(lambda x: x + 1, nested_list)
[1,
 [2],
 [[[[3]]]],
 [4, [], [5, 6]],
 [7, [8, 9], 10, [[[]], 11, []]],
 12,
 [],
 [],
 [13]]

这是一个遍历嵌套（递归）结构的递归函数

优点：


应该对你的案子有用
不使用
isinstance（）
只是几行而已

缺点：


它受递归限制，因此对于嵌套较深的列表并不真正有用
在Python上下文中，递归函数通常是不受欢迎的
此函数使用
TypeError
检查节点的“类型”（原子或原子集合），但这并不总是可靠的（并且取决于映射函数实际执行的操作），尤其是Python类型

实际上，为了解决上一个问题，我已经编写了更多的代码，但在这里输入代码相当麻烦。[1]

[1] 它所做的是创建一个临时的、有限的“类型化宇宙”，它清楚地将原子与原子集合区分开来（这是以一种丑陋的方式完成的，使用
isinstance（）
和friends，这个“类型化宇宙”的创建可以定制），然后将数据和待映射函数提升到这个宇宙中，在这个宇宙中，提升函数只能作用于原子，产生原子作为值。嵌套映射是在这个宇宙中完成的，然后可以选择将结果降级到通常的Python宇宙
 “如果它是一个要修改的列表或[sic]元素”——在Python中，这不能总是100%确定地完成。它太漂亮了，我要哭了。我做了一些修改。我将
L[I]+=1
更改为
L[I]=func（elem）
，并将
isinstance（elem，int）
更改为
not isinstance（elem，list）
在参数列表中添加了func，并将其重命名为nmap。现在我可以很容易地更改嵌套列表。非常感谢你！