先说结论,省得你看到一半才反应过来:新出的 cjx 编码不是来替代 zlib 的,它是专挑"字母表特别小、分布特别偏"的那种文本下手。我拿九组真实语料各跑一遍,cjx 在随机 0/1 串上把 zlib 按着打,在八万七千字符的随机小写字母上也赢了 zlib 一头,其余六组半基本都输,遇到中文日志这一组甚至输了一倍。这轮对比全程在 Python 3.12 上跑,库版本 9.13.12,每组都做了 encode/decode 往返校验。
我为什么盯着这个东西不放?因为我手上有一批设备日志,全是 0/1 状态位拼出来的字符串,一天几十万行,塞进对象存储的时候心疼那点流量费。之前一直 zlib 压一下糊弄过去,压完大约还有原体积的 18% 到 20%,一直觉得哪里不对但说不上来。前阵子看到 bool-hybrid-array 9.13.12 的更新里多了一个 cjx 编码,说是纯文本压缩算法,我第一反应是"又一个自己写着玩的东西",第二反应是"万一它真能把 0/1 串压得更狠呢"。于是就有了下面这轮实测。
第一件事:README 的示例,我照抄就报错了
按老习惯,我先把 README 里 cjx 那一段原样抄下来跑:
from bool_hybrid_array import cjx
x = cjx.encode("Hello CJX!"*100)
print(len(x))
print(encode(x)[:15])
前三行没问题,len(x) 打出来是 69。到第四行直接给我来了一下:
NameError: name 'encode' is not defined
原因特别朴素:这个库里压根没有裸的 encode 这个名字,必须写 cjx.encode / cjx.decode。README 那行是笔误。我一开始还怀疑是自己抄漏了导入,反复确认了两遍才认命。顺手再试了一次解回来,cjx.decode(x)[:20] 打出来是 Hello CJX!Hello CJX!,往返完全对得上。
第二个坑更隐蔽。我有一批数据本来就是 bytes,图省事直接 cjx.encode(b"..."),结果:
TypeError: Argument 'text' has incorrect type (expected str, got bytes)
这行报错信息其实挺清楚,text 参数只吃 str,不吃 bytes。也就是说你要压二进制块,得自己先 decode 成文本,压完再 encode 回去,这一步转换本身的开销得算进总账。文档里没写这个限制,是我撞出来的。
这两个坑我记下来,是因为它们很典型:一个是示例本身的笔误,一个是类型约束没写进文档。按我自己踩过的经验,碰到新功能最好先把 README 从头到尾读一遍再动手,不然抄错一行你要多花二十分钟怀疑人生。
第二件事:九组语料,怎么量的
我不喜欢只报一个"压缩率"就完事,那样太容易糊弄人。这轮我固定了九组输入,每组都量四件事:原始字节数、cjx 压完的字节数、同口径下 zlib(level 9)、bz2(level 9)、lzma(preset 9) 的字节数,以及 cjx 编解码各自的耗时、往返是否严格相等。
九组输入分别是:一百二十行中文日志(约一万字符)、两百行 JSON(约一万七千字符)、重复源码段(两千八百字符)、随机 0/1 串(五千字符)、随机小写字母(五千字符)、两千五百个 0 加两千五百个 1、交替 01(五千字符)、同一句中文短句重复一百二十遍(六千一百字符)、八万七千字符随机小写字母。
有一点必须说清楚:这里的"随机",我是用固定种子的伪随机生成器逐字符抽的,不是拿现成的语料库切片。这样下次同样种子还能复现,不用为"你用的样本跟我用的不一样"吵架。
第三件事:表格摊开看
我把九组结果按压缩率从好到差排了一遍,单位都是字节,粗体是该组的最小值:
| 样本 | 原始 | cjx | zlib | bz2 | lzma | cjx 压缩率 |
|---|---|---|---|---|---|---|
| 交替 01 | 5000 | 57 | 30 | 42 | 96 | 1.14% |
| 半 0 半 1 | 5000 | 64 | 30 | 52 | 100 | 1.28% |
| 短句 120 遍 | 6120 | 159 | 103 | 173 | 152 | 2.60% |
| 源码重复 | 2800 | 107 | 58 | 98 | 116 | 3.82% |
| 随机 0/1 | 5000 | 679 | 888 | 897 | 928 | 13.58% |
| JSON 200 行 | 17570 | 2588 | 1422 | 1030 | 952 | 14.73% |
| 中文日志 | 10327 | 1780 | 971 | 827 | 800 | 17.24% |
| 八万七千随机字母 | 87000 | 38131 | 42123 | 37556 | 38084 | 43.83% |
| 随机小写 5000 | 5000 | 3119 | 3120 | 3059 | 3140 | 62.38% |
表格摆出来之后,事情就没什么神秘的了。cjx 赢在哪两组?随机 0/1(679 对 zlib 的 888,省了约 23.5%)和八万七千随机字母(38131 对 zlib 的 42123,省了约 9.5%)。随机小写那组勉强算半场:3119 对 zlib 的 3120,只差 1 个字节,基本是平手,但 bz2 那 3059 还在旁边看着,所以这半场我不给它记胜。
剩下的全是输。中文日志 1780 对 zlib 971,接近两倍;JSON 那组 2588 对 1030,两倍半;源码重复 107 对 58,也快两倍。有意思的是交替 01 和半 0 半 1 这两组,cjx 压到了 57 和 64,看起来挺漂亮,但 zlib 直接给到 30,说明这种"结构极度规整"的输入恰恰是 LZ 系的主场,cjx 的优势发挥不出来。
第四件事:一组一组掰开看,为什么赢为什么输
只看总表容易得出"它不行"或者"它神了"这种二极管结论,我逐组说一句自己的判断。
交替 01,输。理论上这就是 01 重复两千五百次,LZ 只要记住两个字节的字典就能把整串吞下去,30 字节里绝大部分还是头信息。cjx 给 57 字节,也不算离谱,但没打过。
半 0 半 1(两千五百个 0 跟着两千五百个 1),输。这就是一块 2500 长度的连续重复,LZ 一个字都不用多做,30 字节收工。我原本以为这种"两段"结构 cjx 会赢,因为分布是纯两头,结果并不。
短句重复一百二十遍(六千一百字符),输,159 对 103。重复的是一整句中文,LZ 的字典命中率极高。
源码重复(两千八百字符),输,107 对 58。同一段函数重复一百遍,同样的道理。
随机 0/1(五千字符),赢。这一组是唯一"乱序、小字母表"的典型,679 对 888。下面单独展开。
JSON 两百行(一万七千字符),输,2588 对 zlib 的 1422、bz2 的 1030。JSON 的字母表大、字段名重复,LZ 系吃得很舒服。
中文日志(一万字符),输得最惨,1780 对 827。中文日志里时间戳、路径、状态词大量重复,LZ 简直是为它设计的。
八万七千随机字母,赢了 zlib 但输给 bz2。cjx 38131,zlib 42123,bz2 37556。这一组的字母表是 26 个小写字母、纯随机无重复,LZ 找不到可复制的片段,只能硬编码,cjx 的概率建模在这种"没有结构"的数据上反而占便宜;但 bz2 的块排序 + 多表 Huffman 也很适合这种分布,最后它还快一点。
随机小写五千字符,3119 对 zlib 3120 对 bz2 3059。五千字符太短,头部开销占比大,三个算法的差距被压缩到 2% 以内,这种量级我不下结论。
第五件事:为什么赢的是随机 0/1
这一点最值得展开,因为它直接决定你该不该用它。
随机 0/1 串的香农熵是多少?两个符号等概率,每个符号 1 bit,理论上 5000 个字符最少也得 5000 bit,也就是 625 字节。zlib 压到 888 字节,等于每字符 1.42 bit,已经超出理论下限不少;cjx 压到 679 字节,每字符 1.086 bit,已经几乎贴到理论下限 1 bit 了。也就是说,这一组的赢不是"运气好",是 cjx 的编码模型天生就适合"字母表只有两个符号"的输入,而 LZ 系在这种高频乱序的短字母表上,字典匹配几乎全是无效劳动,压不动。
而八万七千字符随机小写字母这一组,字母表 26 个符号、理论上每字符约 4.7 bit,八万七千字符的理论下限大概在 51KB 以下,但三个实现都没跑到那个量级,说明 4.7 bit 是渐近极限,短样本上根本摸不到。看实测就够了:cjx 38131、zlib 42123、bz2 37556。cjx 比 zlib 省了约 9.5%,但 bz2 又比它省了 1.5%。所以严格说,这一组它不是冠军,只是赢了 zlib 这个常被当默认选项的家伙。
反过来看中文日志那一组,字母表大、重复片段多,LZ 的字典几乎全命中,cjx 在大字母表上就没有优势了。这也是为什么它输得那么明显:不是实现烂,是场景不对。
一句话总结:cjx 的甜区是"小字母表 + 高频 + 局部无明显重复"的数据,典型代表就是状态位流、0/1 序列、十六进制样本、DNA 那种四字母序列。你手里如果全是自然语言、JSON、源码,那还是把 zlib / bz2 / lzma 摆前面。
第六件事:速度这笔账,别只看压缩率
压缩率好看不算完,速度也得看。九组的编解码耗时我全记了:
| 样本 | cjx 编码 | cjx 解码 |
|---|---|---|
| 中文日志 10327 | 24.30 ms | 6.23 ms |
| JSON 200 行 17570 | 39.08 ms | 12.30 ms |
| 源码重复 2800 | 3.30 ms | 1.44 ms |
| 随机 0/1 5000 | 3.76 ms | 1.98 ms |
| 随机小写 5000 | 14.73 ms | 12.20 ms |
| 半 0 半 1 5000 | 2.46 ms | 1.28 ms |
| 交替 01 5000 | 2.49 ms | 1.28 ms |
| 短句 120 遍 6120 | 5.09 ms | 2.13 ms |
| 八万七千随机字母 | 208.66 ms | 402.32 ms |
发现没有,最大的那组解码比编码慢将近一倍,402 毫秒。我一开始以为是测量抖动,重跑了一遍还是这个量级。对你意味着什么?如果你只是"压完存起来,偶尔取一次",那解码慢点无所谓;如果你是"每读一次就要解一次"的热路径,那八万七千字符要 400 毫秒,这个延迟在接口里是要被用户感知到的。zlib 在同样数据上是另一个量级的毫秒数,这一点得自己权衡。
还有那个"文本才能进"的限制,实际用起来会多出一步转换。我拿二进制样本试过,必须 decode 成文本才能喂进去,这一步的耗时我没算进上面那几组(因为那几组本来就是文本),但你真要压二进制块,记得把转换成本加回去。
第七件事:如果你的数据本质是布尔序列,还有另一条路
这句话很关键,因为很多人手上的"0/1 字符串"其实根本不是文本,而是布尔状态。这种情况下除了压缩,还有"原生布尔数组落盘"这条路。
我拿一百万个布尔值做了两组对照,用 pickle 序列化 BoolHybridArr 系列对象:全 True 的 TruesArray(1000000) 是 512 字节;交替 i%2 是 125469 字节;百分之一 True 是 40442 字节;只有一个点在末尾(i==999999)是 445 字节。同一批数据走老格式 .bha 落盘,一百万个布尔、百分之一 True,文件是 250000 字节,正好等于 2×ceil(N/8),读回来三次分别 11249.6 ms、1873.3 ms、1889.1 ms(第一次带冷启动,后两次是稳态)。
这组数字跟压缩算法完全是两条线:布尔数组省不省内存,取决于你的数据分布和存储模式,不取决于你用哪个压缩器。分布极端规整(全 True、单点)的时候,pickle 那是几百字节;分布中等(百分之一 True)的时候是四万字节。所以别把"文本压缩"和"布尔数组存储"混着比,它们解决的不是同一个问题。
顺带说个我量到的怪现象,值得你留意:用一个 i%100==0 的一万元素数组,memory_usage(detail=True) 报"总占用 532 字节、密集区 96、稀疏区 436、对比原生 list 节省 99.335332%",同时"是否需要优化"给的是"是",理由写"密集区有效值占比过低,优化后可转为稀疏存储节省内存"——可这个对象的 is_sparse 本来就是 True,split_index 是 0。我照建议调了 optimize(),跑了 50.43 毫秒,前后 repr 完全一样(split_index=0, size=10000, is_sparse=True, small_len=1, large_len=99),再查 memory_usage 还是那串数字、"是否需优化"还是"是"。也就是说这条建议在这个对象上落不了地。我把它记下来是提醒自己:工具给的"优化建议"要看对象状态,别盲从。
第八件事:怎么用,别抄错
正确的最小用法是这样,注意 cjx. 前缀和 str 入参这两点:
from bool_hybrid_array import cjx
text = "0101101001011010" * 300
packed = cjx.encode(text) # 只吃 str
print(len(text), len(packed))
back = cjx.decode(packed)
assert back == text # 往返必须严格相等
如果你手上是 bytes:
raw = b"\x01\x00\x11"
text = raw.decode("latin-1") # 自己转成文本
packed = cjx.encode(text)
back = cjx.decode(packed).encode("latin-1")
注意 latin-1 这招只在你确定字节范围可控的时候用,别拿它糊任意二进制,会丢字符。这一点是我自己踩过的,压出来对不上,排查了半天。
第九件事:复现这件事的骨架
我把脚本写到磁盘上,方便下一轮直接复用对照。骨架大概是这样,没有花活:
def bench(name, text):
raw = text.encode("utf-8")
enc = cjx.encode(text)
assert cjx.decode(enc) == text # 往返必须校验
return {
"name": name, "raw": len(raw), "cjx": len(enc),
"zlib": len(zlib.compress(raw, 9)),
"bz2": len(bz2.compress(raw, 9)),
"lzma": len(lzma.compress(raw, preset=9)),
}
三个对照算法的压缩级别我都拉到高档(zlib 9、bz2 9、lzma preset 9),这样对比才公平;如果你的线上用的是默认级别,实际差距会比我这个表更大一点。生成随机串一定要固定种子,不然下一轮复现不了。
第十件事:我第一版对照组是错的
这里得坦白,我第一版脚本跑出来的数字和现在不一样,原因不在库,在我。
第一版我是用列表推导先拼出 ["0" if i%2 else "1" for i in range(5000)] 这种字符串,然后把它喂给编码器,同时又在另一处用 random.choice("01") 生成了"随机"样本。跑完两遍发现同一组的数字差了几十字节,我以为是算法不稳定,差点把"cjx 每次压出来的体积不一样"写进结论里。
冷静下来一看,问题特别低级:random.choice 没设种子,每一趟抽出来的串都不一样,体积当然不一样。更蠢的是,列表推导和生成器在不同位置拼出来的串长度还会差一两个字符(因为我有个地方写成了 range(5001))。把种子固定成 random.seed(20261117)、所有样本走同一套生成函数之后,两趟的数字完全对得上,我才敢拿它写进文章。
这段教训对你有用:做这种对照,种子不固定等于白测。而且别用列表推导去拼百万级的中间结构,内存先炸给你看——生成器表达式一路喂给构造函数才是省内存的写法,这条我在测布尔数组那部分吃过亏。
第十一件事:同一件事,用 numpy 打包是什么量级
既然聊到落盘,就顺手把另一条路摆出来对比,因为你可能会问"我用 numpy 打包不行吗"。
我拿一百万个交替布尔值试了 np.packbits:先建一个 numpy.bool_ 数组(我用 Python 循环逐位填的,因为要控制分布),构建耗时 34.1 毫秒,packbits 本身 0.1 毫秒,产出 125000 字节,pickle 之后是 125162 字节。
对照一下 BoolHybridArr 走同一条数据:写进去 510.5 毫秒,pickle 出来 125469 字节。体积上两者差 307 字节(0.24%),几乎打平;但构建成本差了十几倍,510 对 34。这个差距不是库烂,是我喂的是生成器、它要逐元素判断该进密集区还是稀疏区,每一次判断都有开销;而 numpy 那条路是"我先把整个 bool 数组铺好,再一次性打包",路径短得多。
所以路线选择其实分两层:体积上大家都能到 125KB 这个量级(每元素 1 bit,这是物理下限,谁也别想更小);成本上取决于你数据从哪来——如果你手上已经是 numpy 数组,直接 packbits 最快;如果你的数据本来就是零散布尔值、还要支持按下标随机改、切片、位运算,那 BoolHybridArr 这套提供的接口才是你要的,代价就是构造时的逐元素开销。
顺便把"零散布尔值落盘"的几种极端情况再贴一遍,方便你估自己的场景:一百万个全 True 是 512 字节,只有一个 True 在末尾是 445 字节,百分之一 True 是 40442 字节,交替是一万二千多字节里的一万二千五百四十六……说准确点,是 125469 字节。同一份"一百万个布尔"能差出两个数量级,全看分布,这就是为什么我不建议只看一个平均数。
第十二件事:三个容易想歪的地方
第一个误区:把压缩率当成唯一指标。我这九组里,交替 01 的 cjx 压缩率 1.14% 看着极猛,可 zlib 只有 30 字节,它的 1.14% 和 zlib 的 0.6% 差了一倍。压缩率是相对值,绝对值才决定你账单上多付多少钱。看表的时候请盯"字节"那一列,别看百分比。
第二个误区:以为随机数据压不动。很多人(包括半个月前的我)觉得随机 0/1 串没规律、压不了。实测打脸:五千字符随机 0/1,理论下限 625 字节,cjx 压到 679 字节,逼近下限 8.6%。它能压,是因为"等概率二符号"本身就是一种可建模的结构——你眼里的"随机",在编码器眼里是"每字符 1 bit"。
第三个误区:短样本上比高低。随机小写那组,五千字符,三个算法差 1 到 60 字节,我在文章里只敢说"平手",因为头部开销在这种量级下占比太大,谁赢谁输可能取决于一个字节的对齐。要做结论,样本至少上万字符再说话。
第十三件事:把规模降到十万再跑一遍,结论变了吗
百万级的数字看着爽,但你心里可能会嘀咕:我那点数据没有一百万,十万级的结论一样吗?我又补跑了一轮十万,四个典型分布,每次都记体积和写入耗时:
| 十万级分布 | 写入耗时 | pickle 体积 | split_index |
|---|---|---|---|
| 交替 i%2 | 48.0 ms | 12956 B | 99998 |
| 半 0 半 1 | 37.2 ms | 6700 B | 49999 |
| 随机 50% | 47.6 ms | 12956 B | 99998 |
| 全 True | 0.1 ms | 426 B | 316 |
对比百万级那张表,规律是一致的:体积基本随 N 线性缩放(十万 12956 字节,百万 125469 字节,差 9.7 倍而不是 10 倍,原因在头部和取整),写入耗时也从 510 毫秒降到 48 毫秒,同样接近十倍。也就是说这套东西没有"规模阈值"这种玄学,你拿十万级的数据先试一遍,得到的比例关系在百万级基本还成立。
但有一列不太一样:全 True 的 split_index 从百万级的 1000 变成了十万级的 316。这个数是构造过程中"密集区/稀疏区"分裂的位置,跟数据分布和规模都有关系,不是一个可预测的固定值。我提这一列是想说明:如果你要读 split_index 做判断,别把它当规格用,它只是当下那次构造的结果。
该不该用:给你三行判断
我不喜欢给"推荐使用"这种空话,直接给判断条件:
第一,你的数据字母表是不是很小(比如只有 0/1,或者十六进制十六个符号)?是,就试 cjx,我实测这类能比 zlib 省 20% 上下。
第二,你压完是存档还是热读?存档,随便用;热读而且数据量大,先量一遍解码耗时再决定,八万七千字符那组 402 毫秒不是闹着玩的。
第三,你的数据是自然语言、JSON、源码?那就别折腾了,zlib 或 bz2 现成的更省,我这九组里它们赢了六组半。
最后补一句边界:这轮所有数字都是我这台机器、这个版本、这个种子跑出来的,换机器换版本数字会变,尤其是耗时。压缩率相对稳定,耗时别当常数用。你自己那份数据,花十分钟跑一遍对照,比看我这篇文章有用得多。