从嵌套循环创建递归函数，并沿途进行动态分配

Question

这让我有点难过，但总而言之，我正在研究一个图形问题，我 'walking' 沿着图形（暂时）计算事物并沿途分配变量。目前，我有一个带有嵌套 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

编辑：基于评论的新迭代（递归）

这会为所有生成的值调用 fixeds/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)

从嵌套循环创建递归函数，并沿途进行动态分配

Creating a recursive function from nested loops with dynamic assigns along the way

python

recursion

for-loop

nested-loops

MWE

设置

第一个时间步长（索引）

第二个时间步长（索引）

第三个时间步长（索引）

编辑：基于评论的新迭代（递归）