blocks|key|4130848|text|您可以创建一个递归函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4130849|def+group(d,+current+=+[],+in_place+=+[None,+3]):
++need,+_occurs+=+in_place
++if+len(current)+==+5+and+current.count(need)+==+_occurs:
++++yield+current
++else:
++++for+i+in+d:
++++++_c+=+current%2B[i]
++++++if+len(_c)+<=+5+and+_c.count(need)+<=+_occurs:
++++++++yield+from+group(d,+current+=+_c)|code-block|syntax|javascript|4130850|输出：|4130851|[[None,+None,+None,+0,+0],+[None,+None,+None,+0,+1],+[None,+None,+None,+0,+2],+[None,+None,+None,+1,+0],+[None,+None,+None,+1,+1],+[None,+None,+None,+1,+2],+[None,+None,+None,+2,+0],+[None,+None,+None,+2,+1],+[None,+None,+None,+2,+2],+[None,+None,+0,+None,+0],+[None,+None,+0,+None,+1],+[None,+None,+0,+None,+2],+[None,+None,+0,+0,+None],+[None,+None,+0,+1,+None],+[None,+None,+0,+2,+None],+[None,+None,+1,+None,+0],+[None,+None,+1,+None,+1],+[None,+None,+1,+None,+2],+[None,+None,+1,+0,+None],+[None,+None,+1,+1,+None],+[None,+None,+1,+2,+None],+[None,+None,+2,+None,+0],+[None,+None,+2,+None,+1],+[None,+None,+2,+None,+2],+[None,+None,+2,+0,+None],+[None,+None,+2,+1,+None],+[None,+None,+2,+2,+None],+[None,+0,+None,+None,+0],+[None,+0,+None,+None,+1],+[None,+0,+None,+None,+2],+[None,+0,+None,+0,+None],+[None,+0,+None,+1,+None],+[None,+0,+None,+2,+None],+[None,+0,+0,+None,+None],+[None,+0,+1,+None,+None],+[None,+0,+2,+None,+None],+[None,+1,+None,+None,+0],+[None,+1,+None,+None,+1],+[None,+1,+None,+None,+2],+[None,+1,+None,+0,+None],+[None,+1,+None,+1,+None],+[None,+1,+None,+2,+None],+[None,+1,+0,+None,+None],+[None,+1,+1,+None,+None],+[None,+1,+2,+None,+None],+[None,+2,+None,+None,+0],+[None,+2,+None,+None,+1],+[None,+2,+None,+None,+2],+[None,+2,+None,+0,+None],+[None,+2,+None,+1,+None],+[None,+2,+None,+2,+None],+[None,+2,+0,+None,+None],+[None,+2,+1,+None,+None],+[None,+2,+2,+None,+None],+[0,+None,+None,+None,+0],+[0,+None,+None,+None,+1],+[0,+None,+None,+None,+2],+[0,+None,+None,+0,+None],+[0,+None,+None,+1,+None],+[0,+None,+None,+2,+None],+[0,+None,+0,+None,+None],+[0,+None,+1,+None,+None],+[0,+None,+2,+None,+None],+[0,+0,+None,+None,+None],+[0,+1,+None,+None,+None],+[0,+2,+None,+None,+None],+[1,+None,+None,+None,+0],+[1,+None,+None,+None,+1],+[1,+None,+None,+None,+2],+[1,+None,+None,+0,+None],+[1,+None,+None,+1,+None],+[1,+None,+None,+2,+None],+[1,+None,+0,+None,+None],+[1,+None,+1,+None,+None],+[1,+None,+2,+None,+None],+[1,+0,+None,+None,+None],+[1,+1,+None,+None,+None],+[1,+2,+None,+None,+None],+[2,+None,+None,+None,+0],+[2,+None,+None,+None,+1],+[2,+None,+None,+None,+2],+[2,+None,+None,+0,+None],+[2,+None,+None,+1,+None],+[2,+None,+None,+2,+None],+[2,+None,+0,+None,+None],+[2,+None,+1,+None,+None],+[2,+None,+2,+None,+None],+[2,+0,+None,+None,+None],+[2,+1,+None,+None,+None],+[2,+2,+None,+None,+None]]|4130852|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You can create a recursive function:

<pre><code>def group(d, current = [], in_place = [None, 3]):
 need, _occurs = in_place
 if len(current) == 5 and current.count(need) == _occurs:
 yield current
 else:
 for i in d:
 _c = current+[i]
 if len(_c) &lt;= 5 and _c.count(need) &lt;= _occurs:
 yield from group(d, current = _c)
</code></pre>

Output:

<pre><code>[[None, None, None, 0, 0], [None, None, None, 0, 1], [None, None, None, 0, 2], [None, None, None, 1, 0], [None, None, None, 1, 1], [None, None, None, 1, 2], [None, None, None, 2, 0], [None, None, None, 2, 1], [None, None, None, 2, 2], [None, None, 0, None, 0], [None, None, 0, None, 1], [None, None, 0, None, 2], [None, None, 0, 0, None], [None, None, 0, 1, None], [None, None, 0, 2, None], [None, None, 1, None, 0], [None, None, 1, None, 1], [None, None, 1, None, 2], [None, None, 1, 0, None], [None, None, 1, 1, None], [None, None, 1, 2, None], [None, None, 2, None, 0], [None, None, 2, None, 1], [None, None, 2, None, 2], [None, None, 2, 0, None], [None, None, 2, 1, None], [None, None, 2, 2, None], [None, 0, None, None, 0], [None, 0, None, None, 1], [None, 0, None, None, 2], [None, 0, None, 0, None], [None, 0, None, 1, None], [None, 0, None, 2, None], [None, 0, 0, None, None], [None, 0, 1, None, None], [None, 0, 2, None, None], [None, 1, None, None, 0], [None, 1, None, None, 1], [None, 1, None, None, 2], [None, 1, None, 0, None], [None, 1, None, 1, None], [None, 1, None, 2, None], [None, 1, 0, None, None], [None, 1, 1, None, None], [None, 1, 2, None, None], [None, 2, None, None, 0], [None, 2, None, None, 1], [None, 2, None, None, 2], [None, 2, None, 0, None], [None, 2, None, 1, None], [None, 2, None, 2, None], [None, 2, 0, None, None], [None, 2, 1, None, None], [None, 2, 2, None, None], [0, None, None, None, 0], [0, None, None, None, 1], [0, None, None, None, 2], [0, None, None, 0, None], [0, None, None, 1, None], [0, None, None, 2, None], [0, None, 0, None, None], [0, None, 1, None, None], [0, None, 2, None, None], [0, 0, None, None, None], [0, 1, None, None, None], [0, 2, None, None, None], [1, None, None, None, 0], [1, None, None, None, 1], [1, None, None, None, 2], [1, None, None, 0, None], [1, None, None, 1, None], [1, None, None, 2, None], [1, None, 0, None, None], [1, None, 1, None, None], [1, None, 2, None, None], [1, 0, None, None, None], [1, 1, None, None, None], [1, 2, None, None, None], [2, None, None, None, 0], [2, None, None, None, 1], [2, None, None, None, 2], [2, None, None, 0, None], [2, None, None, 1, None], [2, None, None, 2, None], [2, None, 0, None, None], [2, None, 1, None, None], [2, None, 2, None, None], [2, 0, None, None, None], [2, 1, None, None, None], [2, 2, None, None, None]]
</code></pre>

blocks|key|4130859|text|from+itertools+import+product

elemets+=+[None,+0,+1,+2]
l+=+product(elemets,+repeat=5)
s+=+set(p+for+p+in+l+if+p.count(None)+==+3)

print(s)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4130860|输出：|unstyled|4130861|{(None,+None,+None,+0,+2),+(None,+None,+0,+None,+2),+(1,+2,+None,+None,+None),+(0,+None,+None,+1,+None),+(1,+None,+2,+None,+None),+(1,+None,+None,+2,+None),+(None,+2,+1,+None,+None),+(None,+None,+None,+2,+1),+(None,+None,+2,+None,+1),+(None,+None,+None,+1,+1),+(None,+0,+None,+0,+None),+(None,+0,+0,+None,+None),+(None,+1,+None,+None,+1),+(2,+1,+None,+None,+None),+(2,+None,+None,+1,+None),+(None,+0,+None,+None,+1),+(None,+0,+None,+1,+None),+(0,+None,+None,+0,+None),+(0,+None,+0,+None,+None),+(None,+None,+1,+1,+None),+(1,+None,+None,+1,+None),+(2,+None,+None,+2,+None),+(2,+None,+2,+None,+None),+(None,+None,+2,+None,+0),+(None,+None,+None,+2,+0),+(None,+None,+None,+1,+2),+(0,+0,+None,+None,+None),+(None,+0,+None,+None,+0),+(2,+0,+None,+None,+None),+(None,+None,+0,+1,+None),+(None,+None,+1,+2,+None),+(None,+0,+None,+2,+None),+(None,+0,+2,+None,+None),+(0,+1,+None,+None,+None),+(None,+2,+None,+2,+None),+(None,+2,+2,+None,+None),+(None,+1,+None,+1,+None),+(None,+None,+1,+None,+0),+(2,+None,+None,+None,+2),+(2,+2,+None,+None,+None),+(2,+None,+None,+0,+None),+(2,+None,+0,+None,+None),+(None,+1,+None,+2,+None),+(None,+1,+2,+None,+None),+(0,+None,+1,+None,+None),+(0,+None,+None,+None,+1),+(None,+None,+None,+0,+1),+(None,+None,+0,+None,+1),+(None,+2,+None,+1,+None),+(None,+0,+None,+None,+2),+(None,+None,+1,+None,+1),+(2,+None,+1,+None,+None),+(2,+None,+None,+None,+1),+(None,+None,+0,+2,+None),+(1,+None,+None,+None,+0),+(None,+1,+None,+None,+2),+(None,+0,+1,+None,+None),+(0,+None,+None,+None,+2),+(None,+2,+None,+None,+2),+(0,+None,+None,+None,+0),+(None,+None,+0,+0,+None),+(None,+None,+2,+2,+None),+(None,+None,+None,+0,+0),+(None,+None,+0,+None,+0),+(None,+2,+None,+0,+None),+(None,+2,+0,+None,+None),+(1,+None,+1,+None,+None),+(None,+None,+1,+None,+2),+(2,+None,+None,+None,+0),+(0,+2,+None,+None,+None),+(1,+None,+None,+0,+None),+(1,+None,+None,+None,+1),+(1,+None,+0,+None,+None),+(None,+None,+1,+0,+None),+(None,+1,+None,+0,+None),+(None,+1,+0,+None,+None),+(None,+None,+2,+1,+None),+(None,+2,+None,+None,+1),+(1,+1,+None,+None,+None),+(None,+None,+None,+2,+2),+(1,+None,+None,+None,+2),+(0,+None,+None,+2,+None),+(0,+None,+2,+None,+None),+(None,+1,+1,+None,+None),+(None,+None,+None,+1,+0),+(None,+None,+2,+None,+2),+(None,+1,+None,+None,+0),+(None,+None,+2,+0,+None),+(1,+0,+None,+None,+None),+(None,+2,+None,+None,+0)}|4130862|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>from itertools import product

elemets = [None, 0, 1, 2]
l = product(elemets, repeat=5)
s = set(p for p in l if p.count(None) == 3)

print(s)
</code></pre>

Output:

<pre><code>{(None, None, None, 0, 2), (None, None, 0, None, 2), (1, 2, None, None, None), (0, None, None, 1, None), (1, None, 2, None, None), (1, None, None, 2, None), (None, 2, 1, None, None), (None, None, None, 2, 1), (None, None, 2, None, 1), (None, None, None, 1, 1), (None, 0, None, 0, None), (None, 0, 0, None, None), (None, 1, None, None, 1), (2, 1, None, None, None), (2, None, None, 1, None), (None, 0, None, None, 1), (None, 0, None, 1, None), (0, None, None, 0, None), (0, None, 0, None, None), (None, None, 1, 1, None), (1, None, None, 1, None), (2, None, None, 2, None), (2, None, 2, None, None), (None, None, 2, None, 0), (None, None, None, 2, 0), (None, None, None, 1, 2), (0, 0, None, None, None), (None, 0, None, None, 0), (2, 0, None, None, None), (None, None, 0, 1, None), (None, None, 1, 2, None), (None, 0, None, 2, None), (None, 0, 2, None, None), (0, 1, None, None, None), (None, 2, None, 2, None), (None, 2, 2, None, None), (None, 1, None, 1, None), (None, None, 1, None, 0), (2, None, None, None, 2), (2, 2, None, None, None), (2, None, None, 0, None), (2, None, 0, None, None), (None, 1, None, 2, None), (None, 1, 2, None, None), (0, None, 1, None, None), (0, None, None, None, 1), (None, None, None, 0, 1), (None, None, 0, None, 1), (None, 2, None, 1, None), (None, 0, None, None, 2), (None, None, 1, None, 1), (2, None, 1, None, None), (2, None, None, None, 1), (None, None, 0, 2, None), (1, None, None, None, 0), (None, 1, None, None, 2), (None, 0, 1, None, None), (0, None, None, None, 2), (None, 2, None, None, 2), (0, None, None, None, 0), (None, None, 0, 0, None), (None, None, 2, 2, None), (None, None, None, 0, 0), (None, None, 0, None, 0), (None, 2, None, 0, None), (None, 2, 0, None, None), (1, None, 1, None, None), (None, None, 1, None, 2), (2, None, None, None, 0), (0, 2, None, None, None), (1, None, None, 0, None), (1, None, None, None, 1), (1, None, 0, None, None), (None, None, 1, 0, None), (None, 1, None, 0, None), (None, 1, 0, None, None), (None, None, 2, 1, None), (None, 2, None, None, 1), (1, 1, None, None, None), (None, None, None, 2, 2), (1, None, None, None, 2), (0, None, None, 2, None), (0, None, 2, None, None), (None, 1, 1, None, None), (None, None, None, 1, 0), (None, None, 2, None, 2), (None, 1, None, None, 0), (None, None, 2, 0, None), (1, 0, None, None, None), (None, 2, None, None, 0)}
</code></pre>

blocks|key|4130948|text|如果我真的不想生成和过滤掉一堆不合适的条目，我会这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4130949|您需要0到3个代码项(称为n1)，然后是列表中的一个非None项，然后是0到3-n1+Nones+(n2)，然后是列表中的第二个非None项，最后是3-n1-n2+<n2>D9None>s。|offset|length|style|CODE|4130950|states+=+[]
for+(i1,+i2)+in+permutations((0,1,2),+2):
++++for+n1+in+range(4):
++++++++for+n2+in+range(4-n1):
++++++++++++states.append((None,)*n1+%2B+(i1,)+%2B+(None,)*n2+%2B+(i2,)+%2B+(None,)*(3-n1-n2))|code-block|syntax|javascript|4130951|entityMap^0|0|D|2|R|4|14|2|17|4|1E|2|1T|4|24|2|27|2|2B|2|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]|$D|S|E|T|F|G]|$D|U|E|V|F|G]|$D|W|E|X|F|G]|$D|Y|E|Z|F|G]|$D|10|E|11|F|G]|$D|12|E|13|F|G]|$D|14|E|15|F|G]|$D|16|E|17|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|18|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|N|$]]

Here's how I'd approach it if I really didn't want to generate and filter out a bunch of inappropriate entries:

You need 0 to 3 <code>None</code>s (call that number <code>n1</code>), followed by one non-<code>None</code> item from the list, followed by 0 to 3-<code>n1</code> <code>None</code>s (<code>n2</code>), followed by a second non-<code>None</code> item from the list, followed by 3-<code>n1</code>-<code>n2</code> <code>None</code>s.

<pre><code>states = []
for (i1, i2) in permutations((0,1,2), 2):
 for n1 in range(4):
 for n2 in range(4-n1):
 states.append((None,)*n1 + (i1,) + (None,)*n2 + (i2,) + (None,)*(3-n1-n2))
</code></pre>

blocks|key|4130446|text|假设(从您的代码输出和您故意添加多个0、1和2副本的事实)，您正在进行“置换和替换”，或者基本上是具有3个None需求的笛卡尔乘积，我会这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4130447|def+tien_gen(size,+values,+number_of_nones):
++++to_fill+=+size+-+number_of_nones
++++for+locs+in+itertools.combinations(range(size),+to_fill):
++++++++for+fill_values+in+itertools.product(values,+repeat=to_fill):
++++++++++++out+=+[None]+*+size
++++++++++++for+loc,+fill_value+in+zip(locs,+fill_values):
++++++++++++++++out[loc]+=+fill_value
++++++++++++yield+tuple(out)|code-block|syntax|javascript|4130448|它与您的输出相匹配：|4130449|In+[137]:+result+=+list(tien_gen(5,+[0,1,2],+3))

In+[138]:+len(result)
Out[138]:+90

In+[139]:+result
Out[139]:+
[(0,+0,+None,+None,+None),
+(0,+1,+None,+None,+None),
+(0,+2,+None,+None,+None),
+(1,+0,+None,+None,+None),
+[...]
+(None,+0,+None,+1,+None),
+(None,+0,+None,+2,+None),
+(None,+1,+None,+0,+None),
+[...]
+(None,+2,+None,+1,+None),
+(None,+2,+None,+2,+None),
+(None,+0,+None,+None,+0),
+(None,+0,+None,+None,+1),
+[...]
+(None,+None,+None,+1,+2),
+(None,+None,+None,+2,+0),
+(None,+None,+None,+2,+1),
+(None,+None,+None,+2,+2)]

In+[140]:+orig+=+[state+for+state+in+list(set(it.permutations((None,+None,+None,+0,+0,+1,+1,+2,+2),+5)))+if+state.count(None)==3]

In+[141]:+len(result)+==+len(orig)+and+set(result)+==+set(orig)
Out[141]:+True|4130450|对于较小的大小，优点是有限的，但对于较大的大小，这样就避免了生成任何不使用的元组，而且由于它是一个生成器，如果您不想实现所有元组，则不必全部实现它们。|4130451|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Assuming (from the output of your code and the fact you deliberately added multiple copies of 0, 1, and 2) that you're doing 'permutations with replacement', or basically the Cartesian product with your 3 Nones requirement, I'd do something like:

<pre><code>def tien_gen(size, values, number_of_nones):
 to_fill = size - number_of_nones
 for locs in itertools.combinations(range(size), to_fill):
 for fill_values in itertools.product(values, repeat=to_fill):
 out = [None] * size
 for loc, fill_value in zip(locs, fill_values):
 out[loc] = fill_value
 yield tuple(out)
</code></pre>

which matches your output:

<pre><code>In [137]: result = list(tien_gen(5, [0,1,2], 3))

In [138]: len(result)
Out[138]: 90

In [139]: result
Out[139]: 
[(0, 0, None, None, None),
 (0, 1, None, None, None),
 (0, 2, None, None, None),
 (1, 0, None, None, None),
 [...]
 (None, 0, None, 1, None),
 (None, 0, None, 2, None),
 (None, 1, None, 0, None),
 [...]
 (None, 2, None, 1, None),
 (None, 2, None, 2, None),
 (None, 0, None, None, 0),
 (None, 0, None, None, 1),
 [...]
 (None, None, None, 1, 2),
 (None, None, None, 2, 0),
 (None, None, None, 2, 1),
 (None, None, None, 2, 2)]

In [140]: orig = [state for state in list(set(it.permutations((None, None, None, 0, 0, 1, 1, 2, 2), 5))) if state.count(None)==3]

In [141]: len(result) == len(orig) and set(result) == set(orig)
Out[141]: True
</code></pre>

For small sizes the advantages are limited, but for larger ones, this way you avoid generating any tuple that you don't use, and since it's a generator, you don't have to materialize them all if you don't want to.

blocks|key|4131071|text|从概念上讲，我认为最简单的“高效”算法可以解释为:首先生成长度为2的排列。然后，以所有可能的方式插入3个None实例。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4131072|但是，更有效的方法是:首先，在您希望的两个元素所在的位置生成所有索引。然后，对于长度为2的每个排列的每组索引，替换给定索引中的这些元素。|4131073|from+itertools+import+combinations,+permutations,+product

base_list+=+[None]+*+5
values+=+[0,+1,+2]

all_indices+=+combinations(range(5),+2)
all_perms+=+permutations(values,+2)

for+(i,+j),+(x,+y)+in+product(all_indices,+all_perms):
++++list_copy+=+base_list[:]
++++list_copy[i]+=+x
++++list_copy[j]+=+y
++++print(list_copy)

#+[0,+1,+None,+None,+None]
#+[0,+2,+None,+None,+None]
#+...
#+[None,+None,+None,+2,+0]
#+[None,+None,+None,+2,+1]|code-block|syntax|javascript|4131074|对于不同长度的输入，这应该是易于扩展的。|4131075|def+inserted_permutations(size,+values,+insert_count,+default=None):
++++base+=+[default]+*+size
++++all_indices+=+combinations(range(size),+insert_count)
++++all_perms+=+permutations(values,+insert_count)
++++for+indices,+values+in+product(all_indices,+all_perms):
++++++++base_copy+=+base[:]
++++++++for+index,+value+in+zip(indices,+values):
++++++++++++base_copy[index]+=+value
++++++++yield+base_copy|4131076|entityMap^0|1G|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|X|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|R|$]]

Conceptually, I think the easiest "efficient" algorithm might be explained as: First generate the permutations of length 2. Then, insert 3 instances of <code>None</code> in all possible ways.

However, it is more efficient to instead: First, generate all indices where you want your two elements to be. Then, for each set of indices for each permutation of length 2, substitute these elements in the given indices.

<pre><code>from itertools import combinations, permutations, product

base_list = [None] * 5
values = [0, 1, 2]

all_indices = combinations(range(5), 2)
all_perms = permutations(values, 2)

for (i, j), (x, y) in product(all_indices, all_perms):
 list_copy = base_list[:]
 list_copy[i] = x
 list_copy[j] = y
 print(list_copy)

# [0, 1, None, None, None]
# [0, 2, None, None, None]
# ...
# [None, None, None, 2, 0]
# [None, None, None, 2, 1]
</code></pre>

This should be readily extensible for inputs of different lengths.

<pre><code>def inserted_permutations(size, values, insert_count, default=None):
 base = [default] * size
 all_indices = combinations(range(size), insert_count)
 all_perms = permutations(values, insert_count)
 for indices, values in product(all_indices, all_perms):
 base_copy = base[:]
 for index, value in zip(indices, values):
 base_copy[index] = value
 yield base_copy
</code></pre>

I want to generate permutations (tuples) from these elements: 

<pre><code>[None, 0, 1, 2]. 
</code></pre>

I want each permutation to have length 5 and always contain 3 Nones. An example of one such permutation: 

<pre><code>(None, 0, None, None, 1).
</code></pre>

I have currently created this algorithm in Python 3.x: 

<pre><code>[state for state in list(set(it.permutations((None, None, None, 0, 0, 1, 1, 2, 2), 5))) if state.count(None)==3]
</code></pre>

However, I feel this algorithm is sub-optimal (and, well, ugly) and I am not entirely sure it is even correct. Are there any better solutions? I have perused NumPy, but found nothing that would help me.

Thanks for the help!

Generate all permutations where length of a permutation > # of elements in Python

Python

我想从这些元素生成排列(元组)：[None, 0, 1, 2]. 我希望每个排列的长度为5，并且始终包含3个None。一个这样的排列的例子：(None, 0, None, None, 1).我目前在Python 3.x中创建了这个算法：[state for state in list(set(it.permutatio...

问生成所有排列，其中排列的长度> Python中的元素数
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问生成所有排列，其中排列的长度> Python中的元素数EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问生成所有排列，其中排列的长度> Python中的元素数
EN