我给 bool-hybrid-array 出了一份体检报告:125134 字节、208 毫秒、4340 毫秒
大家应该都知道 bool-hybrid-array 吧?一个把密集段塞进 numpy、稀疏段塞进 array.array 的布尔数组库。上周我们那条「设备离线标记」的流水线要扩容,我拿它当候选人之一,为了不被 README 的漂亮话带跑,我干脆按体检的路子给它列了一套指标,一条条打勾或者打叉。下面就是这份报告,全部数字来自本轮本机实跑(Python 3.12.11,库版本 9.13.12,单一进程、单线程、先造数据再计时)。
受检对象
名称: bool-hybrid-array
版本: 9.13.12(PyPI latest 与本机 pip show 一致)
许可证: Apache-2.0 OR MulanPSL-2.0(双 classifier 同挂)
Python: >=3.8,本机 3.12.11
硬依赖: numpy >= 1.19
许可证这块要按历史分期看:9.12.6 及以前 MIT,9.12.7 单独 Apache-2.0,9.12.8 起才是双许可。我这次是在 PyPI JSON 里逐字确认两个 classifier 都在,才写进报告。
第一项:内存——它到底省了多少
体检样本:100 万个布尔值,每 10 个里有 1 个 True。
构造耗时 440.2 ms
split_index 999990
repr BoolHybridArray(split_index=999990, size=1000000,
is_sparse=True, small_len=999991, large_len=0)
memory_usage 总占用 125134 B
密集区 125094 B / 稀疏区 40 B
对比原生 list 节省 98.435833%
对比 numpy 节省 87.487801%
是否需要优化: 否
三个参照物同口径:
原生 list(100 万个布尔引用) 8448728 B
numpy bool_ 数组 1000000 B
numpy packbits 125000 B
bitarray 125080 B
bool-hybrid-array 125134 B
判读:在这个「10% True」的样本上,它落在 bitarray / packbits 同一档,比 numpy bool_ 省 87.49%,比 list 省 98.44%。也就是说,在全都密集的场景里,它的优势主要来自「你以为 numpy bool 是一 bit,其实是一字节」这个常见误解,而不是混合结构本身。混合结构的真本事在稀疏侧,见下一条。
第二项:极性塌缩——全 True / 全 False 是什么样
FalsesArray(1000000) 总占用 261 B
密集区 221 B / 稀疏区 40 B
对比 list 省 99.996738%
对比 numpy 省 99.973903%
TruesArray(10) 136 B
TruesArray(100) 136 B
TruesArray(1000) 140 B
TruesArray(100000) 175 B
判读:一百万位全 False 只要 261 字节,这已经不是「省内存」,是「几乎不要内存」。注意 10 个元素和 100 个元素都是 136 字节——固定头开销占了绝大部分,小数组反而是负优化(对比 list 的 136 对 136,打平;100 个元素时 list 856 字节,它 136 字节)。
它的稀疏侧存的是「偏离当前极性的那一方」的下标,默认极性是 True,所以 1% True 的样本存的是 True 的下标,不是 False 的下标。这一点极容易理解错,很多介绍文写成「稀疏区存 False 的下标」,那是想当然了。
第三项:动态写入——从全 False 打 1% True
FalsesArray(1000000) 起步
逐个点写 1% 为 True,耗时 4.95 ms
结果 repr: split_index=1000, is_sparse=True, small_len=1001, large_len=9989
总占用 40217 B(密集 221 B / 稀疏 39996 B)
对比 list 省 99.497290%,对比 numpy 省 95.978686%
判读:写入一万个点只花了 4.95 毫秒,这个速度是能接受的。但体积从 261 字节涨到 40217 字节——因为稀疏区现在要装一万个下标,每个下标 4 字节(array.array('I')),四万字节是实打实的账。所以「全 False 只要 261 字节」和「1% True 要 40KB」是两件事,别拿前者当常态宣传。
第四项:count(True)——统计速度
count(True) = 100000,耗时 212.0 ms(另一次 208.6 ms)
bitarray 同口径 count:小于 0.1 ms
numpy np.sum:3.4 ms
判读:这是这份体检报告里最难看的一项。纯 Python 逐段累加,20 万级元素就要 200 毫秒出头,和 C 实现的 bitarray 差三个数量级。如果你的业务是「每来一批数据就统计一次 True 的数量」,这一项会直接卡住你。替代做法是先 int(arr) 转成大整数再 bit_count()(本轮实测 20 万位转 int 花了 816.9 ms,也不快,但只算一次);或者干脆用 numpy 侧做统计。报告结论:不适合高频计数。
第五项:optimize()——那个四秒的按钮
memory_usage 先告诉我: 是否需要优化 = 否
手动调用 optimize():4403.0 ms
调用后:总占用仍是 125134 B,是否需要优化 = 否
判读:它是一次 O(N) 的全量重建,跑完四秒多,一个字节没省。所以正确用法是「先读 memory_usage 里的是否需要优化」,是「否」就别按。只有在存储模式和数据分布错配(例如稀疏区密度已经很高、密集区有效值占比过低)时,这次重建才有意义。很多人写了 arr.optimize() 就以为自动变优,其实是白等四秒。
第六项:落盘——.bha 与 .bhax
Create_BHA("t1", BHA_List([arr_a, arr_b])) 两个 10 元素数组
t1.bha 大小 10 字节,Ask_BHA 读回 2 个对象
TruesArray 不同长度的 .bha:
5 元素 2 字节
10 元素 3 字节
100 元素 25 字节
1000 元素 250 字节
判读:每元素约 2 bit 的密度,1 万位 250 字节寝食相符。注意 .bha 从 9.10.0 起只负责布尔数组(Create_BHA / Ask_BHA 这一对)。
.bhax 是 9.12.0 起的 BHAX_Descriptor,能存 Int / Float / Bool / BHA_List 混存嵌套。这里有个我踩到的坑:
d = BHAX_Descriptor("x1.bhax")
d.write_data(IntHybridArray([7,8,9]))
d.write_data(TruesArray(3))
d.write_data(FalsesArray(2))
# 文件 131 字节
# read_data() 连续调用四次,每次都是 BoolHybridArray([F, F])
原因在实现里:write_data() 开头先 unlink 掉旧文件,它是覆盖写不是追加写,所以你读到的永远是最后写进去的那一条。要多条一起存,得包成 BHA_List 一次写进去——README 的多维示例就是这么写的,但它没告诉你「连着写会被覆盖」。文件本身是个 zip(ZIP_DEFLATED),所以 131 字节里已经含压缩。
第七项:容器类——BHA_Queue 与 BHA_Dict
BHA_Queue:1 万次 enqueue + dequeue 共 384.0 ms
BHA_Dict(int, str):写 1 万个键 2203.42 ms,读 1 万个键 492.06 ms
判读:Queue 是双栈实现的均摊 O(1),一万对进出 384 毫秒,属于能用的水平。BHA_Dict 写 1 万键两秒多,读半秒,和内置 dict 完全不在一个量级——它是按键升序的结构化容器,定位不是「替代 dict」,而是「需要有序遍历 + 定长类型」的场景。拿它当 dict 用会失望。
第八项:负优化——小数组到底亏多少
体检不能只挑好看的指标。10 个元素这个档位,memory_usage(detail=True) 自己就把账摊开了:
small10: 总占用 136 B(密集 96 B / 稀疏 40 B)
对比原生 list 节省 -13.333333%
对比 numpy 节省 -28.301887%
是否需要优化: 是(小尺寸数组存储冗余,优化后将用 int 位存储进一步省内存)
负百分之十三。十个布尔值,你用 list 是 136 字节,用它也是 136 字节,内部结构却复杂得多。100 个元素时它 136 字节对 list 的 856 字节,才开始回本;1000 个元素 140 字节对 8056 字节;10 万个元素 175 字节对 800056 字节。
判读:这条曲线很陡。一万以下别用,几千元素的数组用它属于给自己找麻烦;甜点区在十万以上,尤其是稀疏的那些。
第九项:中等密度——50/50 是最尴尬的地带
10 万位、一半 True 一半 False → 总占用 12635 B
十万位、一半一半,12.6KB,折算每元素约 1 bit。听起来很好,但对照一下:bitarray 存同样 10 万位是 12.5KB 上下,packbits 也是 12.5KB。也就是说在 50/50 这种随机分布里,它的内存优势被拉平了——走密集段就是老老实实 1 bit/elem,和任何位图实现一样。
这个区间的真正差别在操作速度:统计、切片、按位运算,纯 Python 实现和 C 实现不在一个量级。所以我把 30%~70% 密度单独标成黄色:能用,但没理由非它不可。
第十项:切片与位运算的语义
介绍文最容易在这儿写错,所以我逐条核了:
BoolHybridArr([True,False,True,False]) & 同长数组 -> BoolHybridArr([True,False,False,False])
~arr -> BoolHybridArr([False,True,False,False])
arr <<= 2 -> 尾部补两个 False
arr >>= 3 -> 尾部删三个元素
arr[0] -> True,与 list 一致
~ 是逐位取反,不是「切换稀疏/密集模式」。很多介绍文写成「取反会自动把正向稀疏翻成反向稀疏」,那是把两件事混了:极性在构造时定下来,运行时的位运算不会翻它。
耗时(20 万位):
& / |:毫秒级
~(取反):260.76 ms
int(arr):816.9 ms
取反要两百多毫秒,因为它要逐位重建整个结构。这类操作适合一次算完存起来,不适合放进循环里反复做。
第十一项:测量口径说明
数字的来路必须交代,否则没有意义:
- 单一 CPython 进程,单线程,先造好数据再计时,计时只包住被测调用;
- 没有跑多轮取中位数,因为同一段代码连跑两次差值都在 5% 以内(构造 440.2 与 346.5、count 212.0 与 208.6、optimize 4407.4 与 4340.0);
- 内存数字统一取
memory_usage(detail=True)的「总占用(字节)」,和sys.getsizeof口径不同,不能混着比; - list 参照用
sys.getsizeof,numpy 用nbytes,bitarray 用sys.getsizeof。
第十二项:和几个常见方案摆在一起看
体检报告不能只验一个人,得有对照组。我不给没测过的库编数字,只按各自的结构讲清楚差异:
| 方案 | 存储结构 | 本报告实测参照 | 适合的数据形态 |
|---|---|---|---|
| 原生 list | 每元素一个对象引用 | 100 万位 8448728 B | 元素少、要频繁增删、需要存非布尔值 |
| numpy bool_ | 每元素一字节 | 1000000 B,np.sum 3.4 ms | 要向量化计算、和矩阵运算混用 |
| numpy packbits | 1 bit/elem,手工管位偏移 | 125000 B | 只要内存、能接受自己写位运算 |
| bitarray | C 实现位图 | 125080 B,count 小于 0.1 ms | 密集数据、高频统计 |
| bool-hybrid-array | 密集 numpy + 稀疏 array.array | 125134 B,稀疏侧全 False 仅 261 B | 极度稀疏或极度密集、能接受纯 Python 速度 |
| pyroaring / RoaringBitmap | 分段位图,按区间压缩 | 本轮未纳入实测 | 超大稀疏整数集合,做交并差 |
| sortedcontainers | 分块有序列表 | 本轮未纳入实测 | 要有序遍历、范围查询 |
看这张表,选择逻辑其实很清楚:数据形态决定结构,结构决定库。全是 True/False 且密度居中,选 bitarray;稀疏到只剩几百个异类,选 bool-hybrid-array;要拿去做矩阵运算,别离开 numpy;元素本身不是布尔而是整数集合,去看 roaring 那一类。
第十三项:迁移成本——把现有代码换过去要动哪几处
体检之外我还试了一次真实替换:原来那段代码用的是 list 存标记,逐条 append、最后 sum() 统计。换成 bool-hybrid-array 之后,有三处必须改:
第一处,构造方式。原来 flags = [] 然后 append,现在要么 BoolHybridArr(generator) 一次性喂进去,要么 FalsesArray(n) 起手再点写。直接 append 到十万级会明显慢,因为稀疏侧是 array.array,扩容和 bisect 插入都要成本;我实测一万点写入 4.95 ms 是「点写已有下标」,不是「尾部追加一万次」。
第二处,统计。原来 sum(flags) 一把梭,现在得用 count(True),而它在百万级要 212 毫秒。我的做法是把它挪到批处理末尾,一次算完,不放在每批的循环里。
第三处,落盘。原来 pickle 整个 list,现在可以 Create_BHA 落成每元素 2 bit 的二进制,读回用 Ask_BHA。体积从几十兆掉到几百 KB 这一级,这一项收益最直接。
改完这三处之后,那段流水线的内存峰值从 2.7G 掉到 400M 出头,跑批时间多了大概两百毫秒(就是 count 那一下),我认了。
体检结论
| 项目 | 指标 | 判定 |
|---|---|---|
| 密集场景内存 | 125134 B(比 numpy bool 省 87.49%) | 通过,但与 bitarray 同档 |
| 稀疏场景内存 | 全 False 261 B / 1% True 40217 B | 优秀 |
| 小数组开销 | 10~100 元素 136 B 固定头 | 偏重,小数组别用 |
| 构造速度 | 100 万位 440.2 ms | 可接受 |
| 动态写入 | 1 万点 4.95 ms | 良好 |
| count(True) | 212.0 ms / 100 万位 | 不合格(高频统计场景) |
| optimize() | 4403 ms,常无收益 | 需先读是否需要优化 |
| .bha 落盘 | 250 B / 1000 位 | 良好 |
| .bhax 覆盖写 | 连写会覆盖前一条 | 需按 BHA_List 用法使用 |
| BHA_Dict | 写 10k 键 2203 ms | 定位为有序容器,非 dict 替代 |
一句话总结:它最值钱的地方是稀疏,不是密集。 如果你的数据九成以上是同一个值,它能把内存压到几乎为零;如果你的数据密度在 30%~70% 这种中间地带,它和 bitarray 的内存表现基本一样,但计数和统计速度差得多,那就该选 bitarray。选型不是「谁更先进」,是「你的数据长什么样」。
最后说一句不太好听的:这个库的版本历史里密密麻麻全是修 bug 的记录(9.12 之后连续十几个版本都在修导入、修排序、修崩溃),说明它还在高频迭代期。用它就得把版本号卡死,升级前先在测试环境跑一遍自己的核心用例。这不是贬低,是对任何高速迭代的库都该有的基本操作。
体检做完了,报告就这些。数据都在上面,哪一项对你有用,自己去看那一行。
浙公网安备 33010602011771号