Python:循环迭代

Question

我无法将以下代码概括为任意长度的indeces：

sol = 0
for f_2 in F_2:
        if f_2 in A[0]:
            fac1 = f(f_2,indeces[0])
            for f_1 in F_1:
                if f_1 in A[0][f_2][0]:
                    fac2 = f(f_1,indeces[1])
                    for f_0 in F_0:
                        if f_0 in A[0][f_2][0][f_1][0]:
                            sol += (float(A[0][f_2][0][f_1][0][f_0])/A[0][f_2][0][f_1][1])*fac1*fac2*f_(indeces[-1],f_0)

也许有人有主意。原则上，问题是在循环上迭代。A是一种树形结构，将[dict,int]列为节点。你知道吗

Answer 1

在我用.children替换...[0]并用.node_val替换...[1]之后，您的代码才开始对我有意义，如果您使用的是具有属性children和node_val的适当Node对象，而不是列表：

sol = 0
for f_2 in F_2:
    if f_2 in A.children:
        fac1 = f(f_2,indeces[0])
        for f_1 in F_1:
            if f_1 in A.children[f_2].children:
                fac2 = f(f_1,indeces[1])
                for f_0 in F_0:
                    if f_0 in A.children[f_2].children[f_1].children:
                        sol +=(float(A.children[f_2].children[f_1].children[f_0])
                                    /A.children[f_2].children[f_1].node_val)
                                    *fac1*fac2*f_(indeces[-1],f_0)

您可能需要的是一个递归解决方案，类似于此（显然未经测试）：

def recursive(F, indeces, node):
    assert len(F) == len(indeces)
    children = node[0]
    node_val = node[1]
    total = 0
    if len F > 1: # do recursive call
        for child_key in F[0]:
            if child_key in children:
                fac = f(child_key, indeces[0])
                total += fac * recursive(F[1:], indeces[1:], children[child_key])
    else: # only 1 item left
        for child_key in F[0]:
            if child_key in children:
                fac = f_(indeces[0], child_key)
                total += fac * (float(children[child_key]xx) / node_val)
    return total

F_X = [F_2, F_1, F_0]
ind = [i0, i1, i2]

result = recursive(F_X, ind, A)

xx指的是我对你的问题的评论，你的float()的参数似乎是一个节点，而我应该是一个数字（node_val？）。你知道吗

Answer 2

很快，这里有一个实施方案

class Node(object):
    def __init__(self, children={}, integer=0):
        self.dictionary = children
        self.integer    = integer

    @property
    def children(self):
        return self.dictionary


class Tree(object):
    def __init__(self):
        self.root = Node()

    def compute_your_thing(self, FF, indeces):
        """
        Assuming FF is a list of lists such that
            FF[0] = [f_00, f_01, f_02, ...]
            FF[1] = [f_10, f_11, f_12, ...]
            FF[2] = [f_20, f_21, f_22, ...]
            ...
            FF[len(indeces)]
        """
        # Generalize for any indeces length
        indeces_level = len(indeces)
        level = 0
        fac = []
        sol = 0

        def lookup(node, F):
            for f in F:
                if f in node.children:
                    new_node = node.children[f]
                    level += 1
                    if level == indeces_level:
                        # We have reached the depth defined by the length of indeces
                        sol += float(new_node.integer/node.integer) * times(fac) * foo(indeces[-1], f)
                    else :
                        fac.append(foo(f, indeces[level]))
                        return lookup(new_node, FF[indeces_level - level])

        # Use the nested loop to compute your thing recursively
        lookup(root, FF[indeces_level])
        return sol


# Utilities
def times(fac):
    result = 1
    for f in fac:
        result *= fac

    return result

def foo(ind, f):
    # I don't know what you do with this function
    pass

希望这有帮助。你知道吗