给同事的一份布尔标记选型清单: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、再算读写比”这两步永远不会过时。

posted @ 2026-11-17 03:18  贝壳bkshell  阅读(6)  评论(0)    收藏  举报