如果使用Python 3.10+，则可以使用int.bit_count()：

>>> for i in range(16):
...   print(f'{i:04b}, count={i.bit_count()}')
...
0000, count=0
0001, count=1
0010, count=1
0011, count=2
0100, count=1
0101, count=2
0110, count=2
0111, count=3
1000, count=1
1001, count=2
1010, count=2
1011, count=3
1100, count=2
1101, count=3
1110, count=3
1111, count=4

因此，对于4位数中的偶数个0和1：

>>> for i in range(16):
...   if i.bit_count() == 2:
...     print(f'{i:04b}')
...
0011
0101
0110
1001
1010
1100

或者简单地计算一下：

>>> sum(1 for i in range(2**4) if i.bit_count() == 2)
6
>>> sum(1 for i in range(2**24) if i.bit_count() == 12)
2704156

一个更快的计数选项是生成N位的组合，一次取N/2，这比上面针对24位数的.bit_count()求和快约4倍：

>>> from itertools import combinations as C
>>> numbits = 24
>>> target = numbits // 2
>>> sum(1 for c in C(range(numbits), target))
2704156

时序比较：

C:\>py -m timeit -s "from itertools import combinations as C" "sum(1 for c in C(range(24), 12))"
1 loop, best of 5: 383 msec per loop

C:\>py -m timeit "sum(1 for i in range(2**24) if i.bit_count() == 12)"
1 loop, best of 5: 1.53 sec per loop

itertools解决方案，生成位模式和值。例如，下面的迭代20次与尝试所有64（26）号码：

from itertools import combinations as C
numbits = 6
target = numbits // 2
for c in C([1<<n for n in range(numbits)], target):
    value = sum(c)
    print(f'{value:0{numbits}b} {value}')

输出：

000111 7
001011 11
010011 19
100011 35
001101 13
010101 21
100101 37
011001 25
101001 41
110001 49
001110 14
010110 22
100110 38
011010 26
101010 42
110010 50
011100 28
101100 44
110100 52
111000 56

这是我的解决方案。
回想一下组合学，跨越K个位置的N个元素的唯一排列的数量是这样的：

P =     N!
    -----------
      P! (N-P)!

对于任何给定的长度为N的二进制串，其中0和1的数量相同的“偶数串”的数量可以类似地计算如下：

permutations =          N!
               ----------------
                 (N/2)! * (N/2)!

在Python中：

P = (math.factorial(N) // math.factorial(N//2)) // math.factorial(N//2)

简单来说就是：

P = math.comb(N, N//2)

让我们通过在决策树的每次迭代中附加一个或1来实现这一点

更新实施情况

import math

def getNumberForIteration(i, length, remaining):
    if (i < 0 or length < remaining or remaining < 0 or length < 0): raise "Error!"
    result = 0
    while (length > remaining) and (length > 0) and (remaining > 0):
        leftCombos = math.comb(length-1,remaining)
        if (i < leftCombos):
            result = result << 1         # append 0
        else:
            result = (result << 1) + 1   # append 1
            remaining = remaining - 1
            i = i - leftCombos
        length = length - 1
    while (remaining > 0):          # pad the end with 1's
        result = (result << 1) + 1   
        remaining = remaining - 1
        length = length - 1
    if (length > 0):                # pad the end with 0's
        result = result << length

    return result

def print_binary_numbers_with_half_the_bits_set(bitLength):
    iterations = math.comb(bitLength, bitLength//2)
    for i in range(0,iterations):
        val = getNumberForIteration(i, bitLength, bitLength//2)
        f = "{0:0" + str(bitLength) + "b}"
        s = f.format(val)
        print(i, s, val)

测试它（打印字符串及其十进制值）

>>> print_binary_numbers_with_half_the_bits_set(6)
000111 7
001011 11
001101 13
001110 14
010011 19
010101 21
010110 22
011001 25
011010 26
011100 28
100011 35
100101 37
100110 38
101001 41
101010 42
101100 44
110001 49
110010 50
110100 52
111000 56

您可以从以下数字开始：
1 + 0 * half + 1 *（half - 1），其中half =目标长度/ 2
然后将每个1从右半部分逐位移动到左半部分。
下面是我得到的代码：

def binary_even(length):
    half = int(length/2)
    result = 0

    for i in range(0, half - 1, 1):
        for j in range(half - i, -1, -1):
            num = int("1"*(i+1) + "0"*j + "1" + "0"*(half-j) + "1"*(half-2-i))
            # Your operations with the number
        
    return result

这里 i 是已经移动到左侧的1的数量，j 是0的初始序列中的当前位置。
对不起，如果指数化是混乱的，但代码应该工作，似乎对我优化。