Python 用于在可变数量的独立列表上循环的算法名称

请原谅我的问题含糊不清，我没有任何正式的CS培训。我很确定已经有了一个解决方案，但我找不到答案，因为我不知道该问什么问题

本质上，我在寻找一个算法或一组算法的名称，以找到多个列表的所有组合，其中每个列表包含单个位置的可能性。也就是说，一些可以执行映射的函数：

((a,b,c), (1,2), (z,g,h), (7)) ->
    ((a,1,z,7), (a,1,g,7), (a,1,h,7), (a,2,z,7), ... (c,2,h,7))

这样，结果可以用于按顺序迭代每个位置列表的所有可能组合

列表的数量是可变的，每个列表的大小是可变的，与其他列表无关。所有示例解决方案至少缺少其中一个标准

如果有人知道这些算法的伪代码或示例实现，或者一个能够处理这些问题的Python包，那将是非常棒的

我以前可以并且已经解决了这个问题，但是在我再次实现我的设计之前，我想知道是否有更好的解决方案

谢谢你抽出时间

对于那些好奇的人来说，我以前的解决方案与中描述的类似，这是我找到的唯一一个示例解决方案。然而，它没有指出问题所在，也没有给我进一步研究的起点。下面是我的通用解决方案的（未经测试的）Python列表：

def nloop(*args):
  lists = args
  n = len(lists) # Number of lists

  # Exit if no lists were passed
  if n <= 0:
    raise StopIteration

  i = [0] * n # Current index of each list
  l = [len(L) for L in lists] # Length of each list

  # Exit if any list is zero-length
  if min(l) <= 0:
    raise StopIteration

  while True:
    # Create and yield a list using the current indices
    yield tuple( lists[x][ i[x] ] for x in range(n) )

    # Increment the indices for the next loop
    # Move to the next item in the last list
    i[-1] += 1
    # Check the lists in reverse order to carry any
    # indices that have wrapped
    for x in reverse(list(range(n))):
      if i[x] >= l[x]:
        i[x] = 0
        if x > 0:
          i[x-1] += 1

    # If the first list has wrapped, we're done
    if i[0] >= l[0]:
      break

  raise StopIteration

def nloop（*args）：
列表=参数
n=len（列表）#列表数量
#如果未传递任何列表，则退出
如果n 0：
i[x-1]+=1
#如果第一个列表已经结束，我们就完成了
如果i[0]>=l[0]：
打破
提出停止迭代

您正在寻找的。它相当于您描述的任意深度的嵌套

for

循环

对于您的特定示例（经过适当的语法修改）：

---

实际上，我查看了itertools，但无论我找到什么文档，都只列出了/other/usage

产品（范围（2），repeat=3）

。永远不会失败，无论你在解决方案上投入了多少努力，在互联网上发布都会保证这是一个你忽略的简单解决方案。谢谢。不用担心，我发布的链接是你应该查看的官方文档。其他的一切都被冲淡了。是的，麻烦的是我知道这一点。再次感谢。@MattW。不用担心，你显然为此付出了很多努力，所以很高兴能提供帮助。如果此答案对您有效，则应选择此答案。等待6分钟计时器结束：）

>>> from itertools import product
>>> list(product(('a', 'b', 'c'), (1, 2), ('z', 'g', 'h'), (7,)))
[('a', 1, 'z', 7),
 ('a', 1, 'g', 7),
 ('a', 1, 'h', 7),
 ('a', 2, 'z', 7),
 ('a', 2, 'g', 7),
 ('a', 2, 'h', 7),
 ('b', 1, 'z', 7),
 ('b', 1, 'g', 7),
 ('b', 1, 'h', 7),
 ('b', 2, 'z', 7),
 ('b', 2, 'g', 7),
 ('b', 2, 'h', 7),
 ('c', 1, 'z', 7),
 ('c', 1, 'g', 7),
 ('c', 1, 'h', 7),
 ('c', 2, 'z', 7),
 ('c', 2, 'g', 7),
 ('c', 2, 'h', 7)]