Question

我在参数嵌套循环中找到了很好的答案-Parametric nested loops in Python

但是，我的要求有点困难

问题：

这是3深度嵌套循环（我想要具有n深度的函数）：

for i in range(100 + 1):
    for j in range(i, 100 + 1):
        for k in range(j, 100 + 1):
            -> need to retrieve [i,j,k]

请注意，每个循环的起点都是动态的，并且随每个父循环而变化

Answer 1

这可以递归地完成（正如您已经猜到的），例如通过这种方式：

def nest_gen(count, start=0, end=101):
    if count < 1:
        return
    elif count == 1:
        yield from ((r,) for r in range(start, end))
        return

    for i in range(start, end):
        yield from ((i,) + r for r in nest_gen(count - 1, i, end))


print(tuple(nest_gen(6, end=5)))

Answer 2

这是我将递归用于的事情-正如我在标签中所看到的那样。像这样的东西，例如：

def iterate(depth, i=0, maxrange=101):
    if depth <= 0:
        return (yield ())
    for j in range(i, maxrange):                    # for each value of j...
        if depth == 1:                              # base case:
            yield (j,)                              #    return a 1-tuple
        else:                                       # recursive case:
            for k in iterate(depth-1, j, maxrange): #    get a generator for the next level of recursion
                yield (j,) + k                      #    yield all (depth+1)-tuples from prepending j to the next layer of recursion

当被称为iterate(3)时应该产生

[(0,0,0), (0,0,1), (0,0,2), ..., (0,0,100), (0,1,1), ..., (0,100,100), (1,1,1), ..., (99,99,99), (100,100,100)]

Answer 3

这是一种迭代方法：

def iterate(max_range, dim):
    if dim == 0:  #handle edge case
        yield from iter(())
    elif dim == 1:
        yield [0]
    else:
        fields = [0]*dim
        while True:
            yield fields
            fields[-1] += 1
            for i in reversed(range(1, dim)):
                if fields[i] >= max_range:
                    fields[i - 1] += 1
                    fields[i] = min(fields[i - 1], max_range -1)
            if fields[0] == max_range:
                break

一个例子：

for i in iterate(4, 3):
    print(i)

给予：

[0, 0, 0]
[0, 0, 1]
[0, 0, 2]
[0, 0, 3]
[0, 1, 1]
[0, 1, 2]
[0, 1, 3]
[0, 2, 2]
[0, 2, 3]
[0, 3, 3]
[1, 1, 3]
[1, 2, 2]
[1, 2, 3]
[1, 3, 3]
[2, 2, 3]
[2, 3, 3]
[3, 3, 3]

编辑：为max_value和嵌套级别添加了单独的参数

Answer 4

这是使用默认参数的递归方法。下面的编号点表示代码中的编号注释。

（基本），深度为零。我们完成了，因此产生组合comb
（归纳）深度至少为1。对于范围中的每个x，使用x作为嵌套范围的新起点将其委托给递归生成器，并附加{{1} }合并到x。

comb

这是三（3）级深的嵌套范围-

def nested_range (depth = 0, start = 0, end = 1, comb = ()):
  if depth == 0:
    yield comb                  #1
  else:
    for x in range(start, end): #2
      yield from nested_range(depth - 1, x, end, comb + (x,))

此实现是一个总体功能，当for p in nested_range (3, 0, 4): print(p) # (0, 0, 0) # (0, 0, 1) # (0, 0, 2) # (0, 0, 3) # (0, 1, 1) # (0, 1, 2) # (0, 1, 3) # (0, 2, 2) # (0, 2, 3) # (0, 3, 3) # (1, 1, 1) # (1, 1, 2) # (1, 1, 3) # (1, 2, 2) # (1, 2, 3) # (1, 3, 3) # (2, 2, 2) # (2, 2, 3) # (2, 3, 3) # (3, 3, 3)-

时提供有效结果

depth = 0

好的，这是一个嵌套的深度为五（5）层的输出-

for p in nested_range (0, 0, 4):
  print(p)

# ()

Python-高级参数嵌套循环

4 个答案: