запуск вложенного цикла в списке неизвестной длины

Question

Я определил список как:

comp = []
comp.append(["A", "B", "C", "D"])
comp.append(["E", "F", "I"])

В реальном случае я не знаю длины comp или comp[x]

Теперь я пытаюсь запустить вложенный цикл для этого, но не удалось. Я имею в виду, если я запускаю свой текущий фрагмент:

for compsi in range(len(comp)):
  for elemn in range(len(comp[compsi])):
    print(comp[compsi][elemn])

вывод A B C D E F I.

Я пытаюсь выполнить для каждого элемента comp[0] полную comp[1], чтобы я получил: A E F I B F I C F I D E F I и т. Д .;

Когда я знаю, что я len(comp) = 2, я могу легко сделать это, используя вложенный цикл for:

for lo in range(len(comp[0])):
  for l1 in range(len(comp[1])):
    print(...)

Но как мне достичь того же, когда я не знаю длины comp?

Пожалуйста, помогите!

Хорошо, скажем, у нас есть comp=[['A', 'B', 'C', 'D'], ['E', 'F', 'G'], ['H'], ['I', 'J','K']]. Мы закончим с:

A E H I  
A E H J  
A E H K  
A F H I 
...
B E H I 
B E H J 
B E H K
...
D G H K 

таким образом.

Answer 1

Если ваш второй приведенный пример со списком [('A', 'B', 'C', 'D'), ('E', 'F', 'G'), ('H',), ('I', 'J', 'K')] правильный, вы можете использовать комбинацию itertools.product и functools.reduce для достижения того, что вы ищете:

from functools import reduce
from itertools import product
comp = [('A', 'B', 'C', 'D'), ('E', 'F', 'G'), ('H',), ('I', 'J', 'K')]
print(list(reduce(lambda a, b: [(*p[0], p[1]) for p in product(a, b)], comp)))

Это выводит:

[('A', 'E', 'H', 'I'), ('A', 'E', 'H', 'J'), ('A', 'E', 'H', 'K'), ('A', 'F', 'H', 'I'), ('A', 'F', 'H', 'J'), ('A', 'F', 'H', 'K'), ('A', 'G', 'H', 'I'), ('A', 'G', 'H', 'J'), ('A', 'G', 'H', 'K'), ('B', 'E', 'H', 'I'), ('B', 'E', 'H', 'J'), ('B', 'E', 'H', 'K'), ('B', 'F', 'H', 'I'), ('B', 'F', 'H', 'J'), ('B', 'F', 'H', 'K'), ('B', 'G', 'H', 'I'), ('B', 'G', 'H', 'J'), ('B', 'G', 'H', 'K'), ('C', 'E', 'H', 'I'), ('C', 'E', 'H', 'J'), ('C', 'E', 'H', 'K'), ('C', 'F', 'H', 'I'), ('C', 'F', 'H', 'J'), ('C', 'F', 'H', 'K'), ('C', 'G', 'H', 'I'), ('C', 'G', 'H', 'J'), ('C', 'G', 'H', 'K'), ('D', 'E', 'H', 'I'), ('D', 'E', 'H', 'J'), ('D', 'E', 'H', 'K'), ('D', 'F', 'H', 'I'), ('D', 'F', 'H', 'J'), ('D', 'F', 'H', 'K'), ('D', 'G', 'H', 'I'), ('D', 'G', 'H', 'J'), ('D', 'G', 'H', 'K')]

Но затем, учитывая ваш первый пример [('A', 'B', 'C', 'D'), ('E', 'F', 'I')], вместо него будет выведено следующее:

[('A', 'E'), ('A', 'F'), ('A', 'I'), ('B', 'E'), ('B', 'F'), ('B', 'I'), ('C', 'E'), ('C', 'F'), ('C', 'I'), ('D', 'E'), ('D', 'F'), ('D', 'I')]

Я предполагаю, что ваш второй пример верен, потому что логика, лежащая в основе вашего первого примера, просто не будет иметь смысла, когда он масштабируется до длины, большей 2.