n层嵌套循环的python实现

方法1

import itertools

ranges = [range(0, 2), range(1, 3), range(2, 4)]

for xs in itertools.product(*ranges):
    print(*xs)

方法2

def combine(body_todo):
    """
    input:
           body_todo:参数列表

    output:参数自由组合后的body数组

    example:
            input:
                [
                [a1,a2],
                [b]
                [c1,c2,c3],
                ]
            output:
                [
                [a1,b,c1],
                [a1,b,c2],
                [a1,b,c3],
                [a2,b,c1],
                [a2,b,c2],
                [a2,b,c3],
                ]

    n层嵌套循环,其中n为字段个数,各层嵌套循环的次数()分别为d1,d2,d3...dn,
    第k层的第i次循环的读取的值表示为vki,0≤i＜dk

    1.步进最内层n的指针 pn=0
    2.当第k层的指针pk==dk,下一次迭代第k层的指针设置为0 pk=0,并且第k-1层(进位+1) p(k-1)++
    3.当p1=d1-1,p2=d2-1...pn=dn-1,循环结束
    """
    body = []
    # 各层嵌套循环次数列表d_list=[d1,d2,d3...dn]
    n = len(body_todo)
    d_list = [len(e) for e in body_todo]
    end_list = [len(e) - 1 for e in body_todo]
    # 指针初始化列表pointer_list=[d1,d2,d3...dn]
    pointer_list = [0 for _ in body_todo]
    stop_flag = False

    while True:
        # 1.最内层指针自增1
        pointer_list[n - 1] = pointer_list[n - 1] + 1
        # 2.处理指针的模除和进位逻辑
        # k的取值k={n-1,n-2,...,1}
        # Q:为什么不访问指针p0?
        # A:(1)p0没有溢出的可能,在p0溢出前,停止标志stop_flag就已经为True(2)需要访问数组k-1的值,访问p0需要单独处理索引越界
        for k in range(n - 1, 0, -1):
            pointer_list[k - 1] = pointer_list[k - 1] + pointer_list[k] // d_list[k]
            pointer_list[k] = pointer_list[k] % d_list[k]

        # 3.更新是否停止迭代的标志
        stop_flag = pointer_list == end_list
        logging.debug(pointer_list)
        if stop_flag: break
        # 输出指针所指的组合t
        t = [body_todo[k][pointer_list[k]] for k in range(n)]
        body.append(t)
    return body