如何通过深度变量动态访问嵌套tuple元素并实现赋值操作？

实现前提说明 #

Python 中原生tuple是不可变类型，无法直接修改内部元素，所以要支持赋值操作，首先需要把嵌套tuple递归转换为嵌套list，修改完成后如果有需要可以再转回tuple格式，整体结构不会发生变化。

核心实现代码 #

1. 嵌套格式转换函数 #

# 嵌套tuple转嵌套list，用于支持修改
def nested_tuple_to_list(t):
    if isinstance(t, tuple):
        return list(nested_tuple_to_list(item) for item in t)
    return t

# 嵌套list转回嵌套tuple，用于还原格式
def nested_list_to_tuple(l):
    if isinstance(l, list):
        return tuple(nested_list_to_tuple(item) for item in l)
    return l

2. 动态访问指定深度元素 #

按照你的需求，约定深度n对应访问n次[1]索引，不需要硬编码多层[]：

def get_nested_item(nested_obj, depth, index=1):
    current = nested_obj
    for _ in range(depth):
        current = current[index]
    return current

如果追求代码简洁，也可以用reduce实现相同逻辑：

from functools import reduce
import operator

# 一行实现按深度访问，depth为对应深度
item = reduce(operator.getitem, [1]*depth, nested_obj)

3. 动态修改指定深度元素 #

修改需要先访问到目标深度的上一级节点，再对对应索引赋值：

def set_nested_item(nested_obj, depth, value, index=1):
    current = nested_obj
    # 走到目标深度的上一层
    for _ in range(depth - 1):
        current = current[index]
    current[index] = value

使用示例 #

# 原始嵌套tuple
J = ((1),((2),((3),((4), (7,7)))))
# 转成嵌套list支持修改
J_list = nested_tuple_to_list(J)

# 访问不同深度元素
print(get_nested_item(J_list, 1)) # 对应J[1]，输出 [2, [3, [4, [7, 7]]]]
print(get_nested_item(J_list, 2)) # 对应J[1][1]，输出 [3, [4, [7, 7]]]
print(get_nested_item(J_list, 4)) # 对应4层[1]，输出 [7,7]

# 修改深度4的元素为(8,8)
set_nested_item(J_list, 4, (8,8))
print(get_nested_item(J_list, 4)) # 输出 (8, 8)

# 转回tuple格式保留原始结构
J_modified = nested_list_to_tuple(J_list)
print(J_modified) # 输出修改后的完整嵌套tuple

内容的提问来源于stack exchange，提问作者shc