基于条件Python通过循环同时更新多个依赖列表

Question

我有一个复杂的情况试图解决，但努力为其创建逻辑和代码。请考虑下图：

沿着 x 轴，我有迭代次数和 y 轴，我有节点，这些节点都是用户定义的并且可以更改，但考虑到 3 节点和 5 次迭代以保持简单。

我正在尝试创建一个可以通过每个节点并基于节点号依次计算度量的循环框架或类似框架，即 N0 然后 N1 然后 N2。

对于所有节点，起始值为“f_value”，但后续值取决于节点编号。例如，让我们考虑将节点 0 表示为“N0”。第一次迭代取决于 N0 最后一个值以及“N1”最后一个值，它们都是“f_value”。第二次迭代，对于“N0”，我们考虑“N0”的最后计算值加上“N1”的先前值，并且这一直持续到最后一次迭代。

当考虑像“N2”这样的节点时，这会变得更加复杂，因为我们必须考虑为“N0”计算的最新值、“N2”的最后一个值以及“N3”的先前值。当谈到“N3”时，我们考虑“N3”的最后一个值和“N2”的最新值，如图所示。对于最后一个节点“N3”，我们只考虑前一个节点“N2”。

换句话说，第一个和最后一个节点具有单个依赖关系，但所有剩余节点具有多个依赖关系，即两侧的节点。

到目前为止，我已经设法创建了一个字典，该字典创建了节点并使用以下代码初始化了“f_value”：

  node = list(range (int(input())))
obj = {}


for i, j in enumerate(node): # assigning default values
    obj['l'+str(i)] = [10]

我正在努力更进一步，需要一些帮助，我们将不胜感激。我在想可能需要一些条件语句，但问题是您不能同时更新所有节点。

请随时要求进一步澄清。

Answer 1

import pandas as pd


def iterate(f_value: float,
            number_of_nodes: int,
            number_of_iterations:int,
            weight_1: float = 0.5,
            weight_2: float = 0.2) -> list:
    """Itearates the f_value according to provided rule and returns the resulting array

    Args:

        f_value: user input value that will be iterated
        number_of_nodes: number of nodes that the iteration will run
        number_of_iterations: number of iterations
        weight_1: user provided weight, default is 0.5
        weight_2: user provided weight, default is 0.2

    Returns:
        A list with length=number_of_iterations where each element is a list that represents
        the corresponding row. Let's call returned list L. L[0][0] represents the value of
        iteration1, node1. L[0][1] represents iteration1 node2 and so on.

    Example:

        >>> iterate(10,3,5)
        [[7.0, 15.5, 17.75],
         [6.6, 22.35, 28.925],
         [7.7700000000000005, 32.02, 44.935],
         [10.289000000000001, 46.151500000000006, 68.01075],
         [14.374800000000002, 66.94105000000002, 101.48127500000001]]

        >>> L = iterate(10,3,5)
        >>> print(L[0][0])
        7.0
        >>> print(L[0][1])
        15.5

    """

    weight_1 = 0.5
    weight_2 = 0.2
    iterations = []


    C = f_value + (f_value * weight_2)
    
    for iteration_no in range(number_of_iterations):

        nodes = []
        
        for node_no in range(number_of_nodes):

            if iteration_no == 0:
                if node_no == 0:
                    # First node
                    value = f_value * (weight_1 + weight_2)

                elif node_no < number_of_nodes-1:
                    # Nodes in between
                    value = (nodes[node_no-1] / 2) + C


                else:
                    # Last node
                    value = (nodes[node_no-1] / 2) + f_value

                nodes.append(value)

            else:
                if node_no == 0:
                    # First node
                    value = (iterations[iteration_no-1][0] * weight_1) + (iterations[iteration_no-1][1] * weight_2)

                elif node_no < number_of_nodes-1:
                    # Nodes in between
                    # we need the latest iteration from [node_no -1]let
                    print
                    value = (iterations[iteration_no-1][node_no]) + (nodes[node_no-1] * weight_1) + (iterations[iteration_no-1][node_no+1] * weight_2)

                else:
                    # Last node
                    value = iterations[iteration_no-1][node_no] + (nodes[node_no-1] * weight_1)

                nodes.append(value)

        iterations.append(nodes)

    return iterations