版权与内容来源声明
本文为原创整理。文中涉及官方文档、开源仓库、论文与公开报道的内容,均在附表 A 中标注来源;引用官方原文保持原样,不作改写。文中命令、版本号与界面截图以本文成文时的实测/核验结果为准,标注「待验证」的部分请以你本地环境实际输出为判断依据。本文不推荐任何不合规的软件获取方式,也不对任何收益结果作承诺。转载请注明出处。
先看内容类型,再谈压缩率:照片和图表的最优格式正好相反
格式不该按「谁的压缩率高」排序,该按「这张图有多少种颜色」分:同一张 1536×1024 的图,照片类存 JPEG 是 365.5K、存 PNG 是 3442.4K;图表类存 PNG 是 6.3K、存 JPEG 是 13.6K。两种图的最优解,恰好是对方的次优解。
这条结论落到上传口上,就是两种同时发生的失败。接口超时卡在 5 秒,用户传手机拍的照片一路挂到超时;同一个人接着传一张图表截图,原文件才十几 KB,干干净净过去了。后端落盘前统一转 PNG,照片那一类单张从三百多 KB 涨到三兆多,超时从「偶发」变成常态;把规则反着改成统一转 JPEG,图表那类又在纯色区域糊出一层灰雾。无论选哪一边,都有一半的图变差——问题不在编码器,在于把内容类型这个变量从账本里删掉了。
一个上传口,两个方向的失败
三张同尺寸的图并排放,体积差得不像一个数量级:
| 内容类型 | JPEG q85 | PNG | WEBP q85 | 谁最小 |
|---|---|---|---|---|
| 照片类 | 365.5K | 3442.4K | 458.4K | JPEG |
| 图表类 | 13.6K | 6.3K | 3.3K | WEBP |
| 文档截图 | 24.4K | 1409.5K | 5.7K | WEBP |
照片类的两种编码差 9.4 倍——3442.4K ÷ 365.5K,这就是标题里那九倍的来源:同一张图、同一个尺寸,只换了编码器。上传口上加一句「统一转 PNG」,每张照片的存储和带宽就按这个倍数记账。
图表类反过来:PNG 6.3K,JPEG 13.6K。JPEG 按 8×8 块做变换、把高频量化掉,平坦色块上被量化掉的正是「什么都没有」,重建回来就带一层块边界起伏;PNG 走无损,平坦区一个字节都不多花。文档截图更极端,1409.5K 对 5.7K——底色接近纯白,只有极浅渐变和一点噪声,噪声让 PNG 落不下来。
还有一个容易漏的格子:照片类的 WEBP 是 458.4K,比 JPEG 的 365.5K 大。WEBP 不是无条件更小,带颗粒噪声时会输给 q85 的 JPEG。
三张同尺寸的图,颜色数差了五个数量级以上
体积差得这么离谱,是因为信息量本来就差得离谱。把三张图的颜色数数出来:图表类只有 3 种颜色,其中 240, 240, 240 这一种就占了 1278976 个像素;照片类有 1118728 种不同颜色。
同一块画布,一边是三个值、一边是一百多万个值。无损编码的反应是逐像素照抄,有损编码是把相近的值合并。所以格式选择的本质是:相近的颜色能不能被合并掉而不被发现。图表类合并一处就出色带,照片类合并一片也看不出来——照片本身就带噪声。
下面这段脚本把三种内容各存三遍,顺手打出颜色数。
🧪 实测环境:macOS(Darwin 27.0.0,Apple Silicon)、Python 3.13.12、Pillow 12.3.0、numpy 2.5.3;测试图由固定随机种子生成,两组脚本各自可复跑
import io
import numpy as np
from PIL import Image
W, H = 1536, 1024
rng = np.random.default_rng(20261120)
yy, xx = np.mgrid[0:H, 0:W]
smooth = np.stack([(xx / W * 200 + 30), (yy / H * 180 + 40), ((xx + yy) / (W + H) * 160 + 60)], axis=-1)
photo = Image.fromarray(np.clip(smooth + rng.normal(0, 12, smooth.shape), 0, 255).astype("uint8"), "RGB")
flat = np.zeros((H, W, 3), dtype="uint8")
flat[:, :] = (240, 240, 240)
flat[H // 3 : 2 * H // 3, W // 4 : 3 * W // 4] = (30, 90, 200)
flat[100:140, 100:900] = (20, 20, 20)
chart = Image.fromarray(flat, "RGB")
screenshot = Image.fromarray(
np.clip(smooth * 0.15 + 235 + rng.normal(0, 2, smooth.shape), 0, 255).astype("uint8"), "RGB"
)
def size_of(img, fmt, **kw):
buf = io.BytesIO()
img.save(buf, fmt, **kw)
return len(buf.getvalue())
print("=== 同样是 1536x1024,三种内容 × 三种格式(单位 KB)===")
print(f"{'内容类型':<12}{'JPEG q85':>10}{'PNG':>10}{'WEBP q85':>10}{'谁最小':>8}")
cases = [("照片类", photo), ("图表类", chart), ("文档截图", screenshot)]
for label, img in cases:
j = size_of(img, "JPEG", quality=85, optimize=True)
p = size_of(img, "PNG", optimize=True)
w = size_of(img, "WEBP", quality=85, method=6)
vals = {"JPEG": j, "PNG": p, "WEBP": w}
best = min(vals, key=vals.get)
print(f"{label:<12}{j / 1024:>9.1f}K{p / 1024:>9.1f}K{w / 1024:>9.1f}K{best:>8}")
print()
print("=== 图表类那三块纯色有多少种颜色 ===")
colors = chart.getcolors(maxcolors=1 << 24)
print(f"不同颜色数 {len(colors)},占比最大的前三种 {sorted(colors, reverse=True)[:3]}")
print()
print("=== 照片类有多少种颜色 ===")
print(f"不同颜色数 {len(photo.getcolors(maxcolors=1 << 24))}")
=== 同样是 1536x1024,三种内容 × 三种格式(单位 KB)===
内容类型 JPEG q85 PNG WEBP q85 谁最小
照片类 365.5K 3442.4K 458.4K JPEG
图表类 13.6K 6.3K 3.3K WEBP
文档截图 24.4K 1409.5K 5.7K WEBP
=== 图表类那三块纯色有多少种颜色 ===
不同颜色数 3,占比最大的前三种 [(1278976, (240, 240, 240)), (261888, (30, 90, 200)), (32000, (20, 20, 20))]
=== 照片类有多少种颜色 ===
不同颜色数 1118728
输出里那个 3 和 1118728 是同一次运行打出来的,三张图像素总数一样,差别只在「有多少个不同的值」——这才是格式选择的自变量。
判断只用看一个数:颜色种类数
按颜色数分三段,判断就定死了:
- 几千种以内(图表、纯色 UI、图标):走 PNG 或 WEBP。这类图 JPEG 一定更大,平坦区还会出现块边界。
- 百万级(照片、实拍、带噪声的图):走 JPEG 或 WEBP。PNG 在这里是灾难,3442.4K 就是它的下限——不是参数没调好,是格式决定了它必须逐像素存。
- 中间带(浅底文档截图、渐变色卡、带抗锯齿的列表页):先测再定。这次文档截图是 WEBP 5.7K、JPEG 24.4K、PNG 1409.5K,跟「截图应该用 PNG」的常识正好错开。
还有一个前提:颜色数是在完全相同的尺寸下比的。一旦允许改尺寸,比较里就混进了第二个变量——下一章单独算尺寸这笔账。
宽度比质量更值钱:三档宽度乘三档质量的账
先砍宽度,再砍质量:从 810.0K 那一格起算,宽度降一档后体积剩 33.8%,质量降一档后剩 45.1%——同样是降一档,宽度切掉的字节更多,砍掉的多半是显示时用不上的像素。
这条顺序不是审美偏好。一张 1536 宽的照片进页面,最终显示宽度常常只有几百像素,多出来的像素被浏览器丢掉,字节却照样从接口走过去、照样占存储、照样算进超时;质量不同,它伤的是整张图的观感,降过头是全局性的。
九格里最贵的一格,是没被砍过的原尺寸
同一张 1536×1024 的源图,三档宽度乘三档质量:
| 宽度 | 质量 95 | 质量 85 | 质量 75 |
|---|---|---|---|
| 1536 | 810.0K | 365.5K | 212.3K |
| 1024 | 273.9K | 103.0K | 59.6K |
| 768 | 124.8K | 44.3K | 25.6K |
最贵的一格是 810.0K:原尺寸、最高质量,也就是绝大多数「直接另存」的默认结果。最便宜的一格是 25.6K,两端差三十一倍。
体积下降的斜率比像素数更快。1536 砍到 1024,像素数剩九分之四,体积却剩 33.8%;砍到 768,像素数剩四分之一,体积只剩 5.5%。原因是缩图先把高频噪声平均掉了,而噪声恰恰是 JPEG 最费字节的部分——所以「先缩后压」永远比「先压后缩」省。
这九个数来自下面这段脚本。
🧪 实测环境:macOS(Darwin 27.0.0,Apple Silicon)、Python 3.13.12、Pillow 12.3.0、numpy 2.5.3;测试图由固定随机种子生成,两组脚本各自可复跑
import base64
import io
import os
import numpy as np
from PIL import Image, ImageChops
OUT = "/tmp/img_budget"
os.makedirs(OUT, exist_ok=True)
W, H = 1536, 1024
rng = np.random.default_rng(20261120)
yy, xx = np.mgrid[0:H, 0:W]
base = np.stack(
[
(xx / W * 200 + 30),
(yy / H * 180 + 40),
((xx + yy) / (W + H) * 160 + 60),
],
axis=-1,
)
noise = rng.normal(0, 12, base.shape)
arr = np.clip(base + noise, 0, 255).astype("uint8")
src = Image.fromarray(arr, "RGB")
print(f"源图 {src.size[0]}x{src.size[1]},模式 {src.mode}")
def jpeg_bytes(img, q):
buf = io.BytesIO()
img.save(buf, "JPEG", quality=q, optimize=True)
return buf.getvalue()
print()
print("=== 同一张图,三种宽度 × 三档质量(JPEG,单位 KB)===")
print(f"{'宽度':>6} {'质量95':>9} {'质量85':>9} {'质量75':>9}")
rows = []
for width in (1536, 1024, 768):
h = round(H * width / W)
img = src.resize((width, h), Image.LANCZOS)
sizes = [len(jpeg_bytes(img, q)) for q in (95, 85, 75)]
rows.append((width, sizes))
print(f"{width:>6} {sizes[0] / 1024:>8.1f}K {sizes[1] / 1024:>8.1f}K {sizes[2] / 1024:>8.1f}K")
full = rows[0][1][0]
print()
print("=== 相对原尺寸 + 质量 95 的比例 ===")
for width, sizes in rows:
for q, b in zip((95, 85, 75), sizes):
print(f"宽 {width:<5} 质量 {q} 体积 {b / 1024:>7.1f}K 是基准的 {b / full * 100:>5.1f}%")
print()
print("=== 编码格式与 base64 后的传输体积 ===")
small = src.resize((768, 512), Image.LANCZOS)
jpg = jpeg_bytes(small, 85)
buf = io.BytesIO()
small.save(buf, "PNG", optimize=True)
png = buf.getvalue()
buf = io.BytesIO()
small.save(buf, "WEBP", quality=85, method=6)
webp = buf.getvalue()
for label, data in (("JPEG q85", jpg), ("PNG", png), ("WEBP q85", webp)):
b64 = len(base64.b64encode(data))
print(f"{label:<10} 原始 {len(data) / 1024:>7.1f}K base64 后 {b64 / 1024:>7.1f}K 膨胀 {b64 / len(data) * 100:.1f}%")
print()
print("=== 缩到 768 宽再放大回去,和原图差多少 ===")
back = small.resize((W, H), Image.LANCZOS)
diff = ImageChops.difference(src, back)
d = np.asarray(diff, dtype=np.int16)
print(f"平均绝对误差 {d.mean():.2f},最大误差 {d.max()},超过 16 的像素占 {100 * (d > 16).mean():.1f}%")
print()
print("=== 带透明通道的图直接存 JPEG ===")
rgba = src.convert("RGBA")
px = rgba.load()
for y in range(0, 200):
for x in range(0, 200):
px[x, y] = (255, 0, 0, 0)
try:
data = jpeg_bytes(rgba, 85)
back_rgb = Image.open(io.BytesIO(data)).convert("RGB")
print(f"存盘成功,体积 {len(data) / 1024:.1f}K")
print(f"原图该点 RGBA={rgba.getpixel((10, 10))},读回 RGB={back_rgb.getpixel((10, 10))}")
except Exception as e:
print(f"{type(e).__name__}: {e}")
white = Image.new("RGBA", rgba.size, (255, 255, 255, 255))
flat = Image.alpha_composite(white, rgba).convert("RGB")
data = jpeg_bytes(flat, 85)
print(f"先合成到白底再存 JPEG:体积 {len(data) / 1024:.1f}K,该点 RGB={flat.getpixel((10, 10))}")
naive = rgba.convert("RGB")
print(f"直接掉 alpha 通道:该点 RGB={naive.getpixel((10, 10))}")
源图 1536x1024,模式 RGB
=== 同一张图,三种宽度 × 三档质量(JPEG,单位 KB)===
宽度 质量95 质量85 质量75
1536 810.0K 365.5K 212.3K
1024 273.9K 103.0K 59.6K
768 124.8K 44.3K 25.6K
=== 相对原尺寸 + 质量 95 的比例 ===
宽 1536 质量 95 体积 810.0K 是基准的 100.0%
宽 1536 质量 85 体积 365.5K 是基准的 45.1%
宽 1536 质量 75 体积 212.3K 是基准的 26.2%
宽 1024 质量 95 体积 273.9K 是基准的 33.8%
宽 1024 质量 85 体积 103.0K 是基准的 12.7%
宽 1024 质量 75 体积 59.6K 是基准的 7.4%
宽 768 质量 95 体积 124.8K 是基准的 15.4%
宽 768 质量 85 体积 44.3K 是基准的 5.5%
宽 768 质量 75 体积 25.6K 是基准的 3.2%
=== 编码格式与 base64 后的传输体积 ===
JPEG q85 原始 44.3K base64 后 59.0K 膨胀 133.3%
PNG 原始 677.4K base64 后 903.2K 膨胀 133.3%
WEBP q85 原始 33.2K base64 后 44.2K 膨胀 133.3%
=== 缩到 768 宽再放大回去,和原图差多少 ===
平均绝对误差 8.42,最大误差 56,超过 16 的像素占 11.8%
=== 带透明通道的图直接存 JPEG ===
OSError: cannot write mode RGBA as JPEG
先合成到白底再存 JPEG:体积 357.3K,该点 RGB=(255, 255, 255)
直接掉 alpha 通道:该点 RGB=(255, 0, 0)
输出分五段,后面三章都从这里取数。
质量从 95 降到 85,是整张表里最便宜的一刀
按基准比例看:95 降到 85,体积剩 45.1%,画质损失多数场景看不出来,这一步不用犹豫。85 降到 75,从 45.1% 掉到 26.2%,省下的不到基准的两成,肤色过渡、天空渐变这类平缓区域开始出现轻微色带。75 往下就别去了。Pillow 文档对 quality 写得直接:取值 0 到 95,默认 75,并明确「Values above 95 should be avoided」——95 以上是拿体积换几乎看不见的差异,100 还会关掉 JPEG 压缩算法的部分环节,文件变大而画质几乎不涨。
宽度那一刀的落点更值得抠:1536 的 q85 是 365.5K,1024 的 q85 是 103.0K,768 的 q85 是 44.3K。每降一档,体积掉到前一档的三四成,而丢掉的像素在页面上本来就没有落点。
预算倒推:先钉宽度,再钉质量下限
落地时真正要改的就是这几个参数:
def jpeg_bytes(img, q):
buf = io.BytesIO()
img.save(buf, "JPEG", quality=q, optimize=True)
return buf.getvalue()
optimize=True 也值得留着。Pillow 对 JPEG 的 optimize 写的是「indicates that the encoder should make an extra pass over the image in order to select optimal encoder settings」,也就是多扫一遍挑参数;对 PNG 的 optimize 写的是「instructs the PNG writer to make the output file as small as possible」。两者都是拿一点 CPU 换体积,在上传链路上几乎总是划算的。
倒推的顺序反过来:
- 先量显示宽度。缩略图、正文配图、详情大图差得远;目标宽度定在显示宽度的两倍以内,多出来的直接
resize掉。 - 再在九格表里挑一格。预算线定在 103.0K 就取 1024 宽 q85,定在 44.3K 就取 768 宽 q85。别先定质量再试宽度,那样每格都偏贵。
- 95 只留给要二次处理的图。原图要进裁剪、合成、识别流程才用 95,直接展示的一律 85 起。75 是下限,不是默认值——默认值省事,但它不是按你的显示宽度算出来的。
这份资料是什么:一张把「内容类型 × 格式 × 宽度 × 质量 × 传输膨胀」并在一起的预算表,三类内容各自该落在哪一格,附两个脚本的复跑步骤。和这一章九格数据配合看,先钉宽度再钉质量。放在资料包里,扫码即可获取:
分辨率砍掉一半,像素差在哪
缩到 768 宽再放大回原尺寸,平均绝对误差 8.42——这个数字好看得没什么用,真正决定能不能接受的是另外两个:最大误差 56,以及偏差超过 16 的像素占 11.8%。
判断依据要摆清楚:8.42 是在 255 级色阶上的均值,占满量程三个多百分点,单看它,任何图都像「几乎没差」。但均值会把大片平坦区的零误差和小片高频区的大误差混在一起,混完既看不出哪里崩了,也看不出崩了多少——这笔账得拆成三行看。
8.42 是被平均出来的
同一张图里,渐变背景占了绝大多数面积,缩图对这种区域几乎是完美重建——低频信号缩小再放大,误差接近零。这些像素把均值往下拉。
最大误差 56 说明至少有一个像素被改了超过两成的量程。它可能是噪声尖点,也可能是某条细线的边缘:尖点改了就改了,细线边缘一改就是「断」和「虚」。均值回答「整体像不像」,最大值回答「最坏能坏到什么程度」,缺的那一问是「坏的地方有多少、在哪里」。
11.8% 的像素超过 16,这个比例落在哪才关键
阈值 16 是脚本里选的一条线,不是行业标准——把它当成「肉眼在平滑区域能分辨的灰度差」的一个保守刻度来用。按这条线数,超过的像素占 11.8%,每八九个像素一个。
这 11.8% 的分布比数值本身重要:
- 散在噪声区、渐变区:可以接受。照片本身就在抖,多抖一级没人看得出来。
- 集中在文字边缘、表格线、细笔画:不可以接受。这类结构只有一两个像素宽,误差 16 意味着笔画被削掉一半,放大是发虚,缩小是断字。
- 集中在高对比边界(深色文字压浅底):最糟,误差会被视觉放大,块状和振铃都从这里出来。
所以「11.8% 的像素有偏差」本身不构成结论,得补上「偏差在哪」。本文这张测试图是纯合成的渐变加噪声,11.8% 基本散在噪声区,属于可接受那一侧;换成一张票据扫描件,同样的 11.8% 会全部压在字符笔画上,结论就翻过来。
这几类图不要指望靠缩图解决
- 文字截图、票据、表单:像素边界就是信息边界,缩一半等于把笔画砍半。要么保持原宽,要么换无损格式。
- 带细线的图表:坐标轴、网格线、1 像素描边,缩图后会被平均成浅灰。图表该省的是格式(PNG 或 WEBP),不是分辨率。
- 已经压过一次的图:二次编码会在第一次的块边界上再叠一层,误差不是相加而是放大。
- 要 OCR 或做识别的图:不用看误差指标,直接把宽度锁在原尺寸——缩图省下的字节会在识别率上还回来。
反过来,列表缩略图、点开才看大图的场景,768 宽完全够——44.3K 换掉的不是画质,是一整条超时路径。
上传链路上还有一次 33% 的膨胀
图片体积算完还要再乘一次系数:base64 之后是原来的 133.3%,脚本里 JPEG、PNG、WEBP 三种编码打出来都是这个数——膨胀只跟封装方式有关,跟图片内容无关。
原因在编码规则本身。RFC 4648 §4 写的是「The encoding process represents 24-bit groups of input bits as output strings of 4 encoded characters」:每 3 个字节换成 4 个字符,体积比就是 4/3。这是这种编码的定义,不是实现细节,所以「换个图片格式能不能绕开这 33%」根本不成立——换格式改的是编码前那一半。
44.3K 变 59.0K:这笔账要在选格式时就记上
同一张 768 宽的图,两种编码各自走一遍:
| 编码 | 原始体积 | base64 后 | 膨胀 |
|---|---|---|---|
| JPEG q85 | 44.3K | 59.0K | 133.3% |
| PNG | 677.4K | 903.2K | 133.3% |
两行的膨胀一模一样,绝对增量差得远——33% 是乘法,不是加法,图越大这层封装费越贵。所以「PNG 反正无损、干脆都存 PNG」这个决定,在传输层要按 677.4K 变 903.2K 记账,不是按 677.4K。
记账口径要跟着网关走:网关数的是请求体大小,不是文件大小。目标定 44.3K 的图,进 body 就是 59.0K;字段额度按整百 KB 给的时候,图片本身只能占四分之三,剩下全是编码费——预算表少写这一行,线上就会以「莫名其妙超了」的形式出现。
真要省这 33%,只有换传输方式:二进制直传、预签名 URL 让客户端直传对象存储、图放 CDN 只传地址。这三条都改协议,不改编码。
透明通道掉下去,同一个像素剩两个值
带 alpha 的图是另一种开销,不体现在体积上,体现在颜色上。对 RGBA 图直接存 JPEG,抛出来的是 OSError: cannot write mode RGBA as JPEG——JPEG 没有 alpha 通道,编码器当场拒绝。
绕过去有两条路,同一个点给出两个值:先合成到白底再存 JPEG,体积 357.3K,该点 RGB 是 (255, 255, 255);直接掉 alpha 通道,该点 RGB 是 (255, 0, 0)。
源图那个点原本是 (255, 0, 0, 0)——全透明的红。人眼看到的应该是「什么都没有」,掉通道之后成了实心红块,整片透明区变红底。这类问题最难查:PNG 看着没事,转 JPEG 出现大片色块,第一反应是压缩参数,其实是 alpha 被丢了。
正确的做法是先合成,再转模式:用页面背景色建不透明底图,把 RGBA 图 alpha_composite 上去,再 convert("RGB")。页面底色不是白,就用页面底色合成,透明区才会真正「消失」。
357.3K 也值得留意:它是 1536×1024 全图 q85 的结果,和照片类那格 365.5K 差不多。合成白底不会让体积失控,失控的是「先掉通道再压」——红块是高频硬边,压不动。
三步把预算钉死,然后停手
落地就三步,每步钉一个数:
- 按颜色数分格式。几千种以内走 PNG 或 WEBP,百万级走 JPEG 或 WEBP,中间带实测。
- 按显示宽度定宽度。目标宽度取显示宽度的两倍以内,超过就
resize;文字、票据不缩。 - 按预算线定质量。85 起步,75 是下限,95 只给要二次处理的图;
optimize=True一直开着。
最后按 133.3% 报预算。三步做完就停手——继续往下抠(换编码器、多档 quality 扫描、自适应量化)的收益通常小于花掉的时间,而每加一个变量,复现和回归的成本都要重算一遍。
停手信号很明确:一张图已经落到 44.3K 这个量级(768 宽、q85),再压只能靠牺牲可读性;一张图是百万级颜色、又没有显示宽度上的冗余,365.5K 附近就是它的合理位置,剩下的空间该去优化链路(直传、CDN、异步),不该继续在编码器上找。
这份资料是什么:一份「上传链路体积预算清单」,从颜色数分类、宽度上限、质量下限,到 base64 记账和 alpha 合成,每步一条判断线和一条停手条件。和这一章两笔隐性开销配合看。放在资料包里,扫码即可获取:
附表 A:本文引用事实与出处对照表
| 事实(可核对的原文或数值) | 出处 | 本文位置 |
|---|---|---|
“The image quality, on a scale from 0 (worst) to 95 (best), or the string keep. The default is 75. Values above 95 should be avoided; 100 disables portions of the JPEG compression algorithm, and results in large files with hardly any gain in image quality.” | Pillow 文档《Image file formats》JPEG 保存选项 quality(https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html) | 第 2 章第 2 小节 |
| “If present and true, instructs the PNG writer to make the output file as small as possible.” | Pillow 文档《Image file formats》PNG 保存选项 optimize(同上) | 第 2 章第 3 小节 |
| “If present and true, indicates that the encoder should make an extra pass over the image in order to select optimal encoder settings.” | Pillow 文档《Image file formats》JPEG 保存选项 optimize(同上) | 第 2 章第 3 小节 |
| “The encoding process represents 24-bit groups of input bits as output strings of 4 encoded characters.” | RFC 4648 §4(https://www.rfc-editor.org/rfc/rfc4648.html) | 第 4 章第 1 小节 |
work/exp1120/s4b_format.py 与 s4b.out 一次运行的原始输出:照片类 365.5K / 3442.4K / 458.4K,图表类 13.6K / 6.3K / 3.3K,文档截图 24.4K / 1409.5K / 5.7K;图表类颜色数 3,照片类颜色数 1118728 | 本机运行(macOS Darwin 27.0.0 / Python 3.13.12 / Pillow 12.3.0 / numpy 2.5.3,固定种子) | 第 1 章表 1、代码块 |
work/exp1120/s4_img.py 与 s4.out 一次运行的原始输出:九格体积 810.0K 至 25.6K、base64 膨胀 133.3%、误差 8.42 / 56 / 11.8%、白底合成 357.3K 与 (255, 255, 255) / (255, 0, 0) | 同上 | 第 2 章表 2、第 3 章、第 4 章表 3 |
九倍这一比值由 s4b.out 两格相除得出:3442.4K ÷ 365.5K ≈ 9.4 | 由本文实测输出换算 | 第 1 章第 1 小节 |
写在最后:这篇用到的资料
写这篇文章时,把相关的官方文档和源码又翻了一遍,顺手也整理了几份配套的东西:
- 大模型学习路线图:从零基础到能自己动手做 Agent,按阶段说明每一步该学什么、哪些可以先跳过
- 《LangChain + LangGraph + MCP 智能体开发实战》视频课:7 个模块,从私有化部署、Embedding+RAG 到 MCP+Agent 全流程
- AI 大模型知识库(在线可查):Agent Skills 从入门到落地、Claude Skills 完全指南等专题,按目录浏览即可
- 640 套 AI 大模型行业报告 + 经典 PDF 书籍:看行业落地案例和别人怎么做的时候用得上
- 大模型零基础到精通教学视频:跟着敲一遍,比只读文档快得多
资料是我自己整理的,放在下面这个码上,扫码即可获取:
添加时备注「AI」,优先通过。
资料按「先路线、再动手、最后查漏」的顺序整理好了,建议先看学习路线那一份,照着它挑一条适合自己当前基础的路径再往下看。
转载自 CSDN-专业IT技术社区
原文链接:https://blog.csdn.net/2601_96189255/article/details/171071374










