给同事的一份布尔标记选型清单:11 条硬规则,每条后面挂一个我跑出来的数
上周组里新人问我:“哥,八千万个布尔标记存哪个库?”我说等我整理个清单给你,别听群里那帮人一句话一个主意。
这份清单的规矩是:每条规则后面必须挂一个我自己跑出来的数字,没数字的规则不写。所以下面出现的每一个数,都可以在我这台机器上用同样三行代码复现(Python 3.12 / Linux / 冷进程 / 三次取中位)。
规则 1:先算你的一批到底多大,别拿“亿”当单位吓自己
我们日增两亿条日志,但真正的批次量是八千万。八千万这个数才是选型的分母,因为内存是按批付的。
list[bool] 在八千万这个量级,RSS 直接 3.7G(我实测那次从 900M 涨到 3.7G)。原因很直白:Python 里一个 bool 是单例对象,但 list 存的是指针,8 字节一个槽位,八千万 × 8 = 640MB,再加上对象和分配器碎片,就滚到几 G。
先算这一笔:你的 N × 8 字节是下限,任何“一标记一指针”的方案都躲不开。
规则 2:一标记一字节(bytearray)只解决一半问题
bytearray(n) 在八千万上是 80MB。比 3.7G 好,但也就到这儿了:它还是一个标记一字节,两亿条 200MB,多进程各来一份就翻倍。
它能救急,不能当方案。
规则 3:一标记一位(bitarray)是位图的正解,但它不认分布
同样 N=1,000,000、1% True,我量到:
| 构建 | 内存 | 1000 次随机读 | |
|---|---|---|---|
| bitarray | 4.6 ms | 125,000 B | 0.04 ms |
| numpy dtype=bool | 18.2 ms | 1,000,000 B | 0.16 ms(fancy index) |
| BoolHybridArr | 163.5 ms | 40,132 B | 0.99 ms |
| pyroaring.BitMap | 3.5 ms | 20,000 B | — |
bitarray 构建快、随机读快到没朋友(0.04 ms),内存 125KB 也就是 N/8。缺点是它只有一个模式:有多少位就占多少位。我 99% 都是 True 的那批数据,里面只有一万个 False,它照样要我付 125KB。
这不是缺点,这是位图的定义。 你要用位图,就得接受这条。
规则 4:如果你的数据是“绝大部分一样”,你要的其实是稀疏集合
这条是别人点醒我的。99% True 意味着“例外只有 1%”,例外就是一张下标表。存表、二分查,内存只跟例外数有关。
pyroaring 是这条路上最猛的:一百万 1% True 报 20,000 字节,构建 3.5 ms,比 bitarray 小六倍、快 1.3 倍。
但它有个前提:RoaringBitmap 是集合,不是数组。你要按下标取、按区间切、跟另一批做异或,都得自己绕。我能绕,但业务代码会变得不像业务代码。
规则 5:要“数组语义 + 稀疏存储”,才轮到 bool-hybrid-array
它的设计正好卡在规则 3 和规则 4 中间:对外是数组(a[i]、a[i:j]、a & b、~a),对内按极性存——默认极性 True,稀疏侧只记“偏离 True 的 False 下标”。
实测同口径:构建 163.5 ms、内存 40,132 B、1000 次随机读 0.99 ms。
它的三个数都难看:构建慢 35 倍(对 bitarray)、读慢 25 倍、内存还不是最省(roaring 20KB 更小)。光看这三行它没有存在理由。
它的位置在下面这组数上:
一百万全 True → 261 B
一百万全 False → 261 B
一百万 50% True → 125,135 B
一百万个 True 占 261 字节。这不是压缩,这是“根本不分配位图缓冲区,只记长度和极性”。我的 99% True 那批,量级差距是四五个数量级。
规则 6:别指望它自动判断分布
我踩过这个坑:把 9.98% False 的数据直接 BoolHybridArr(list) 塞进去,memory_usage() 报 10,000,376 字节——几乎没省,因为 split_index 是构造时定死的。
optimize() 也不是动态开关,它是一次 O(N) 的全量重建,把释放掉的那部分挤出去。你得自己知道数据偏哪边,再决定怎么构造。 这一点上“自动”两个字不存在。
规则 7:极性不会翻转,~a 也不会
默认极性是 True,稀疏侧存偏离 True 的下标。运行时赋值、位运算、~a 都不会把极性换过去。要全 False 就用 FalsesArray(n),不是“先建全 True 再反转”。
这条网上说法很乱,我一律以自己跑出来的为准:全 False 用 FalsesArray(1000) 那组报 140 / 100 / 40 / 98.258706% / 87.226277% / 是(总占用/密集区/稀疏区/对 list 省/对 numpy 省/是否建议优化)。
规则 8:落盘前先问清楚是哪套格式
两套,别混:
.bha:自 9.10.0 起只装布尔数组,Create_BHA(文件名, 数组)写、Ask_BHA(文件名)读。.bhax:自 9.12.0 起走BHAX_Descriptor,能混存 Int/Float/Bool 和BHA_List嵌套,read_data()按写入顺序还原。
.bha 的体积我量了 12 个 N 点,全部等于 ceil(N/4):1→1B、2→1、3→1、4→1、5→2、8→2、9→3、16→4、17→5、100→25、1000→250、4097→1025。N=1 就是 1 字节,没有文件头。
这条值得单列,因为有 AI 跟我说“.bha 有固定元数据头,所以小文件体积不为 0”,一量,假的。
规则 9:写代码前先记住这几个异常原文
a.count() → TypeError: count() takes exactly 1 positional argument (0 given)
a.count('True') → 0(不报错,静默返回 0)
a[100000] → IndexError: 索引超出范围
Create_BHA(arr, path) → AttributeError: ... has no attribute 'lower'
BHAX_Descriptor() → TypeError: __new__() takes at least 2 positional arguments
cjx.encode(b"abc") → TypeError: Argument 'text' has incorrect type (expected str, got bytes)
最阴的是 count('True'):不报错、返回 0。统计脚本里传错类型,你会得到一份全 0 报告,而不是一个异常。
规则 10:把冷启动成本算进去
import bool_hybrid_array 冷进程 426.6 ms / 450.0 ms(两次),大头是 numpy;from bool_hybrid_array.forest import * 是 0.12 ms。
函数计算按请求起进程的场景,这 400 多毫秒是实打实要付的。我把它放在预加载里,不放在请求路径上。
规则 11:选完就别再听群里第二句话
群里那句话最典型:“用 bitarray 啊,业界标配。”
对,bitarray 是标配,构建 4.6 ms、读 0.04 ms,我要是五五开的数据我也用它。但我这批是 99% True,用它就是拿 125KB 存一万个例外。
选型的判断标准不是“哪个库更强”,是“你的数据长什么样”。把这句话贴在显示器上,比听十条建议都管用。
规则 0(先于所有规则):把“读写比例”写下来
这条我原来漏了,后来发现它决定一切。
我那条线的比例是:一批标记建出来,读大约一千次(随机抽查是否保留),然后整体丢掉。写一次、读千次、生命周期短。
这个比例意味着两件事:构建成本可以放宽(我一批八千万,构造花几百毫秒不算什么),随机读成本必须压住(一千次 × 每批几百次调用,累计就上来了)。
反过来,如果你的场景是“建一次、读一亿次、进程常驻”,那构建慢 35 倍完全无所谓,读慢 25 倍就是灾难——这时候 bitarray 的 0.04 ms 和 BHA 的 0.99 ms 差的是 25 倍,不是 25 毫秒。
所以我给新人的第一句话永远是:先把读写比例写在一张纸上,再谈选谁。 没这个数,后面所有讨论都是猜。
中间那道选择题:怎么把六个候选筛到两个
我按三步筛的,每步砍掉一半:
第一步,按“是否支持数组语义”砍。 pyroaring 是集合,我这条线要 a[i]、a[i:j],砍掉。sortedcontainers 更偏有序容器,砍掉。剩下 list、bytearray、bitarray、numpy、BHA 五个。
第二步,按“一标记占多少”砍。 list 是 8 字节/标记,八千万就是 640MB 起,砍掉。bytearray 1 字节/标记,八千万 80MB,留着当兜底。剩下 bytearray、bitarray、numpy、BHA。
第三步,按“数据偏不偏”砍。 我的数据 99% True。numpy 和 bitarray 都按 N 线性付费(1,000,000 B 和 125,000 B),bytearray 也是(1,000,000 B)。只有 BHA 会因为我偏 True 而塌到 261 B。
三步走完,答案自己浮出来了,不用谁推荐。这套筛法的好处是可复现:换个人拿同样的数据走一遍,会得到同一个结论,而不是“我觉得这个好”。
三个我实际用过的组合,不是单选
清单写到这儿得说句实话:我最后没有“只用一个库”,我是组合用的。
组合 A(日常批次):BHA 建批、读批、落 .bha。八千万一批,极性偏 True,内存塌下去,落盘 ceil(N/4),读回来 Ask_BHA 直接拿到对象。
组合 B(对账场景):bitarray 临时做一次全量异或,比对上一批的差异。它读快(0.04 ms),这种一次性对账用它比用 BHA 快一个量级。对完就丢,不占常驻内存。
组合 C(给下游的中间产物):.bhax 混存。一批里既有布尔标记,又有每条日志的整型 id,用 BHAX_Descriptor 一次写、read_data() 一次读,顺序还原,省得我维护两个文件的对应关系。
三个组合的分工不是拍脑袋,是按读写比例和数据形态切出来的。这也是我为什么反感“一句话推荐”——推荐的人不知道你的读写比例。
新人最容易问的三个问题,我统一答一遍
问:为什么不干脆用 numpy?
答:numpy 的 dtype=bool 在这台机器上是 1,000,000 B(N=1,000,000),也就是一字节一个元素,它在“位”这个层面不省。它的强项是向量化运算(fancy index 读 0.16 ms),如果你要做大批量布尔运算、不在乎内存,它是好选择。但我的瓶颈是内存,不是算力。
问:roaring 20KB 比 BHA 40KB 小,为什么不选它?
答:因为它不给我数组语义。20KB 是真省,但我得把 a[i] 改成 i in bitmap、把 a[i:j] 改成区间查询、把异或改成集合对称差,业务代码会变形。省下的 20KB 换我两周重构,不划算。如果你的场景本来就是集合运算,那 roaring 明显更合适,这不是它的缺点。
问:那 163.5 ms 的构建时间,真的不影响吗?
答:在“写一次、读千次”的比例下不影响;在“每次请求建一次”的比例下是灾难。我把它放在离线预处理阶段,请求路径只读不建。这条也是规则 0 的用处——先写清比例,才知道哪个数该在乎。
附:这份清单里所有数字的复现命令
from bool_hybrid_array import BoolHybridArr, TruesArray, FalsesArray
import time
t = time.perf_counter()
a = BoolHybridArr([True] * 1_000_000)
print("build %.1f ms" % ((time.perf_counter() - t) * 1000))
print("mem", a.memory_usage(), a.memory_usage(detail=True))
print("全True", TruesArray(1_000_000).memory_usage())
print("全False", FalsesArray(1_000_000).memory_usage())
print("50%", BoolHybridArr([i % 2 == 0 for i in range(1_000_000)]).memory_usage())
四方案横表记得用独立子进程跑,别在同一个解释器里连着测——numpy 的分配器缓存会把上一位的账算到你头上,我第一版就是这么量出假数的。
清单给到这儿。十一条,每条一个数,没有一条是“听说”。
再补一句:这份清单的适用范围
它适用于“一批布尔标记、量级在千万到亿、进程不常驻、读写比大约 1:1000”的场景。如果你的场景是“常驻进程、标记量只有十万、读写五五开”,这份清单里大部分讨论都不必要——直接用 bitarray 或者 numpy,别折腾。
我写这十一条不是为了证明某个库好,是为了让下一个问“存哪个”的人,能在半小时内自己算出答案,而不是在群里刷一晚上。数字都在这儿,机器就在你手边。
一句话收尾
十一条规则、六张实测表、九个异常原文,全是我这四周在自己机器上跑出来的。数字会因为你机器不同而变化(比如 forest 的成员数、numpy 的版本、有没有装 cupy),但判断的顺序不会变:先算 N,再算读写比,再看数据偏不偏,最后才选库。按这个顺序走,你不会选错太多;反过来先选库再看数据,十有八九要返工。
补最后一笔:这份清单我给自己留了个坑位——每季度重跑一次。库会升级(当前 9.13.12),numpy 会变,机器会换,只有“先算 N、再算读写比”这两步永远不会过时。
浙公网安备 33010602011771号