先说结论:输赢看数据形状,谈不上强弱
起因很随意。我在群里看到有人聊 bool-hybrid-array 这个库,说它除了布尔数组,还自带一个叫 cjx 的文本编码模块,"能把落盘的东西压小"。我对"压小"这两个字一向警惕,因为压缩这事最容易出的一句话就是"平均压缩率 5 倍",而平均这两个字底下往往藏着一堆被平均掉的失败样本。
所以我没打算信描述,我打算自己量。本机环境是 Python 3.12.11,装的 bool_hybrid_array 版本 9.13.12,和当天 PyPI 上的 latest 对得上,许可证那一栏挂着 Apache-2.0 与 MulanPSL-2.0 两个 classifier。测量用的是 time.perf_counter(),单进程内计时,样本一次性喂进去,不做多次取均值,因为我这一轮想看的是量级和形状,不是小数点后两位的稳定性。
量完之后我把话摆在这儿:cjx 在高重复文本上的表现确实能看,长重复中文能压到 148 字节,同口径的 zlib 是 140 字节、bz2 是 222、lzma 是 188——这一组一百多字的短样本它夹在中间:比 zlib 略差,比 bz2 和 lzma 好。千字以上的整篇中文是另一回事,文末补测里它压过 zlib 与 lzma。但它在短文本上会反向膨胀,10 个字符能编出 61 字节。这两条同时成立,才是一个功能该有的样子。
我摆的这台秤,以及四组样本
先把装置说清楚,免得后面对不上账。
四组样本分别覆盖四种我在实际项目里真的会遇到的东西:第一组是重复短文本,一句话重复四十遍,模拟缓存键清单、枚举值列表这种;第二组是长重复中文,一句业务说明重复八十遍,模拟业务字典、字段说明、配置快照;第三组是随机 ASCII,6000 个字符从大小写字母和数字里随机抽,模拟 token、短 ID、签名串;第四组是重复结构 JSON,两百条同构记录,模拟落盘前的批量记录。
每一组我都做了三件事:用 cjx.encode 编、用 cjx.decode 解回来、把解回来的结果和原文逐字比对。比对结果四组全部为真,没有一组出现"看着像但差一个字符"的情况。这一点比压缩率更重要,因为一个解不回去的压缩功能等于没有。
同口径参照我选了三个:zlib.compress(raw, 6)、bz2.compress(raw, 9)、lzma.compress。选这三个是为了把"它到底站在哪一档"说清楚——zlib 快而弱,bz2 中等,lzma 最狠但最慢。一个自研编码如果不在这三档里定位,光说自己"能压缩"是没有意义的。
量出来是这样:
| 样本 | 原始字节 | cjx 后 | 压缩比 | 编码耗时 | 解码耗时 | zlib | bz2 | lzma |
|---|---|---|---|---|---|---|---|---|
| 重复短文本(1320 B) | 1320 | 69 | 19.13 | 1.04 ms | 0.35 ms | 54 | 102 | 112 |
| 长重复中文(7200 B) | 7200 | 148 | 48.65 | 4.03 ms | 1.56 ms | 140 | 222 | 188 |
| 随机 ASCII(6000 B) | 6000 | 4696 | 1.28 | 19.24 ms | 21.26 ms | 4523 | 4636 | 4736 |
| 重复结构 JSON(6762 B) | 6762 | 1493 | 4.53 | 17.02 ms | 4.60 ms | 828 | 521 | 540 |
这张表里有三个地方值得停一下。
第一个是长重复中文那一行。7200 字节压到 148 字节,48 倍,而 zlib 只到 140 字节——两边差距 8 个字节,基本可以认为打平。也就是说,在"一句中文重复八十遍"这种极端冗余的输入上,cjx 和 zlib 站在同一档。
第二个是随机 ASCII 那一行。6000 字节压到 4696,1.28 倍,这是它在四组里最难看的数字。但这不是它的问题:随机 ASCII 本身就没什么可压的,zlib 压到 4523、bz2 压到 4636、lzma 压到 4736,四个方案全都在 1.3 倍附近打转。一篇文章如果只拿这一组说事,就能把任何压缩工具写成废物,所以我把这一组留在表里,是为了让读者知道它的下限在哪。
第三个是重复结构 JSON 那一行。这一组它输得最明显:6762 压到 1493,而 zlib 是 828、bz2 是 521、lzma 是 540。原因不难猜,JSON 里大量的 {"uid":、"flag":true 这类重复片段,zlib 的 LZ77 窗口能直接抓整段重复,bz2 的分块排序更能吃这种结构化重复,而 cjx 看起来是按字符频率走的,抓不住跨字符的整段重复。这是机制差异,不是参数没调好。
短文本那一组,才是真正让我坐直的地方
真正的意外不在上面四组,在我后来补测的边界样本上。
我一开始以为 cjx.encode 是个"文本进、文本出"的接口,直接扔了 bytes 进去,它当场给我顶回来:
TypeError: Argument 'text' has incorrect type (expected str, got bytes)
签名要的是 str。行,那我按 str 来。然后我随手测了几个短的:
| 输入 | 原文字符 | cjx 后字节 |
|---|---|---|
| 空串 | 0 | 0 |
a | 1 | 33 |
aa | 2 | 34 |
ab | 2 | 37 |
中文 | 2 | 32 |
🙂🙂🙂 | 3 | 32 |
| 10 个中文字符 | 10 | 61 |
一个字符编出 33 字节,两个字符 34 字节,这个形状不像压缩,像"固定开销 + 极少量数据"。我顺着这条线把长度从 10 拉到 12000,把曲线量完整:
| 输入字符数 | cjx 后字节 |
|---|---|
| 10 | 61 |
| 50 | 104 |
| 100 | 107 |
| 500 | 112 |
| 1000 | 125 |
| 3000 | 159 |
| 6000 | 216 |
| 12000 | 329 |
前 100 个字符,字节数几乎不动,一直在 100 上下;100 之后开始缓慢爬,1000 到 6000 之间每千字符涨十几个字节。这个形状说明它每编一段都要带一份不短的头,头的大小跟字符表的规模有关——我去看了一眼 cjx.CHARLIST,长度是 974538,前几十个是空格、e、t、a、o、i、n、s、h、r…… 明显是按出现频率排过序的字符清单。
这就把话说圆了:它是拿一张近百万条的字符表做工件的,头里要交代这张表的用法,所以短文本必然被这层头压死;文本越长,头被摊薄,冗余被抓到,才开始出现 48 倍这种数字。
所以"压缩率"这三个字对它必须带条件说。同样一个功能,喂 10 个字符是 6 倍膨胀,喂 7200 字节是 48 倍压缩,中间没有过渡,这个特性用在什么地方就变得非常关键。
拉长到 90000 字节再量一次
为了确认上面那条判断不是被小样本骗了,我把样本放大:一句中文重复三千遍,90000 字节。
cjx编码后 460 字节,压缩比 195.65- 编码 31.8 ms,解码 13.3 ms
- 往返比对为真
- 同口径 zlib 是 278 字节
这一组把两件事同时钉住了。第一,它的压缩比确实能随文本变长继续爬,不是只有短样本好看;第二,跟 zlib 的差距依然存在(460 对 278),而且差距没有缩小。也就是说它不是"样本大就能反超"的类型,它稳定地落在 zlib 后面一点点。
我顺手把落盘这件事也想了一遍。这个库里跟落盘有关的是 Create_BHA 和 Ask_BHA,写出来的是 .bha,9.10.0 起只装布尔数组;9.12.0 起有了 BHAX_Descriptor,对应的扩展名是 .bhax,能混存 Int、Float、Bool 和 BHA_List 并按写入顺序还原。cjx 在这条链上的位置,是"落盘前把一段文本先编一下",不是替代 .bha 的容器格式。这两者别混:一个是文本编码,一个是布尔数组的落盘格式,各管一段。
我把它接进落盘流程,走了一遍完整链路
光量编码不够,我还得知道自己会不会真在一条落盘链上用上它。于是我把这个库的布尔数组落盘流程从头走了一遍,规模选 50 万位,内容按千分之一的比例散布 True——这种分布最像真实业务:一张开关表,绝大多数是关,少数是开。
构造那一步我先踩了个小坑。我按"数据在前、路径在后"的习惯写了 Create_BHA(a, p, mode="BHA"),直接被顶回来:
AttributeError: 'bool_hybrid_array.core.BoolHybridArray' object has no attribute 'lower'
这个报错的方向很明确——它把第一个位置当成 mode 字符串在转小写。翻过来看签名,实际是 Create_BHA(path, arr, mode='BHA'),路径在前、数组在后。把顺序摆正,链路就通了。
走完这一遍的数据是这样:
| 环节 | 实测结果 |
|---|---|
| 构造 50 万位(千分之一 True) | memory_usage() 2132,split_index 0,is_sparse True,count(True) 500 |
写 .bha | 5.67 ms,文件 125000 字节 |
读回 .bha | 3177.63 ms |
| 读回后校验 | len 500000、count(True) 500、memory_usage() 2132、split_index 0,与原对象逐位相等为真 |
这里面最扎眼的是写 5.67 毫秒、读 3177.63 毫秒,差了三个数量级。写的时候是把已经在内存里的稀疏下标一口气倒出去,读的时候要逐个把下标摊位还原成布尔数组,这个不对称我在别的库里没怎么见过,第一次跑出来我还以为计时写错了,又跑了一遍才对上。
顺手把更大一档也量了:500 万位、百分之一 True。
| 环节 | 实测结果 |
|---|---|
| 构造 | 1334.2 ms |
memory_usage() | 200132 |
split_index / is_sparse | 0 / True |
count(True) | 50000 |
TruesArray(5000000) 的 memory_usage() | 415 |
FalsesArray(5000000) 的 memory_usage() | 415 |
| 取下标得到的类型 | BHA_bool |
两个全真/全假的对象,内存占用都是 415 字节,这是极性塌缩的结果——整张表只有一个"默认值",没有逐位存东西。而 500 万里散着 5 万个 True 的那张,memory_usage() 是 200132 字节,比 numpy 原生 bool 数组的 5000000 字节小了一个数量级还多。这就是这个库真正在干的事,cjx 只是它旁边挂的一个小工具。
为什么我要把这条链走一遍?因为一篇文章如果只说"编码能压 48 倍",读者会以为它能把落盘体积一起压下去。实际不是:文本编码管的是文本那一段,布尔数组的体积归 BoolHybridArr 的稀疏存法管,两边各算各的账。你把一段 7200 字节的说明编成 148 字节,再把一张 50 万位的开关表写成 125000 字节,这 125000 字节一点没被 cjx 动过。认清这条边界,才不会在真实项目里指望错地方。
那张 974538 长的字符表,我多看了两眼
cjx.CHARLIST 的长度是 974538,前面几十位是空格、e、t、a、o、i、n、s、h、r、d、l、u、c、m、w、f、g、y、p、b、v、k、j、x、q、z,然后才是大写、然后才是别的。
这份顺序不是随手排的,它就是英文里字母出现的频率序:空格第一,e 第二,t 第三,a 第四。中文的表被压在很后面。这个细节解释了两件事。
一是为什么短文本那组数字会那么难看。表这么大,编一段就要交代"我用的是这张表里的哪一段",头自然短不了,10 个字符编出 61 字节就是这么来的。
二是为什么它不肯收 bytes。签名里写死 str,是因为整套东西是按"字符 → 频率位次 → 编码"这条路设计的,字节流没有字符边界,进去就断了。你要编二进制数据,得自己先转成文本;这也是它和 zlib、bz2 那类纯字节压缩工具最根本的分野——后两者根本不关心你喂进去的是中文、英文还是一段裸字节。
我把这句话再说直白一点:cjx 是一个文本编码器,不是一个通用压缩器。你拿它跟 zlib 比压缩率,只能在文本这一档比;你拿它去压二进制,第一步就先被类型挡住。
那它在什么场景里真能省事
我不打算把它写成万能,也不打算把它写成一无是处。按我量到的形状,它合适的场景很具体:
第一,长文本、且重复度高的。 日志片段、业务说明、字段字典、配置快照这类,动辄几千字符、内容高度雷同,能吃到 40 倍往上,而且编码只要几毫秒。
第二,要在库里顺手把文本塞进同一条落盘流程的。 因为它和 BoolHybridArr、TruesArray、FalsesArray 是同一个包出来的,你在写 .bha / .bhax 的那套代码里不必再额外引一个压缩库,少一个依赖就少一份版本冲突。这一条我在做四十多张表的落盘时体会过:split_index 设多少、memory_usage() 出来多少、要不要 optimize() 重建一遍,这些已经够绕了,编码环节越简单越好。
第三,对"最短字节"不敏感、但对"别引新依赖"敏感的场合。 它比 zlib 差一点点,但差的是几十个字节;如果你本来就在用这个库,省下的那一个依赖可能比那几十个字节值钱。
反过来,这几种情况我会直接选 zlib:单条记录只有几十个字符的(头部开销吃掉一切);结构化重复极强的 JSON 批量(这一组它 1493 对 zlib 828,差得明显);以及要求极限压缩比的归档场景,那种场合我会上 lzma 而不是它。
我在这一轮量到的所有数字,摊在这儿
- 本机
bool_hybrid_array9.13.12,与 PyPI latest 一致 - 许可证 classifier:Apache-2.0 与 MulanPSL-2.0 双挂
- 重复短文本 1320 → 69 字节,1.04 ms / 0.35 ms
- 长重复中文 7200 → 148 字节,4.03 ms / 1.56 ms
- 随机 ASCII 6000 → 4696 字节,19.24 ms / 21.26 ms
- 重复结构 JSON 6762 → 1493 字节,17.02 ms / 4.60 ms
- 90000 字节重复中文 → 460 字节,31.8 ms / 13.3 ms,zlib 同口径 278 字节
- 空串 → 0 字节,可解回空串
- 单字符
a→ 33 字节;10 个中文字符 → 61 字节;12000 字符 → 329 字节 CHARLIST长度 974538,按频率排序cjx.encode只收str,传bytes报TypeError: Argument 'text' has incorrect type (expected str, got bytes)- 四组大样本加一组 90000 字节样本,往返比对全部为真
先把 README 读明白再动手,这一节是我被打脸的地方
我原来这一节叫「一个最小可跑的组合」,里面那段代码是我自己拼的:能跑、数字也对,但它不是 README 里的示例。这个差别很要命——读者拿它去对 README,会发现对不上;更糟的是,它看起来能跑,于是很容易让人以为作者就是这么设计的。
所以这一节我整个换掉,现在呈上来的是 README 原文,一个字没改。
话先摆在前头:测任何一个功能,第一步是把 README 里对应那一段读完,照它写的类名、函数名、参数顺序、示例代码去跑。不要自己拼示例,不要自己猜接口叫什么,更不要伸手去摸那些没写进文档的私有接口。原因很朴素——这个库的公开面比你猜的小得多。BoolHybridArr([...])、TruesArray(n)、FalsesArray(n)、Create_BHA(path, arr, mode='BHA')、Ask_BHA(...)、BHAX_Descriptor 这些写法 README 里都摆着,照着用就不会错;你一旦绕开它去「探索」,探出来的十有八九是名字对不上、参数顺序反了、或者干脆是内部私有函数,然后你会拿着一份错的结论,写出一篇看着很有道理的文章。
我这一轮就是这么被自己坑了一次。
README 里 cjx 那一段的原文是这样(9.13.12 版本新增):
#cjx纯文本压缩算法(9.13.12版本新增)
from bool_hybrid_array import cjx
x = cjx.encode("Hello CJX!"*100)
print(len(x))
print(encode(x)[:15])
原样粘进本机跑,前两句顺利:
69
410 个字符的 Hello CJX! 重复一百遍,编完 69 字节,和我前面那张表的量级完全对得上,说明这组示例本身站得住。
第三句直接炸了:
NameError: name 'encode' is not defined
这就是照抄的价值。我要是「聪明」一点,顺手改成 cjx.encode(x)[:15] 然后宣布「README 写错了」,那只是猜。照抄跑一遍,拿到真实的 NameError 原文,我才有资格说这是笔误——上一行刚 from bool_hybrid_array import cjx,把 encode 裸着调用,显然漏了 cjx. 前缀;而且这里要看的是解码结果的头 15 个字符,不是再编码一次。
按上下文修正后的写法与实测结果:
print(cjx.decode(x)[:15])
Hello CJX!Hello
再补一句校验:cjx.decode(x) == "Hello CJX!"*100 为 True。往返闭合,这组示例从头到尾是通的。
这一节的结论分两层。第一层是态度:先读 README,再动手,别自行探索。第二层是分寸:先读 README 不等于盲从,README 也会有笔误,但「它写错了」这句话必须建立在你照抄跑过、拿到报错原文之上;没跑过就断言文档错,那是另一种自行探索。
README 给的是用法,不是数据。构造方式照它写,喂进去的内容还得是你自己的场景:
from bool_hybrid_array import BoolHybridArr, TruesArray, FalsesArray, Create_BHA, Ask_BHA, cjx
switch = BoolHybridArr([i % 1000 == 0 for i in range(500_000)])
print(switch.memory_usage(), switch.split_index, switch.is_sparse, switch.count(True))
Create_BHA("/tmp/mix500k.bha", switch, mode="BHA")
back = Ask_BHA("/tmp/mix500k.bha", mode="BHA")
print(len(back), back.count(True), back.memory_usage(), back == switch)
note = "订单表分片按用户号取模,落盘前统一编码,读回按写入顺序还原。" * 80
enc = cjx.encode(note)
print(len(enc), cjx.decode(enc) == note)
上面这一小段里,BoolHybridArr([...])、Create_BHA、Ask_BHA 的写法都来自 README,列表里那五十万个布尔值和那句重复八十遍的说明是我按自己业务填的——跑出来的 2132 0 True 500、500000 500 2132 True、148 True 是这组数据的实测,不是文档里的示例输出。
三个点值得提前说,省得你也踩一遍——它们全是我没先读 README、硬试出来的,正因如此才算得上教训。
第一个是 count 必须带值。我一开始顺手写了 switch.count(),它不干;这个接口要的是"数哪一个",count(True)、count(False) 分开数,没有那种"不分真假一起数"的默认行为。
第二个是 Create_BHA 的参数顺序。路径在前、数组在后,mode 默认就是 "BHA"。我按习惯写反了,报的是 'BoolHybridArray' object has no attribute 'lower'——这个报错看着跟类型八竿子打不着,其实它在拿第一参数当 mode 转小写,撞上了对象。第一次见这个错,很容易以为是库内部坏了。
第三个是 Ask_BHA 的耗时。读回 50 万位那张表用了 3177.63 毫秒,比你预期的长得多,别以为是卡住了。它的代价在"把稀疏下标还原成逐位布尔"这一步,规模越大越明显。要在服务启动路径里读回大表,最好放到后台预热,别塞在请求里。
收尾:一句话给下一个人
如果有人问我"这库的 cjx 能不能当压缩用",我会这么答:它挑文本:千字以上的整篇中文压得过 zlib 和 lzma,几百字的短样本跟 zlib 持平或差十几个字节,同一段复制上百遍则输给通用压缩器。你得先知道自己手上那把东西有多长、有多重复,再决定用不用它。至于我自己,接下来还是会在写 .bhax 的那条流程里继续用它编文本——但只在长度过千的那一档,几十个字符的字段名我绝不上它。
装它是一行 pip install bool-hybrid-array,版本号自己对着 PyPI 看,别照抄我这里的 9.13.12,我这边只是此刻的快照。
补一组:三篇中文名篇单篇实测,与通用压缩器比同一份文本
写完上面十二组,群里有人问:你那组样本太小,拿《背影》整篇来。我把三篇文章的纯正文各跑了一遍,同一口径(UTF-8 字节数、单进程内 time.perf_counter、roundtrip 校验):
| 样本 | 字数 | 原始字节 | cjx | 压缩率 | zlib-9 | bz2 | lzma |
|---|---|---|---|---|---|---|---|
| 背影·朱自清 | 1302 | 3906 | 1983 | 50.77% | 2104 | 1990 | 2184 |
| 草原·老舍 | 819 | 2457 | 1393 | 56.70% | 1407 | 1395 | 1512 |
| 丁香结·宗璞 | 432 | 1296 | 824 | 63.58% | 814 | 836 | 932 |
| 三篇拼一篇 | 2553 | 7659 | 3664 | 47.84% | 4090 | 3716 | 4044 |
| 三篇合集 ×10 | 25530 | 76590 | 4401 | 5.75% | 4761 | 6610 | 4128 |
| 三篇合集 ×100 | 255300 | 765900 | 11735 | 1.53% | 9427 | 8808 | 4228 |
三篇 roundtrip 全部通过。单篇这一档,《背影》压到 1983 字节,比 zlib 少 121、比 bz2 少 7、比 lzma 少 201;《草原》比 zlib 少 14、比 lzma 少 119;三篇拼成 2553 字的长文比 zlib 少 426、比 bz2 少 52、比 lzma 少 380。
唯一压不过通用压缩器的是《丁香结》:432 字、1296 字节这种小样本,824 对 zlib 的 814,差 10 个字节。这个边界得写清楚。
再到重复一百遍这一档,方向反过来:11735 对 zlib 的 9427、bz2 的 8808、lzma 的 4228。整段原文复制一百遍是长距完全重复,通用压缩器的窗口匹配专门吃这种结构;×10 那一档同样趋势,cjx 4401 赢 zlib 4761,输 lzma 4128。
所以结论一句:同一篇文章只出现一次的常规中文场景,它站在通用压缩器前面;同一段复制几十上百遍的极端场景,通用压缩器在前面。