Python：如何在列表或元组中循环/迭代列表 - 特殊的唯一输出？ [关闭]

Question

我需要帮助

这是我的列表和元组。我不知道哪个更适合解决方案，所以我在这里打印两者。

我在这里只使用列表来展示我的问题。

x11 = ["1", "x", "t", "f", "T"]
x12 = ["C", "D", "6"]
x13 = ["5", "9", "J", "D"]
x14 = ["e", "a", "o", "x", "f", "z"]
x15 = ["1", "x", "7", "f", "T"]
x16 = ["D", "O", "0", "B", "8", "Q", "q"]
x17 = ["c", "a"]
x18 = ["9", "J", "7", "f", "I"]
x19 = ["C", "O", "D", "0", "6"]
x20 = ["P", "F", "C"]

xlist1 = [x11,x12,x13,x14,x15,x16,x17,x18,x19,x20]

t11 = ("1", "x", "t", "f", "T")
t12 = ("C", "D", "6")
t13 = ("5", "9", "J", "D")
t14 = ("e", "a", "o", "x", "f", "z")
t15 = ("1", "x", "7", "f", "T")
t16 = ("D", "O", "0", "B", "8", "Q", "q")
t17 = ("c", "a")
t18 = ("9", "J", "7", "f", "I")
t19 = ("C", "O", "D", "0", "6")
t20 = ("P", "F", "C")

tuple1 = (t11,t12,t13,t14,t15,t16,t17,t18,t19,t20)

我希望在 xlist1/tuple1 上进行迭代/循环以获取特殊格式的新列表/元组。 目标输出列表/元组应该是唯一的。

output = (["1C5e1Dc9CP"],["xC5e1Dc9CP"],["tC5e1Dc9CP"],["FC5e1Dc9CP"],["TC5e1Dc9CP"],
         ["1D5e1Dc9CP"],["165e1Dc9CP"],
         ["1C9e1Dc9CP"],["1CJe1Dc9CP"],["1CDe1Dc9CP"],
         ["1C5a1Dc9CP"],["1C5o1Dc9CP"],["1C5x1Dc9CP"],["1C5f1Dc9CP"],["1C5z1Dc9CP"],
         ...
         ["T6DzTqaI6C"])

迭代所有指标：

'1D5e1Dc9CP'    '1D5e1Dc9CP'    '1D9e1Dc9CP'    '1DJe1Dc9CP'    '1DDe1Dc9CP'    '1D5a1Dc9CP'    '1D5o1Dc9CP'    '1D5x1Dc9CP'    '1D5f1Dc9CP'    '1D5z1Dc9CP'    '1D5exDc9CP'    '1D5e7Dc9CP'    '1D5efDc9CP'    '1D5eTDc9CP'    '1D5e1Oc9CP'    '1D5e10c9CP'    '1D5e1Bc9CP'    '1D5e18c9CP'    '1D5e1Qc9CP'    '1D5e1qc9CP'    '1D5e1Da9CP'    '1D5e1DcJCP'    '1D5e1Dc7CP'    '1D5e1DcfCP'    '1D5e1DcICP'    '1D5e1Dc9OP'    '1D5e1Dc9DP'    '1D5e1Dc90P'    '1D5e1Dc96P'    '1D5e1Dc9CF'    '1D5e1Dc9CC'
'xD5exDc9CP'    'x65exDc9CP'    'xC9exDc9CP'    'xCJe1Dc9CP'    'xCDe1Dc9CP'    'xC5a1Dc9CP'    'xC5o1Dc9CP'    'xC5x1Dc9CP'    'xC5f1Dc9CP'    'xC5z1Dc9CP'    'xC5exDc9CP'    'xC5e7Dc9CP'    'xC5efDc9CP'    'xC5eTDc9CP'    'xC5e1Oc9CP'    'xC5e10c9CP'    'xC5e1Bc9CP'    'xC5e18c9CP'    'xC5e1Qc9CP'    'xC5e1Qc9CP'    'xC5e1Da9CP'    'xC5e1DcJCP'    'xC5e1Dc7CP'    'xC5e1DcfCP'    'xC5e1DcICP'    'xC5e1Dc9OP'    'xC5e1Dc9DP'    'xC5e1Dc90P'    'xC5e1Dc96P'    'xC5e1Dc9CF'    'xC5e1Dc9CC'
'TC5e1Dc9CP'    'TCJe1Dc9CP'    'TCDe1Dc9CP'    'TC5a1Dc9CP'    'TC5o1Dc9CP'    'TC5x1Dc9CP'    'TC5f1Dc9CP'    'TC5z1Dc9CP'    'TC5exDc9CP'    'TC5e7Dc9CP'    'TC5efDc9CP'    'TC5eTDc9CP'    'TC5e1Oc9CP'    'TC5e10c9CP'    'TC5e1Bc9CP'    'TC5e18c9CP'    'TC5e1Qc9CP'    'TC5e1qc9CP'    'TC5e1Da9CP'    'TC5e1DcJCP'    'TC5e1Dc7CP'    'TC5e1DcfCP'    'TC5e1DcICP'    'TC5e1Dc9OP'    'TC5e1Dc9DP'    'TC5e1Dc90P'    'TC5e1Dc96P'    'TC5e1Dc9CF'    'TC5e1Dc9CC'        
'TD5e1Dc9CP'    'TDJe1Dc9CP'    'TDDe1Dc9CP'    'TD5a1Dc9CP'    'TD5o1Dc9CP'    'TD5x1Dc9CP'    'TD5f1Dc9CP'    'TD5z1Dc9CP'    'TD5exDc9CP'    'TD5e7Dc9CP'    'TD5efDc9CP'    'TD5eTDc9CP'    'TD5e1Oc9CP'    'TD5e10c9CP'    'TD5e1Bc9CP'    'TD5e18c9CP'    'TD5e1Qc9CP'    'TD5e1qc9CP'    'TD5e1Da9CP'    'TD5e1DcJCP'    'TD5e1Dc7CP'    'TD5e1DcfCP'    'TD5e1DcICP'    'TD5e1Dc9OP'    'TD5e1Dc9DP'    'TD5e1Dc90P'    'TD5e1Dc96P'    'TD5e1Dc9CF'    'TD5e1Dc9CC'        
'T65e1Dc9CP'    'T6Je1Dc9CP'    'T6De1Dc9CP'    'T65a1Dc9CP'    'T65o1Dc9CP'    'T65x1Dc9CP'    'T65f1Dc9CP'    'T65z1Dc9CP'    'T65exDc9CP'    'T65e7Dc9CP'    'T65efDc9CP'    'T65eT6c9CP'    'T65e1Oc9CP'    'T65e10c9CP'    'T65e1Bc9CP'    'T65e18c9CP'    'T65e1Qc9CP'    'T65e1qc9CP'    'T65e1Da9CP'    'T65e1DcJCP'    'T65e1Dc7CP'    'T65e1DcfCP'    'T65e1DcICP'    'T65e1Dc9OP'    'T65e1Dc9DP'    'T65e1Dc90P'    'T65e1Dc96P'    'T65e1Dc9CF'    'T65e1Dc9CC'        

这里我展示了带有inidicies的迭代算法：

output = ([x11[0]+x12[0]+x13[0]+x14[0]+x15[0]+x16[0]+x17[0]+x18[0]+x19[0]+x20[0]], 
         # 1C5e1Dc9CP
          [x11[1]+x12[0]+x13[0]+x14[0]+x15[0]+x16[0]+x17[0]+x18[0]+x19[0]+x20[0]], 
         # xC5e1Dc9CP 
          [x11[2]+x12[0]+x13[0]+x14[0]+x15[0]+x16[0]+x17[0]+x18[0]+x19[0]+x20[0]], 
         # tC5e1Dc9CP
          [x11[3]+x12[0]+x13[0]+x14[0]+x15[0]+x16[0]+x17[0]+x18[0]+x19[0]+x20[0]], 
         # FC5e1Dc9CP
          [x11[4]+x12[0]+x13[0]+x14[0]+x15[0]+x16[0]+x17[0]+x18[0]+x19[0]+x20[0]], 
         # TC5e1Dc9CP

          [x11[0]+x12[1]+x13[0]+x14[0]+x15[0]+x16[0]+x17[0]+x18[0]+x19[0]+x20[0]], 
         # 1D5e1Dc9CP
          [x11[0]+x12[1]+x13[0]+x14[0]+x15[0]+x16[0]+x17[0]+x18[0]+x19[0]+x20[0]], 
         # 165e1Dc9CP

          [x11[0]+x12[0]+x13[1]+x14[0]+x15[0]+x16[0]+x17[0]+x18[0]+x19[0]+x20[0]], 
         # 1C9e1Dc9CP
          [x11[0]+x12[0]+x13[2]+x14[0]+x15[0]+x16[0]+x17[0]+x18[0]+x19[0]+x20[0]], 
         # 1CJe1Dc9CP
          [x11[0]+x12[0]+x13[3]+x14[0]+x15[0]+x16[0]+x17[0]+x18[0]+x19[0]+x20[0]], 
         # 1CDe1Dc9CP

          [x11[0]+x12[1]+x13[0]+x14[1]+x15[0]+x16[0]+x17[0]+x18[0]+x19[0]+x20[0]], 
         # 1C5a1Dc9CP
          [x11[0]+x12[1]+x13[0]+x14[2]+x15[0]+x16[0]+x17[0]+x18[0]+x19[0]+x20[0]], 
         # 1C5o1Dc9CP
          [x11[0]+x12[1]+x13[0]+x14[3]+x15[0]+x16[0]+x17[0]+x18[0]+x19[0]+x20[0]], 
         # 1C5x1Dc9CP
          [x11[0]+x12[1]+x13[0]+x14[4]+x15[0]+x16[0]+x17[0]+x18[0]+x19[0]+x20[0]], 
         # 1C5f1Dc9CP
          [x11[0]+x12[1]+x13[0]+x14[5]+x15[0]+x16[0]+x17[0]+x18[0]+x19[0]+x20[0]], 
         # 1C5z1Dc9CP
          ...
          [x11[4]+x12[2]+x13[3]+x14[5]+x15[4]+x16[6]+x17[1]+x18[5]+x19[4]+x20[2]]) 
         # T6DzTqaI6C

因此，重要的是输出元组/列表是唯一的并且具有相同的长度== 10 chars、(len(xlist1)) 并且始终是方向 从 x11 .. x20.

我已经尝试过，但它并没有解决它......

combs = functools.reduce(lambda x, y: list(itertools.combinations(xlist1, y)) + x, range(len(xlist1)+1), [])
for c in combs:
    print ("Combination:", c)

或

combs = list(itertools.combinations(tuple1, r=x))
permutations = list(itertools.permutations(xlist1, r=None)) # terminal killed it :/

有人有建议、想法或解决方案吗？

Answer 1

要获得列表的完整产品，您需要：

list(itertools.product(*tuple1))

您的输入将是 160 万个元素：

['1C5e1Dc9CP', '1C5e1Dc9CF', '1C5e1Dc9CC', '1C5e1Dc9OP', '1C5e1Dc9OF', 
 '1C5e1Dc9OC', '1C5e1Dc9DP', '1C5e1Dc9DF', '1C5e1Dc9DC', '1C5e1Dc90P' ...]

要分块，请编写分块函数：

def chunker(gen, size):
    while True:
        lst = []
        for _ in range(size):
            lst.append(next(gen))
        yield lst

product_generator = itertools.product(*tuple1)
chunks = chunker(product_generator, 50000)

然后你通过

获得每个块

chunk = next(chunks)

---

下面是上一个答案，它不会生成列表的完整产品：

这会生成一个列表，并且可以正确处理要在整个基中迭代单个元素的任意列表的重复项。

full = []
for piece_index in range(len(tuple1)):
    for inner_index in range(0 if piece_index == 0 else 1, len(tuple1[piece_index])):
        line = ""
        for index in range(len(tuple1)):
            line += tuple1[index][inner_index if piece_index == index else 0]
        full.append(line)

这是通过逐个列表、逐个元素并围绕该元素构建一个字符串来实现的。它还会跳过除第一个之外的每个列表中的第一个元素，因为它只是第一个元素的副本。

• piece_index 跟踪我们当前正在处理的子列表。
• inner_index 跟踪我们当前正在构建关于该子列表中的哪个元素的字符串
• index 是我们当前使用的围绕 tuple1[piece_index][inner_index] 构建的字符串中的哪个字符。

结果：

['1C5e1Dc9CP', 'xC5e1Dc9CP', 'tC5e1Dc9CP', 'fC5e1Dc9CP', 'TC5e1Dc9CP', 
 '1D5e1Dc9CP', '165e1Dc9CP', 
 '1C9e1Dc9CP', '1CJe1Dc9CP', '1CDe1Dc9CP', 
 '1C5a1Dc9CP', '1C5o1Dc9CP', '1C5x1Dc9CP', '1C5f1Dc9CP', '1C5z1Dc9CP', 
 '1C5exDc9CP', '1C5e7Dc9CP', '1C5efDc9CP', '1C5eTDc9CP', 
 '1C5e1Oc9CP', '1C5e10c9CP', '1C5e1Bc9CP', '1C5e18c9CP', '1C5e1Qc9CP', '1C5e1qc9CP', 
 '1C5e1Da9CP', 
 '1C5e1DcJCP', '1C5e1Dc7CP', '1C5e1DcfCP', '1C5e1DcICP', '1C5e1DcJCP', 
 '1C5e1Dc9OP', '1C5e1Dc9DP', '1C5e1Dc90P', '1C5e1Dc96P', 
 '1C5e1Dc9CF', '1C5e1Dc9CC']

如果您希望它们作为 1 个元素列表的元组，full.append([line]) 并在循环后添加 full = tuple(full) 将进行更改。

值得注意的是，这确实包含重复项 ('1C5e1DcJCP')，因为您的源列表包含重复项：t18 = ("9", "J", "7", "f", "I", "J")