Python 一般来说，遍历未知数量的列表的最佳方法是什么？

给定一种支持列表迭代的编程语言，即

for element in list do
    ...

如果我们有一个以动态列表数作为输入的程序，

list[1]。。。list[n]

（其中

n

可以取任何值），遍历这些列表中的每个元素组合的最佳方法是什么

e、 g.

list[1]=[1,2]

，

list[2]=[1,3]

然后我们迭代

[[1,1]，[1,3]，[2,1]，[2,3]

我认为我的想法不是很好：

1） 将这些列表中的一个大产品创建到

list\u product

（例如，在Python中，您可以多次使用

itertools.product（）

），然后迭代

list\u product

。问题是，这需要我们存储一个（可能很大的）iterable

2） 找到所有列表的长度与总长度的乘积，并使用模块化算术类型的思想，按照下面的思路进行操作

len_lists = [len(list[i]) for i in [1..n]]
total_length = Product(len_lists)
for i in [1 ... total_length] do
    total = i-1
    list_index = [1...n]
    for j in [n ... 1] do
        list_index[j] = IntegerPartOf(total / Product([1:j-1]))
        total = RemainderOf(total / Product([1:j-1]))
    od
    print list_index
od

其中，然后针对所有不同的组合打印

列表\索引

---

在速度方面有没有更好的方法（不要太在意可读性）？

您可以使用

itertools.product

，而无需具体化列表：

>>> from itertools import product
>>> lol = [[1,2],[1,3]]
>>> product(*lol)
<itertools.product object at 0xaa414b4>
>>> for x in product(*lol):
...     print x
...     
(1, 1)
(1, 3)
(2, 1)
(2, 3)

来自itertools导入产品的

>>
>>>lol=[[1,2]，[1,3]]
>>>产品（*lol）
>>>对于产品中的x（*lol）：
...     打印x
...     
(1, 1)
(1, 3)
(2, 1)
(2, 3)

至于性能，您很容易花更多的时间思考优化方法，而不是希望从优化中获得什么。如果您在循环中做任何事情，那么迭代开销本身很可能可以忽略不计。（最常见的例外情况是紧密的数值循环，在这种情况下，您应该尝试以数值形式进行。）

我的建议是使用

itertools.product

，继续你的一天

1） 将这些列表的一个大产品创建到列表产品中（例如，在Python中，您可以多次使用itertools.product（）），然后迭代列表产品。问题是，这需要我们存储一个（可能很大的）iterable

itertools

（以及通常的迭代器）的要点是，它们不是一次构造整个结果，而是一次创建并返回一个结果项。因此，如果您有一个列表列表

ListOfLists

，并且希望所有元组都包含其中每个列表中的一个元素，请使用

for elt in itertools.product(*ListOfLists):
   ...

---

请注意，您只需要调用

产品一次。它简单而高效
 子列表可以有不同数量的元素吗？