运维同学做过一组对比:同一台机器上,40MB 的访问日志用 gzip 压完只剩 3MB;顺手把素材目录里两百张 JPEG 也打了个 zip,180MB 变成 178MB。他问是不是 zip 的参数没调对,为什么同样是压缩,一个压到十分之一,一个几乎没动。

不是参数问题。日志里全是重复的字段名、固定的时间格式、反复出现的单词,压缩器很容易找到规律。JPEG 在生成的时候,已经把像素里的规律用掉了一遍,剩下的字节看起来接近随机。压缩工具面对已经压过的数据,几乎没有活可干,能省下的只有包装和索引的零头。

这篇讲清楚「变小」的来源:压缩器到底在吃什么、信息量怎么量化、哪些数据天生压不动,以及压缩比背后要付的 CPU、内存和随机访问这三笔账。下一篇再分无损和有损,讲 JPEG 和 MP3 具体扔掉了什么。

现象真实原因第一步查什么
日志能压到十分之一,图片几乎压不动日志有大量重复字段和固定格式,图片像素信息已接近随机分别算一段数据的字节熵,看是不是接近每字节 8 bit
给 JPEG、MP3、MP4 再打 zip,只小一点点这些格式本身已做过有损压缩,剩下的是编码后的高熵数据确认源文件是不是已经压缩过的格式,不要重复压缩
随机数字文件压完反而变大没有可利用的规律,压缩器还要额外写文件头、索引和校验比较压缩前后的字节数,算一下头部的固定开销
同一个文件用最高级别压缩,只多省 2%收益受内容熵限制,级别再高也只能逼近下限,CPU 却成倍增加记录不同级别的耗时和输出大小,算每省 1MB 要多花多少时间
压缩后的文件想直接跳到中间某一段,读不出来多数通用压缩是流式的,后面的数据依赖前面的解压结果查格式是否支持随机访问,或是否需要先建索引
上传一个 10KB 的压缩包,解压后占满磁盘压缩炸弹:嵌套结构和极高压缩比让解压体积失控解压前限制总输出大小和压缩比,不要只看压缩包大小
视频转码后文件更大、画面还更糊码率、分辨率、编码参数和内容复杂度不匹配看转码后的码率、关键帧间隔和编码 preset,而不是只看分辨率

压缩只有两条路:还原,或者扔掉

先把词定清楚。压缩就是让表示同一份内容所需的字节变少。按照能不能原样还原,分成两类。

无损压缩要求解压后的每一个字节都和原文件一致,适合文本、代码、日志、数据库备份、可执行文件。它的做法是找数据里的重复和规律,换成更紧凑的表示。你熟悉的 zip、gzip、7z、zstd 都属于这一类。

有损压缩允许解压结果和原文件不一样,只要人的眼睛或耳朵察觉不到。JPEG 会丢掉颜色细节,MP3 会丢掉被强音盖住的弱音,H.264 会丢掉相邻帧里重复的画面。它们的压缩比通常远高于无损,代价是信息真的没了,反复转码会一层层变差。

无损压缩:一个字节都不能错

文本、配置、日志、源代码、压缩包本身。压缩比通常 2:1 到 10:1,取决于内容重复程度。解压必须完整,通常不支持跳到文件中间直接读。

有损压缩:只保留人感知得到的部分

照片、音乐、视频。压缩比可以到 10:1 甚至 100:1,代价是细节永久丢失。每次解码再编码都会再损失一次,所以素材要保留原始档。

很多人把这两类混在一起谈「压缩率」,于是得出错误结论:既然视频能压到百分之一,日志为什么不能。两者能丢的东西根本不一样,分母也不同。无损压缩的下限由数据本身的信息量决定,有损压缩的下限由人的感知决定,后者可以低得多,但前提是你愿意接受「不一样」。

顺带把压缩比的写法统一一下:写成 8:1 时,意思是原始大小是压缩后的八倍;写成省下 87.5% 时,意思是压缩后只剩原来的八分之一。两个数字指的是同一件事,但混着说容易让人误判,做容量规划时最好把口径写清楚。

信息量怎么量:熵

一九四八年,香农在论文里给出了一个衡量方法:一件事发生的概率越低,它带来的信息越多;概率越高,信息越少。把一组符号的平均信息量算出来,就是熵。它的单位是 bit,含义是「平均每个符号最少需要多少位来编码」。

公式不长:把每个符号出现的概率 p 取以二为底的对数,乘上概率,再全部加起来取负号。等概率的两个符号,每个占 1 bit;等概率的 256 个字节值,每个占 8 bit。分布越不均匀,熵越低,因为常见符号可以发短码,罕见符号发长码,平均下来就省了。

import math, collections

def entropy(data):
    n = len(data)
    counts = collections.Counter(data)
    return -sum((c / n) * math.log2(c / n) for c in counts.values())

for name, data in [
    ("ABABAB", "AB" * 50),
    ("0-255 均匀字节", bytes(range(256))),
    ("一段中文的 UTF-8 字节", "为什么文件能变小,冗余到底在哪里".encode("utf-8")),
]:
    print(f"{name}: {entropy(data):.4f} bit/byte")

在本机 Python 3.15 上实际运行,输出是:

ABABAB: 1.0000 bit/byte
0-255 均匀字节: 8.0000 bit/byte
一段中文的 UTF-8 字节: 4.6004 bit/byte

第一行说明「A 和 B 各占一半」时,每个字节平均只要 1 bit 就能表示,100 个字节的理论下限是 100 bit,也就是 12.5 字节。第三行的中文按 UTF-8 拆成字节后,熵是 4.6 bit/byte,不到 8,因为常用汉字的 UTF-8 前缀重复很多。

要小心一个误读:上面算的是「单个字节的出现频率」,它只是无损压缩下限的一个粗糙估计。真正压缩文本时,压缩器还会利用上下文,比如「re」后面大概率跟「quest」,这种规律不在单字节频率里。所以实际压缩结果可以比这个估计更小,也可能因为格式开销比它更大。熵告诉你「不可能无限压」,不告诉你「一定能压到多少」。

熵是平均信息量,不是文件大小的保证。小文件带头部开销,压缩后完全可能比原文件大;分布极不均匀的数据,还要看压缩器能不能真的把长码短码分配好。

冗余的三种形态

压缩器不是靠猜,它靠数据里真实存在的冗余。把冗余分开看,会更容易判断一段数据「有没有救」。

重复冗余:同样的字节或结构反复出现,比如日志里每行都有的字段名、HTML 里成对的标签、连续相同的像素
分布冗余:某些符号出现得特别频繁,比如英文里的 e、中文里的「的」、照片里大片的天空蓝,等长编码会浪费
结构冗余:后面的内容能从前面的内容推出来,比如相邻像素通常接近、连续帧通常相似、文件头字段的顺序固定

三种冗余对应三类手段。重复冗余交给字典类算法,把出现过的片段记下来,下次直接引用,LZ 系列就是干这个的。分布冗余交给变长编码,常见符号发短码,哈夫曼编码和算术编码属于这一类。结构冗余交给预测,用前面的数据猜后面的数据,只编码猜错的部分,视频的帧间预测、PNG 的行滤波都是这个思路。

实际的压缩工具通常是组合拳。gzip 先用 LZ77 找重复片段,再对结果做哈夫曼编码;zstd 用更长的窗口和更复杂的匹配策略;FLAC 先做线性预测,再对残差编码。你看到的「一个算法」,内部往往是两三层。

一个通用压缩器的内部顺序
读入原始字节
找重复片段
统计符号频率
分配长短码
写出压缩流

这个顺序也解释了为什么「压缩级别」影响的不只是压缩比。级别越高,压缩器愿意花更多时间在更大的窗口里找更长的匹配,甚至尝试多轮统计。收益会越来越小,因为容易找的重复在前面几轮就用掉了,后面只剩零碎的匹配。

一次实测:日志 8:1,随机字节 1:1

只看公式容易抽象。下面这段脚本生成两份大小相同的数据:一份是格式固定、字段重复的访问日志,一份是等长的随机字节。两份都用 Python 标准库的 gzip 最高级别压缩,记录原始大小、压缩后大小和字节熵。

import math, collections, gzip, random

def entropy(data):
    n = len(data)
    counts = collections.Counter(data)
    return -sum((c / n) * math.log2(c / n) for c in counts.values())

random.seed(7)
paths = ["/api/order", "/api/user", "/api/cart", "/api/search", "/static/app.js"]
lines = []
for i in range(12000):
    rid = "%08x" % random.getrandbits(32)
    p = random.choice(paths)
    st = random.choice([200, 200, 200, 200, 301, 404, 500])
    cost = random.randint(1, 300)
    lines.append(
        f"2026-11-06 10:{i//600%60:02d}:{i%60:02d} INFO request_id={rid} "
        f"method=GET path={p} status={st} cost={cost}ms"
    )

log = ("\n".join(lines) + "\n").encode()
raw = len(log)
gz = len(gzip.compress(log, 9))
print(f"log: raw={raw} gzip={gz} ratio={raw/gz:.2f}:1 entropy={entropy(log):.4f}")

random_bytes = bytes(random.getrandbits(8) for _ in range(raw))
gz2 = len(gzip.compress(random_bytes, 9))
print(f"random: raw={len(random_bytes)} gzip={gz2} "
      f"ratio={len(random_bytes)/gz2:.4f}:1 entropy={entropy(random_bytes):.4f}")

本机实际输出:

log: raw=1130889 gzip=139304 ratio=8.12:1 entropy=4.9844
random: raw=1130889 gzip=1131252 ratio=0.9997:1 entropy=7.9998

日志压到八分之一,随机字节不但没小,还多了三百多字节。多出来的部分主要是 gzip 的文件头、数据块头和尾部校验,加起来几百字节。这正好对应前面说的「小文件或高熵数据,压缩后可能变大」。

日志的字节熵只有 4.98 bit/byte,低于 8,说明字节分布本身就不均匀;但真正让压缩比到 8 倍的,是 LZ 匹配到大量重复的整行结构和字段名,而不只是单字节频率。随机字节的熵是 7.9998,几乎顶到 8,说明每个字节值出现的概率几乎一样,没有分布冗余可抓,压缩器只能原样抄一遍。

这也给了一个实用的判断方法:拿到一份数据,先看它是不是已经压缩过、是不是加密过、是不是随机生成。如果是,别再指望通用压缩。反过来,日志、CSV、JSON、未压缩的 WAV、位图 BMP,通常都有明显收益。

边界与代价:压缩比不是唯一指标

压缩从来不是免费的。真正落地时,至少要同时看四个指标:压缩后大小、压缩耗时、解压耗时、以及能不能随机访问。

代价具体表现什么时候会咬人
CPU 时间最高级别可能比最低级别慢几倍,收益却只有几个百分点高并发接口在线压缩响应体、日志实时压缩
内存窗口越大,压缩器要记住的历史数据越多;解压也要按窗口缓存在容器里跑多实例,内存配额很紧
随机访问流式压缩的后面依赖前面,不能直接跳到中间解码视频拖动进度条、日志按行号取、数据库按块读
格式开销每个文件、每个数据块都有头和校验,小文件尤其明显大量几 KB 的小文件逐个压缩、逐条消息压缩

最常被忽略的是随机访问。gzip 是流式的,想读文件最后一段,理论上得从头解压。有人给日志文件加了 gzip,然后写了个「按偏移读取」的工具,结果每次查看都要解压全量,文件一大就卡住。需要随机访问时,要么选支持独立块的格式,要么在压缩时额外建索引,要么干脆不压这一层。

第二个坑是重复压缩。已经用 JPEG、MP3、MP4、zip 压过的文件,再套一层 gzip 通常只省下封装开销。有些团队把用户上传的图片统一再 gzip 一遍,CPU 花了,体积没降,还多了一层解压步骤。判断方法很简单:随机抽几个文件压一下,看压缩比是否接近 1:1。

解压不可信来源的压缩包时,必须先限制输出总大小和嵌套层数。压缩炸弹可以把几百 KB 的包解出几十 GB,磁盘和内存会被瞬间吃满。不要用「压缩包多大」来判断解压后有多大。

第三笔账是延迟。在线服务里,压缩一个 5MB 的 JSON 响应可能占用几十毫秒 CPU,QPS 一高就成了瓶颈;而静态资源完全可以在构建时预压缩,运行时只发文件。同样是压缩,放在构建期还是请求期,成本差一个数量级。

还有一个现实约束:解压必须比不压缩直接读更快,否则省下的带宽会被 CPU 吃掉。判断标准是端到端时间,包括压缩、传输、解压三段的合计,而不是单看压缩后的体积。

还有一个容易忽略的边界:压缩会改变字节,但不会改变语义。压缩包里的文件修改时间、权限、路径分隔符在不同系统上可能表现不同;跨平台分发时,压缩格式的选择不只是压缩比问题,还要看对方能不能解、文件名编码是否正确。

压缩前的预处理:省的是另一笔账

很多人一发现文件大,第一反应是换更强的压缩算法。实际项目里,改数据本身的结构往往更有效,但它省下的账和压缩不是同一笔。

拿订单列表接口举例。原始 JSON 用 order_id、created_at、customer_id 这样的完整键名,每条记录都重复一遍。如果把键名缩短成 id、t、c,原始体积会明显下降。下面用两千条记录实测,两组数据都用最高级别 gzip 压缩:

long keys: raw=252534 gzip=23746
short keys: raw=170534 gzip=23081

原始体积从 252,534 字节降到 170,534 字节,少了约三成;但压缩后只从 23,746 字节降到 23,081 字节,差 2.8%。原因是 gzip 的 LZ 匹配早就把这些重复键名折叠掉了,换短键名并没有给它新的规律。所以「短键名」真正帮到的是不压缩传输的场景、解压后的内存占用和前端解析成本,而不是压缩比。

另一类预处理确实能提升压缩率:把同类数据排在一起。时间戳做差分,只存相邻两条的间隔;传感器读数做增量编码,只存变化量;把行式记录改成列式,让相同类型的值连续存放。这些做法让数值的分布更集中、重复更明显,压缩器才有东西可抓。代价是格式变复杂,读写两端都要按新结构处理,不能再当普通 JSON 用。

结论很朴素:先量一遍再改。分别记录「原始大小、压缩后大小、压缩耗时、解压后内存」,看清楚收益落在哪一栏。不要因为换了个算法名字,就假设它一定更快或更小。

当天能自己验证的五个练习

  1. 用上面的 entropy() 函数,分别计算一段中文、一段英文、一段随机字节的熵,记录三个数值并解释差异。
  2. 生成一兆字节的重复日志和一兆字节的随机字节,各用 gzip.compress(data, 9) 压一次,记录原始大小、压缩后大小和耗时。
  3. 找一张 JPEG 和一个 MP3,分别用 zip 或 gzip 再压一遍,看压缩比是不是接近 1:1,并解释原因。
  4. 对同一个文本文件分别用 gzip 的级别 1 和级别 9 压缩,记录大小差和耗时差,算一下每省 1% 体积要多花多少时间。
  5. 写一个 20 字节的小文件,压缩后对比大小,确认头部开销会让它变大,再换成一个 20KB 的文件重复实验。

小结

三句话收尾:压缩在利用数据里的重复、分布不均和可预测性;熵给出无损压缩的理论下限,接近随机的数据压不动;压缩比只是四个指标之一,CPU、内存和随机访问同样要算进账。

下一篇讲无损与有损的分界线。同样是「压」,PNG 和 JPEG 对同一个画面的处理完全不同,一个必须精确还原每个像素,一个敢把颜色细节抹平。搞清楚它们各自丢了什么,才能判断一张图该存成什么格式、转码几次之后还能不能救。