Question

我正在隔离中为公司制作一个“最可爱的宠物支架”，我感到困惑的是，在打完一轮（有人获胜）后如何更新随后几轮的竞争对手。

说我的获胜者是3，之后的回合是：

[[3，14]，[6，11]]

之后的回合是：

[[2，[7，10]]，[[3，14]，[6，11]]]

我想用子节点替换其中的子节点，以反映出现在只有子节点仍然存在的事实：

[[3，14]，[6，11]]-> [3，[6，11]]

[[2，[7，10]]，[[3，14]，[6，11]]]-> [[2，[7，10]]，[3，[6，11] ]]

我想出了一些代码，但是不能正常工作

[[3，14]，[6，11]]-> [[3]，[6，11]]（关闭，但没有雪茄）

[[2，[7，10]]，[[3，14]，[6，11]]]-> [[2，[7，10]]，[[3，14]，[ 6，11]]]]（不变）

    def traverse(traversed_element_of_list_of_lists, winner):
        rebuild = []
        if isinstance(traversed_element_of_list_of_lists, list):
            for value in traversed_element_of_list_of_lists:
                if isinstance(value, int):
                    continue#rebuild.append(value)
                if winner in value:
                    rebuild.append([winner])
                else:
                    rebuild.append(value)
                traverse(value, winner)
        return rebuild

SO上有很多关于替换已定义形状的嵌套列表中的项目的答案，还有关于如何遍历和展平任意深度的嵌套列表的答案，但是我似乎找不到任何有关如何替换项目的信息在任意深度的列表中。

谢谢您的帮助！

Answer 1

您的递归有3种情况：

基本情况下，嵌套对象不是真正的嵌套对象，它只是一个数字。直接退货。
特殊情况下，获奖者在列表中，在这种情况下，您只希望返回单个获奖者编号。
递归的情况，您可以通过递归遍历每个元素来返回新列表。

将其作为递归函数组合在一起

def traverse(nested, winner):
    if not isinstance(nested, list):
        return nested

    if winner in nested:
        return winner

    return [traverse(o, winner) for o in nested]

这会在您的示例中产生预期的结果。

traverse([[3, 14], [6, 11]], 3)                                                                                                                                                                                                     
# [3, [6, 11]]

traverse([[2, [7, 10]], [[3, 14], [6, 11]]], 3)                                                                                                                                                                                     
# [[2, [7, 10]], [3, [6, 11]]]

替换任意深度的嵌套列表中的元素

1 个答案: