我可以用蛮力做到这一点，但我希望有聪明的编码，或者现有的功能，或者我没有意识到的东西......
所以我想要一些数字的例子：
00000000001111110000
11111100000000000000
01010101010100000000
10101010101000000000
00100100100100100100
完整的排列。除了结果只有六个1。不多。不低于。 64位或32位是理想的。如果提供答案，则为16位。
我认为你需要的是使用itertools模块。
坏的解决方案
但是你需要小心，例如，使用像permutations这样的东西只能用于非常小的输入。即：
像下面这样的东西会给你一个二进制表示：
>>> ["".join(v) for v in set(itertools.permutations(["1"]*2+["0"]*3))]
['11000', '01001', '00101', '00011', '10010', '01100', '01010', '10001', '00110', '10100']
然后只是得到这些数字的十进制表示：
>>> [int("".join(v), 16) for v in set(itertools.permutations(["1"]*2+["0"]*3))]
[69632, 4097, 257, 17, 65552, 4352, 4112, 65537, 272, 65792]
如果你想要32位，6个，26个零，你可以使用：
>>> [int("".join(v), 16) for v in set(itertools.permutations(["1"]*6+["0"]*26))]
但这个计算需要超级计算机来处理（32！= 263130836933693530167218012160000000）
解决方案
所以更聪明的方法是使用combinations，也许是这样的：
import itertools
num_bits = 32
num_ones = 6
lst = [
f"{sum([2**vv for vv in v]):b}".zfill(num_bits)
for v in list(itertools.combinations(range(num_bits), num_ones))
]
print(len(lst))
这将告诉我们在32位数字的整个频谱中有906192数字，其中有6个。
鸣谢：
这个答案的功劳归于@Mark Dickinson谁指出使用permutations是不可行的，并建议使用combinations
好吧，我不是Python编码器，所以我不能为你发布有效的代码。相反，我可以做一个C ++ ...
如果你看看你的问题，你设置6位和许多零...所以我会通过6嵌套for循环计算所有可能的1s位置并设置位...
就像是：
for (i0= 0;i0<32-5;i0++)
for (i1=i0+1;i1<32-4;i1++)
for (i2=i1+1;i2<32-3;i2++)
for (i3=i2+1;i3<32-2;i3++)
for (i4=i3+1;i4<32-1;i4++)
for (i5=i4+1;i5<32-0;i5++)
// here i0,...,i5 marks the set bits positions
所以O(2^32)变得不到'~O（26.25.24.23.22.21 / 16）并且你不能比那更快，因为这意味着你错过了有效的解决方案......
我假设您要打印数字，所以为了加快您可以从头开始计算二进制数字符串的数字，以避免字符串和数字之间的缓慢转换...
嵌套的for循环可以编码为数组的递增操作（类似于bignum算术）
当我把所有这些放在一起时，我得到了这个C ++代码：
int generate()
{
const int n1=6; // number of set bits
const int n=32; // number of bits
char x[n+2]; // output number string
int i[n1],j,cnt; // nested for loops iterator variables and found solutions count
for (j=0;j<n;j++) x[j]='0'; x[j]='b'; j++; x[j]=0; // x = 0
for (j=0;j<n1;j++){ i[j]=j; x[i[j]]='1'; } // first solution
for (cnt=0;;)
{
// Form1->mm_log->Lines->Add(x); // here x is the valid answer to print
cnt++;
for (j=n1-1;j>=0;j--) // this emulates n1 nested for loops
{
x[i[j]]='0'; i[j]++;
if (i[j]<n-n1+j+1){ x[i[j]]='1'; break; }
}
if (j<0) break;
for (j++;j<n1;j++){ i[j]=i[j-1]+1; x[i[j]]='1'; }
}
return cnt; // found valid answers
};
当我使用n1=6,n=32时，我得到了这个输出（没有打印数字）：
cnt = 906192
它是在AMD A8-5500 3.2GHz（win7 x64 32位应用程序无线程）的4.246 ms上完成的，这对我来说足够快......
一旦你开始在某个地方输出数字，请注意速度会急剧下降。特别是如果输出到控制台或者什么......输出缓冲输出可能会更好，比如一次输出1024个字符串数等等...但正如我之前提到的，我不是Python编码器所以它可能已经由环境...
除此之外，一旦你将使用变量n1,n，你可以为零而不是1做同样的事情并使用更快的方法（如果有更少的零然后使用嵌套for循环来标记零而不是1）
如果想要的解决方案号码是一个数字（不是一个字符串），那么它可以重写这个，所以i[]或i0,..i5保持位掩码而不是位位置...而不是inc / dec你只是左/右移位...并且不再需要x阵列，因为数字将是x = i0|...|i5 ...
您可以为数字中的1s位置创建一个计数器数组，并通过移动各自位置的位来组装它。我在下面创建了一个例子。它运行速度非常快（我的笔记本电脑上的32位不到一秒钟）：
bitCount = 32
oneCount = 6
maxBit = 1<<(bitCount-1)
ones = [1<<b for b in reversed(range(oneCount)) ] # start with bits on low end
ones[0] >>= 1 # shift back 1st one because it will be incremented at start of loop
index = 0
result = []
while index < len(ones):
ones[index] <<= 1 # shift one at current position
if index == 0:
number = sum(ones) # build output number
result.append(number)
if ones[index] == maxBit:
index += 1 # go to next position when bit reaches max
elif index > 0:
index -= 1 # return to previous position
ones[index] = ones[index+1] # and prepare it to move up (relative to next)
64位大约需要一分钟，大致与输出值的数量成比例。上）
在递归生成器函数中可以更简洁地表达相同的方法，这将允许更有效地使用位模式：
def genOneBits(bitcount=32,onecount=6):
for bitPos in range(onecount-1,bitcount):
value = 1<<bitPos
if onecount == 1: yield value; continue
for otherBits in genOneBits(bitPos,onecount-1):
yield value + otherBits
result = [ n for n in genOneBits(32,6) ]
当你获得所有数字时，这并不快，但它允许部分访问列表而不通过所有值。
如果需要直接访问第N位模式（例如，获取随机的1位模式），则可以使用以下函数。它就像索引列表一样，但不必生成模式列表。
def numOneBits(bitcount=32,onecount=6):
def factorial(X): return 1 if X < 2 else X * factorial(X-1)
return factorial(bitcount)//factorial(onecount)//factorial(bitcount-onecount)
def nthOneBits(N,bitcount=32,onecount=6):
if onecount == 1: return 1<<N
bitPos = 0
while bitPos<=bitcount-onecount:
group = numOneBits(bitcount-bitPos-1,onecount-1)
if N < group: break
N -= group
bitPos += 1
if bitPos>bitcount-onecount: return None
result = 1<<bitPos
result |= nthOneBits(N,bitcount-bitPos-1,onecount-1)<<(bitPos+1)
return result
# bit pattern at position 1000:
nthOneBit(1000) # --> 10485799 (00000000101000000000000000100111)
这允许您在非常大的整数上获得无法完全生成的位模式：
nthOneBits(10000, bitcount=256, onecount=9)
# 77371252457588066994880639
# 100000000000000000000000000000000001000000000000000000000000000000000000000000001111111
值得注意的是，模式顺序不遵循相应数字的数字顺序
虽然nthOneBits（）可以立即生成任何模式，但是在批量生成模式时它比其他函数慢得多。如果需要按顺序操作它们，则应该使用生成器函数而不是在nthOneBits（）上循环。
此外，调整生成器以使其以特定模式启动应该相当容易，这样您就可以充分利用这两种方法。
最后，在给定已知模式的情况下获得下一位模式可能是有用的。这就是以下函数的作用：
def nextOneBits(N=0,bitcount=32,onecount=6):
if N == 0: return (1<<onecount)-1
bitPositions = []
for pos in range(bitcount):
bit = N%2
N //= 2
if bit==1: bitPositions.insert(0,pos)
index = 0
result = None
while index < onecount:
bitPositions[index] += 1
if bitPositions[index] == bitcount:
index += 1
continue
if index == 0:
result = sum( 1<<bp for bp in bitPositions )
break
if index > 0:
index -= 1
bitPositions[index] = bitPositions[index+1]
return result
nthOneBits(12) #--> 131103 00000000000000100000000000011111
nextOneBits(131103) #--> 262175 00000000000001000000000000011111 5.7ns
nthOneBits(13) #--> 262175 00000000000001000000000000011111 49.2ns
与nthOneBits（）一样，这个不需要任何设置时间。它可以与nthOneBits（）结合使用，以便在给定位置获得初始模式后获得后续模式。 nextOneBits（）比nthOneBits（i + 1）快得多，但仍然比生成器函数慢。
对于非常大的整数，使用nthOneBits（）和nextOneBits（）可能是唯一的实用选项。
你正在处理multisets的排列。有许多方法可以实现这一点，正如@BPL指出的那样，有效地做到这一点并非易事。这里提到了很多很棒的方法：permutations with unique values。最干净的（不确定它是否最有效）是使用multiset_permutations模块中的sympy。
import time
from sympy.utilities.iterables import multiset_permutations
t = time.process_time()
## Credit to @BPL for the general setup
multiPerms = ["".join(v) for v in multiset_permutations(["1"]*6+["0"]*26)]
elapsed_time = time.process_time() - t
print(elapsed_time)
在我的机器上，上面的计算时间超过8秒。它也产生了不到一百万的结果：
len(multiPerms)
906192