Python位运算生成唯一键性能极差，寻求优化方案

你的核心问题是Python解释器的动态特性带来的循环、函数调用、对象实例化开销，对比编译型语言的静态优化差距明显。以下是几个落地的提速方案，按实现复杂度和提升效果排序：

1. 彻底移除类封装，直接生成整数键（最快的纯Python实现） #

原代码中UniqueKey类仅封装了一个整数，完全没必要用类来承载。直接计算整数并存入列表，省去对象实例化、函数调用的双重开销：

A_BIT_COUNT = 11
A_BIT_MASK = (1 << A_BIT_COUNT) - 1
B_BIT_COUNT = 11
B_BIT_MASK = (1 << B_BIT_COUNT) - 1
C_BIT_COUNT = 2
C_BIT_MASK = (1 << C_BIT_COUNT) - 1

A_BIT_OFFSET = B_BIT_COUNT
C_BIT_OFFSET = A_BIT_COUNT + B_BIT_COUNT

if __name__ == "__main__":
    keys = []
    # 调整循环顺序：把循环次数少的放外层（C只有4次），减少内层循环的初始化开销
    for c in range(C_BIT_MASK + 1):
        c_shifted = c << C_BIT_OFFSET
        for a in range(A_BIT_MASK + 1):
            a_shifted = a << A_BIT_OFFSET
            # 预计算a+c的部分，内层循环只处理b
            ac_base = a_shifted | c_shifted
            for b in range(B_BIT_MASK + 1):
                keys.append(ac_base | b)  # B的偏移是0，直接按位或

效果：这个改动能把耗时从15秒压缩到1-2秒左右，因为砍掉了最耗时的类实例化和跨函数调用。另外调整循环顺序，把次数少的C循环放外层，减少内层循环的重复初始化工作。

2. 使用列表推导式进一步提速 #

Python的列表推导式是底层C实现，比手动append的Python循环更快。结合预计算的思路，用嵌套推导式实现：

A_BIT_COUNT = 11
A_BIT_MASK = (1 << A_BIT_COUNT) - 1
B_BIT_COUNT = 11
B_BIT_MASK = (1 << B_BIT_COUNT) - 1
C_BIT_COUNT = 2
C_BIT_MASK = (1 << C_BIT_COUNT) - 1

A_BIT_OFFSET = B_BIT_COUNT
C_BIT_OFFSET = A_BIT_COUNT + B_BIT_COUNT

if __name__ == "__main__":
    keys = [
        (a << A_BIT_OFFSET) | b | (c << C_BIT_OFFSET)
        for c in range(C_BIT_MASK + 1)
        for a in range(A_BIT_MASK + 1)
        for b in range(B_BIT_MASK + 1)
    ]

效果：相比手动append的循环，列表推导式能再提速30%-50%，耗时大概在0.8-1.5秒。

3. 用numpy批量生成（接近编译型语言速度） #

如果允许使用numpy库，利用其矢量运算的特性，把整个计算过程转为C级别的批量操作，彻底避开Python循环：

import numpy as np

A_BIT_COUNT = 11
A_MAX = (1 << A_BIT_COUNT) - 1
B_BIT_COUNT = 11
B_MAX = (1 << B_BIT_COUNT) - 1
C_BIT_COUNT = 2
C_MAX = (1 << C_BIT_COUNT) - 1

A_BIT_OFFSET = B_BIT_COUNT
C_BIT_OFFSET = A_BIT_COUNT + B_BIT_COUNT

if __name__ == "__main__":
    # 生成所有a、b、c的网格
    c = np.arange(C_MAX + 1, dtype=np.int64)[:, None, None]
    a = np.arange(A_MAX + 1, dtype=np.int64)[None, :, None]
    b = np.arange(B_MAX + 1, dtype=np.int64)[None, None, :]
    
    # 批量计算位运算
    c_shifted = (c << C_BIT_OFFSET)
    a_shifted = (a << A_BIT_OFFSET)
    keys = (a_shifted | b | c_shifted).ravel()  # 展平为一维数组

效果：耗时可以降到100-200ms，和Go/Java的性能基本持平。numpy的矢量运算完全绕开了Python的循环开销，所有计算都在底层C完成。

4. 额外小优化：移除冗余掩码操作 #

如果a、b、c的取值范围本来就不超过掩码（比如你的循环是从0到掩码值），那& 掩码的操作是多余的，可以直接去掉，进一步减少计算量。

内容的提问来源于stack exchange，提问作者Mko