从带有动态赋值的嵌套循环创建递归函数

Question

这个问题让我有点困惑，但总的来说，我正在研究一个图形问题，在这个问题上，我“走”在一个图形上（暂时），计算东西，并在过程中分配变量。目前，我有一个嵌套for循环的大型函数，它肯定可以转换为递归函数。我只是不知道怎么做。非常感谢您的帮助

MWE

设置

from collections import OrderedDict
from itertools import product

# MWE for SO
D = {"A":(0,1), 'B':(0,1), 'C':(0,1)}
nodes = ['A','B','C']

def assign(assigned, fixed, F):
    for i in nodes:
        if i in fixed:
            assigned[i] = fixed[i]
        else:
            assigned[i] = F[i](assigned)

    return assigned

def func():
    return OrderedDict(
        {
            "A": lambda v: v["A"],
            "B": lambda v: v["B"], 
            "C": lambda v: v["C"],
        }
    )

def func2(past):
    return OrderedDict(
        {
            "A": lambda v: v["A"]^past['A'],
            "B": lambda v: v["B"]^past['B'], 
            "C": lambda v: v["C"]^past['C'],
        }
    )

第一时间步（索引）

# First time step
fixed1 = {'B':0}
F = func()
for j in product(*[D[i] for i in D.keys()]):
    assigned = dict(zip(D.keys(), j))
    assigned = assign(assigned, fixed1, F)
    # For each j and assigned some logic happens here

第二时间步（索引）

# For second time-step, we start nesting
fixed1 = {'B':0}
fixed2 = {'A':1}
F = func()
# t=0
for j in product(*[D[i] for i in D.keys()]):
    assigned = dict(zip(D.keys(), j))
    assigned = assign(assigned, fixed1, F)
    # For each j and assigned some logic happens here

    # t=1
    G = func2(assigned)
    for jj in product(*[D[i] for i in D.keys()]):
        assigned = dict(zip(D.keys(), jj))
        assigned = assign(assigned, fixed2, G)
        # For each jj and assigned some logic happens here

第三时间步（索引）

# For second time-step, we start nesting
fixed1 = {'B':0}
fixed2 = {'A':1}
fixed3 = {'A':1}
F = func()
# t=0
for j in product(*[D[i] for i in D.keys()]):
    assigned = dict(zip(D.keys(), j))
    assigned = assign(assigned, fixed1, F)
    # For each j and assigned some logic happens here

    # t=1
    G = func2(assigned)
    for jj in product(*[D[i] for i in D.keys()]):
        assigned = dict(zip(D.keys(), jj))
        assigned = assign(assigned, fixed2, G)
        # For each jj and assigned some logic happens here

        # t=2
        H = func2(assigned)
        for jjj in product(*[D[i] for i in D.keys()]):
            assigned = dict(zip(D.keys(), jjj))
            assigned = assign(assigned, fixed3, H)
            # For each jjj and assigned some logic happens here

您可以看到它的发展方向（为了清晰起见进行编辑：对于每个新的时间步，我需要添加一个新的嵌套循环，这就是我想使用递归解决的部分。。值得注意的是，fixed变量将其他变量设置为特定值，并且来自此模块之外

因此，我如何将其转化为递归函数呢？正如您所想象的，我要做的远远不止三个索引

Answer 1

编辑：基于注释的新迭代（递归）

这将为生成的所有值调用fixed/funcs

def do_timesteps(fixeds_funcs, assigned=None):
    (fixed, func), *next_fixeds_funcs = fixeds_funcs
    print(fixed, func, assigned)  # for debugging :)
    F = func(assigned)
    for j in product(*[D[i] for i in D.keys()]):
        assigned = dict(zip(D.keys(), j))
        assigned = assign(assigned, fixed, F)
        if next_fixeds_funcs:
            do_timesteps(next_fixeds_funcs, assigned)


def main():
    fixeds_funcs = [
        ({"B": 0}, func),
        ({"A": 1}, func2),
        ({"A": 1}, func2),
    ]
    do_timesteps(fixeds_funcs)