九组样本跑完,cjx 只赢了两场半:我跟 zlib、bz2、lzma 打了一轮对照

11 阅读19分钟

先说结论,省得你看到一半才反应过来:新出的 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(五千字符)、同一句中文短句重复一百二十遍(六千一百字符)、八万七千字符随机小写字母。

有一点必须说清楚:这里的"随机",我是用固定种子的伪随机生成器逐字符抽的,不是拿现成的语料库切片。这样下次同样种子还能复现,不用为"你用的样本跟我用的不一样"吵架。

第三件事:表格摊开看

我把九组结果按压缩率从好到差排了一遍,单位都是字节,粗体是该组的最小值:

样本原始cjxzlibbz2lzmacjx 压缩率
交替 015000573042961.14%
半 0 半 150006430521001.28%
短句 120 遍61201591031731522.60%
源码重复280010758981163.82%
随机 0/1500067988889792813.58%
JSON 200 行1757025881422103095214.73%
中文日志10327178097182780017.24%
八万七千随机字母870003813142123375563808443.83%
随机小写 50005000311931203059314062.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 解码
中文日志 1032724.30 ms6.23 ms
JSON 200 行 1757039.08 ms12.30 ms
源码重复 28003.30 ms1.44 ms
随机 0/1 50003.76 ms1.98 ms
随机小写 500014.73 ms12.20 ms
半 0 半 1 50002.46 ms1.28 ms
交替 01 50002.49 ms1.28 ms
短句 120 遍 61205.09 ms2.13 ms
八万七千随机字母208.66 ms402.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%248.0 ms12956 B99998
半 0 半 137.2 ms6700 B49999
随机 50%47.6 ms12956 B99998
全 True0.1 ms426 B316

对比百万级那张表,规律是一致的:体积基本随 N 线性缩放(十万 12956 字节,百万 125469 字节,差 9.7 倍而不是 10 倍,原因在头部和取整),写入耗时也从 510 毫秒降到 48 毫秒,同样接近十倍。也就是说这套东西没有"规模阈值"这种玄学,你拿十万级的数据先试一遍,得到的比例关系在百万级基本还成立。

但有一列不太一样:全 True 的 split_index 从百万级的 1000 变成了十万级的 316。这个数是构造过程中"密集区/稀疏区"分裂的位置,跟数据分布和规模都有关系,不是一个可预测的固定值。我提这一列是想说明:如果你要读 split_index 做判断,别把它当规格用,它只是当下那次构造的结果。

该不该用:给你三行判断

我不喜欢给"推荐使用"这种空话,直接给判断条件:

第一,你的数据字母表是不是很小(比如只有 0/1,或者十六进制十六个符号)?是,就试 cjx,我实测这类能比 zlib 省 20% 上下。

第二,你压完是存档还是热读?存档,随便用;热读而且数据量大,先量一遍解码耗时再决定,八万七千字符那组 402 毫秒不是闹着玩的。

第三,你的数据是自然语言、JSON、源码?那就别折腾了,zlib 或 bz2 现成的更省,我这九组里它们赢了六组半。

最后补一句边界:这轮所有数字都是我这台机器、这个版本、这个种子跑出来的,换机器换版本数字会变,尤其是耗时。压缩率相对稳定,耗时别当常数用。你自己那份数据,花十分钟跑一遍对照,比看我这篇文章有用得多。