阅读范围、用时与原有实验记录
实验记录怎么读
本页原有耗时、内存、报错和环境值保留为原文记录;本轮内容审校未逐项复跑这些实验。版本、硬件、数据和测量方法都会影响结果,示例中的倍数也不是保证。需要复现时先核对依赖版本,再在同一输入下比较。
⏱ 64 分钟 | ⭐ 同一个溢出,写成数组一声不吭给你 44,写成标量会报警告 —— 你踩的坑正是因为数组不吭声
01 / 完整解释
先确认这个整数格能装多少。
🎯 一句话
本章固定宽度整数数组的加法可静默回绕;浮点转整数的 astype 向零截断,而非四舍五入。np.errstate 不能充当整数数组的通用越界检查器;部分 NumPy 整数标量运算却会受它影响,需分开看。
数组加法回绕后仍会给出类型范围内的整数。检查结果是否在范围内,无法倒推出刚才有没有回绕。
🧩 一、先把边界划清楚
同样是 255,加 1 得到 256 还是 0,要先问这些数是怎么存的。数组的数据类型(Data Type,dtype)规定了每个元素的表示方式。例如 uint8 用 8 个二进制位存一个无符号整数,能存 0 到 255。
| 说的是 | 在哪讲 | 关心什么 |
|---|---|---|
| FP16 / BF16 / FP8 怎么选、loss scaling 怎么配 | AI 基础设施 · 06 · 混合精度 | 训练该用哪个精度(工程选型) |
| INT8 量化、per-channel 还是 per-tensor | AI 基础设施 · 18 · 量化 | 模型压到多小还能用(模型压缩) |
exp 会不会炸、log(1+x) 丢几位 |
09 · log 域运算 | 浮点表示本身的数值行为 |
⭐ int16 装不下 70000 会变成什么 |
本章 | 整数的回绕、截断、类型提升 |
本章跟着一个整数走过三步:先存入数组,再参加运算,最后把结果存进目标类型。混合类型运算可能让整数进入浮点表示,所以还要检查它能否保住相邻整数的差别。
🧩 二、招牌:数组静默,标量报警告
import numpy as np
import warnings
with warnings.catch_warnings(record=True) as w: # 把警告抓下来数一数
warnings.simplefilter("always")
r = np.array([200], dtype=np.uint8) + np.uint8(100)
print("数组 [200]uint8 + uint8(100) =", r, "| 警告条数", len(w))
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
s = np.uint8(200) + np.uint8(100)
print("标量 uint8(200) + uint8(100) =", s, "| 警告条数", len(w))
for x in w:
print(" ->", x.category.__name__ + ":", x.message)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
r2 = np.array([200], np.uint8) + np.array([100], np.uint8)
r3 = np.array([2147483647], np.int32) + np.int32(1)
print("数组+数组 =", r2, "| int32 最大值 +1 =", r3, "| 警告条数", len(w))
关键信息
⭐ 这就是全章的招牌:三个式子算的是同一件事,答案都是 44,只有写成标量的那一个会告诉你出事了。
为什么是 44:uint8 只有 8 位,能表示 0–255。300 超了,于是取模——300 − 256 = 44。有符号那一侧更吓人:int32 的最大值加 1,直接从 21 亿多跳到负 21 亿多。
💀 而你在真实代码里遇到的,永远是数组那一版。你不会写 np.uint8(200) + np.uint8(100),你会写 img + delta——然后什么都没发生,只是几个像素从 250 变成了 4。
🧩 三、每种整数能装多少
import numpy as np
for t in (np.int8, np.uint8, np.int16, np.uint16,
np.int32, np.uint32, np.int64, np.uint64):
i = np.iinfo(t)
print(f"{np.dtype(t).name:<7} {i.bits:>2} bit {i.min:>21} ~ {i.max:>20}")
print("\nnp.array([1,2,3]).dtype =", np.array([1, 2, 3]).dtype)
print("np.arange(3).dtype =", np.arange(3).dtype)
print("np.zeros(3, dtype=int).dtype =", np.zeros(3, dtype=int).dtype)
print("np.array([2**40]).dtype =", np.array([2**40]).dtype)
| 整数类型 | 位宽 | 范围 |
|---|---|---|
| int8 | 8 bit | -128 ~ 127 |
| uint8 | 8 bit | 0 ~ 255 |
| int16 | 16 bit | -32768 ~ 32767 |
| uint16 | 16 bit | 0 ~ 65535 |
| int32 | 32 bit | -2147483648 ~ 2147483647 |
| uint32 | 32 bit | 0 ~ 4294967295 |
| int64 | 64 bit | -9223372036854775808 ~ 9223372036854775807 |
| uint64 | 64 bit | 0 ~ 18446744073709551615 |
这台环境上的默认 dtype
- np.array([1,2,3]).dtype = int64
- np.arange(3).dtype = int64
- np.zeros(3, dtype=int).dtype = int64
- np.array([2**40]).dtype = int64
⭐ 中间那四个数字,请记住它们的样子:127 · 255 · 32767 · 65535 · 2147483647 · 4294967295。它们是整数溢出留在数据里的指纹——见第八节。
⚠️ 默认整数 dtype 是平台相关的。上面这台机器(Windows + NumPy 2.4.6)给的是 int64;⚠️ NumPy 1.x 时代的 Windows 默认是 int32。所以「同一份代码在同事的 Linux 上没问题,在我的 Windows 上算错了」这种事,历史上真实发生过很多次。⭐ 依赖范围的地方永远显式写 dtype,别指望默认值。
02 / 完整解释
转换和运算是两条不同边界。
🧩 四、astype 是截断,不是四舍五入
import numpy as np
f = np.array([0.9999, -0.9999, 2.5, -2.5, 3.5, 1e9])
print("直接 astype ", f.astype(np.int32))
print("round 再 astype", np.round(f).astype(np.int32))
print("floor 再 astype", np.floor(f).astype(np.int32))
big = np.array([32768, 70000, -1], dtype=np.int64)
print("int64 -> int16", big.astype(np.int16))
print("int64 -> uint8", big.astype(np.uint8))
info = np.iinfo(np.int16)
print("int16 范围", info.min, "~", info.max,
"| 全部装得下吗:", bool(((big >= info.min) & (big <= info.max)).all()))
关键信息
这三行结果来自不同操作。 先区分主动舍入与直接转换,再看原值是否超出目标类型的范围。
| 现象 | 实证 | 说明 |
|---|---|---|
| 向零截断 | 0.9999 -> 0,-0.9999 -> 0 |
不是四舍五入,也不是 floor。⚠️ 负数那一侧和 floor 结果不同(-0.9999 截断是 0,floor 是 −1) |
⭐ np.round 是「银行家舍入」 |
2.5 -> 2 而 3.5 -> 4 |
五往偶数那边凑,不是永远进位。批量取整时会让「统计上的偏差」更小,但会让你对不上手算的结果 |
| 💀 越界静默回绕 | 70000 -> 4464,-1 -> 255(uint8) |
和上一节同一个机制。-1 变成 255 是最经典的那个:用无符号类型存可能为负的量,负号会变成一个巨大的正数 |
⚠️ 32768 -> -32768 这一条最值得盯着看:只超了 1,符号就翻了。如果这是个传感器读数,你的下游会看到一个「突然反向的信号」而不是「一个偏大的值」——只检查值域会漏掉它,因为它落在合法范围内。
上表的越界回绕来自整数数组转成更窄的整数类型。浮点转整数要先按任务决定如何取整,再检查结果是否有限、是否在目标整数范围内。np.isfinite 对 NaN(非数值)和正负无穷 Inf 返回假,而范围要另外核对。
🧩 五、类型提升:NEP 50 之后的规则
给同一个 int8 数组加 1,用 Python 的 1 和 NumPy 的 np.int64(1),两次都能得到相同的值,结果类型却可能不同。类型提升(Type Promotion)指 NumPy 根据操作数的类型决定运算所用类型的过程。下面的 Python 标量规则从 NumPy 2.0 起适用。
import numpy as np
a8 = np.array([1, 2, 3], dtype=np.int8)
print("int8 数组 + Python int 1 ->", (a8 + 1).dtype)
print("int8 数组 + np.int64(1) ->", (a8 + np.int64(1)).dtype)
print("int8 数组 + int64 数组 ->", (a8 + np.array([1], np.int64)).dtype)
u8 = np.array([1], np.uint8)
i8 = np.array([1], np.int8)
print("uint8 + int8 ->", (u8 + i8).dtype)
print("uint8 + int16 ->", (u8 + np.array([1], np.int16)).dtype)
print("uint64 + int64 ->", (np.array([1], np.uint64) + np.array([1], np.int64)).dtype)
print("int64 + float32 ->", (np.array([1], np.int64) + np.array([1], np.float32)).dtype)
print("int32 + float32 ->", (np.array([1], np.int32) + np.array([1], np.float32)).dtype)
print("int8 数组 + 1000 ->", end=" ")
try:
print(a8 + 1000)
except Exception as e:
print(type(e).__name__ + ":", e)
关键信息
规则拆开是四条:
- ⭐ Python 的裸整数是「弱标量」,不会拉高数组的 dtype(NEP 50)。
int8 数组 + 1还是int8。 ⭐ 但它越界时会报OverflowError——a8 + 1000直接抛异常。这是 NumPy 2 少数几个主动帮你挡了一下的地方,请珍惜,因为下一条里它就不管了。 - 有 dtype 的标量(
np.int64(1))和数组一样参与提升。int8 + np.int64(1)→int64。 💀 所以a8 + 1和a8 + np.int64(1)结果的 dtype 不一样,而它们看起来只差一个包装。 - 有符号 + 无符号 = 找一个能同时装下两边的。
uint8(0–255)+int8(−128–127)→int16,因为没有 8 位类型能覆盖 −128–255。 ⚠️uint64 + int64找不到这样的整数类型,于是掉到float64。它能表示更大的数,但超过2**53后,不能精确表示每一个整数。 - 整数与浮点混算时,整数位宽也参与选型。
int16 + float32→float32,但int32 + float32→float64,因为float32的有效精度只有 24 个二进制位,无法逐一表示所有int32的值。int64 + float32也得到float64,仍可能舍入较大的整数。
看一次整数舍入。 三条记录的整数 ID 依次是 16777216、16777217 和 16777218。若把它们转成 float32,还能区分三条记录吗?先沿下表读中间一行,再跑代码。
| 整数 ID | 转成 float32 | 转成 float64 |
|---|---|---|
| 16777216 | 16777216 | 16777216 |
| 16777217 | 16777216 | 16777217 |
| 16777218 | 16777218 | 16777218 |
2**24 表示 2 的 24 次方,等于 16777216。从这个数开始,float32 向上的相邻可表示数间距从 1 变成 2。因为只能保留 24 个有效二进制位,这一段只能每隔 2 存一个整数。16777217 到两侧的距离都是 1,两侧同样近。默认舍入规则会选保留下来的二进制末位为 0 的那一侧,也就是 16777216。float64 有 53 个有效二进制位,在这三个数附近仍能区分间距 1,直到 2**53 才遇到同样的边界。
import numpy as np
ids = np.array([2**24, 2**24 + 1, 2**24 + 2], dtype=np.int64)
near32 = ids.astype(np.float32)
near64 = ids.astype(np.float64)
print(near32.tolist()) # [16777216.0, 16777216.0, 16777218.0]
print(near64.tolist()) # [16777216.0, 16777217.0, 16777218.0]
print(np.isfinite(near32).all()) # True
ids_at_edge = np.array([2**53, 2**53 + 1, 2**53 + 2], dtype=np.int64)
edge64 = ids_at_edge.astype(np.float64)
print(edge64.tolist())
# [9007199254740992.0, 9007199254740992.0, 9007199254740994.0]
这里两列都直接从原始整数转换。第一个 print 已经看到两个 ID 合并,但 np.isfinite(near32).all() 仍为真,因为三个结果都是有限值。再把 near32 转成 float64 只会更精确地存下舍入后的值。需要按 ID 精确匹配时,保留原始整数列。
03 / 完整解释
把错误挡在输入与计算边界。
🧩 六、💀 np.errstate 不保证捕获整数数组回绕
下一章用 np.errstate 把浮点运算的 inf 等异常变成报错。它不能通用地捕获整数数组回绕:下面的 int32 数组加法仍会回绕。要与 NumPy 整数标量运算区分:例如 with np.errstate(over="raise") 内,np.int16(32000) * np.int16(3) 会抛 FloatingPointError。
import numpy as np
try:
with np.errstate(over="raise"):
print(np.exp(np.array([800.0])))
except FloatingPointError as e:
print("浮点溢出被抓到:", e)
with np.errstate(over="raise", invalid="raise", all="raise"):
r = np.array([2147483647], np.int32) + np.int32(1)
print("整数回绕没被抓到:", r)
def add_checked(a, b):
"""先升到 int64 算,再确认结果装得回原来的 dtype"""
out = a.astype(np.int64) + np.int64(b)
info = np.iinfo(a.dtype)
if (out < info.min).any() or (out > info.max).any():
raise OverflowError(f"结果超出 {a.dtype} 的范围 {info.min}~{info.max}")
return out.astype(a.dtype)
try:
add_checked(np.array([2147483647], np.int32), 1)
except OverflowError as e:
print("自己查出来了:", e)
print("np.can_cast(int32 -> int16, 'safe') =", np.can_cast(np.int32, np.int16, "safe"))
print("np.can_cast(int16 -> int32, 'safe') =", np.can_cast(np.int16, np.int32, "safe"))
关键信息
⭐ 边界:errstate 控制 NumPy 的数值错误处理;本节整数数组加法的回绕没有被它报告,但 NumPy 的部分整数标量运算会受这些设置影响。因此不能从数组示例推断“所有整数运算都不受影响”,也不能把它当作通用整数越界检测。
⚠️ with np.errstate(all="raise") 不能保证整数数组计算没有越界。 是否报告还取决于标量或数组及具体运算;范围安全仍需单独检查。
🧩 七、整数这一侧只能自己兜
| 手段 | 怎么用 | 什么时候用 |
|---|---|---|
⭐ 先升到 int64 再算,算完检查范围 |
上面那个 add_checked |
有条件的较窄整数加法示例:a 的值、b 及精确中间和都必须能由 int64 表示,代价是一份 int64 临时内存。它不是任意整数的通用兜底;int64 最大值加 1 会先在临时结果中回绕,后续范围检查可能漏过。64 位边界应在运算前用安全的判界逻辑,或转为 Python int / object 做精确整数运算后再检查目标范围;不能假设再升到 int64 就安全。 |
np.can_cast(src, dst, "safe") |
转换前先问一句 | 写库函数、要给调用方一个明确报错时 |
np.iinfo(dtype).min / .max 自查 |
((x >= lo) & (x <= hi)).all() |
⭐ 从外部读进来的数据落库前,最值钱的一道闸 |
| 选好存储和中间类型 | 按值域和运算规模检查 dtype |
int64 能表示较宽范围的有符号整数,适合值与中间结果都落在其范围内的任务。若要写回窄类型,仍需检查目标范围。 |
假设传感器给了三次整数计数 [12000, 25000, 31000],全部存得进 int16。现在要把每次计数乘 2,再求总数。先把输入、乘法结果和最后的求和分别写下来。
| 路径 | 乘法后得到的三项 | 最终输出 |
|---|---|---|
乘完再转 int32 | 24000、−15536、−3536 | 同样的三项,存成 int32 |
乘完用 int64 求和 | 24000、−15536、−3536 | 4928 |
先转 int32,再乘,再用 int64 求和 | 24000、50000、62000 | 136000 |
int16 能存 −32768 到 32767。第一项 12000 × 2 = 24000 仍在范围内。后两项 25000 × 2 = 50000 与 31000 × 2 = 62000 各减去一轮的 2**16 = 65536,才落回范围,变成 −15536 和 −3536。用 int64 加总这些数,只会准确地算出 24000 − 15536 − 3536 = 4928。
import numpy as np
raw = np.array([12000, 25000, 31000], dtype=np.int16) # (3,)
products = raw * np.int16(2) # (3,), int16
late_cast = products.astype(np.int32)
late_sum = products.sum(dtype=np.int64)
print(late_cast.tolist(), late_cast.dtype) # [24000, -15536, -3536] int32
print(late_sum, late_sum.dtype) # 4928 int64
wide_products = raw.astype(np.int32) * np.int32(2) # (3,), int32
wide_sum = wide_products.sum(dtype=np.int64)
print(wide_products.tolist()) # [24000, 50000, 62000]
print(wide_sum, wide_sum.dtype) # 136000 int64
先升宽那条路径保住了乘法的三项,求和得到 24000 + 50000 + 62000 = 136000。累加器(Accumulator)是求和中保存中间总数的量。sum(dtype=np.int64) 在求和阶段使用 int64 累加,只有传给它的数值仍然正确,这一步才有用。
再单独测一次求和。 下一个例子有 100 个各为 30000 的 int16 计数。数学上的总和为 100 × 30000 = 3000000,均值为 3000000 ÷ 100 = 30000。试想如果用 int16 累加,哪一步先装不下?
import numpy as np
raw = np.array([12000, 25000, 31000], dtype=np.int16)
print("原始 int16 ", raw)
print("直接 *2 (int16)", raw * np.int16(2)) # 静默回绕
print("先升 int32 再乘", raw.astype(np.int32) * 2) # 正确
big = np.full(100, 30000, dtype=np.int16)
print("sum 的 dtype ", big.sum().dtype, "值", big.sum())
print("逐元素累加 int16", np.add.reduce(big, dtype=np.int16))
print("mean 的 dtype ", big.mean().dtype, "值", big.mean())
print("int16 + float32 ->", (np.array([1], np.int16) + np.array([1], np.float32)).dtype)
print("bool + bool ->", (np.array([True]) + np.array([True])).dtype,
np.array([True]) + np.array([True]))
关键信息
这个例子里,第二个 30000 加上去就达到 60000,超出 int16。显式指定 np.add.reduce(big, dtype=np.int16) 时,最终结果 3000000 − 46 × 65536 = −14656 落回了 int16 的范围。
当输入的整数位宽小于平台默认整数的位宽时,sum() 默认用更宽的整数类型累加。这份有符号 int16 输入在 64 位 NumPy 2.x 中得到 int64。整数输入的 mean() 默认使用 float64 计算并返回结果。整数和仍可能超出累加器的范围,浮点均值也可能舍入。分别核对乘法的中间值、求和的中间值和最后写回的目标类型。
最后一行加的是两个 NumPy 布尔数组,逐元素相加在这里等价于逻辑或,得到 [True]。要数一份布尔数组里有多少个 True,可以直接调用 .sum(),NumPy 会用整数计数。单独写 Python 的 True + True 得到的是 2。
🧩 八、⭐ 站里已经在诊断这个 bug,只是没讲成因
数据这一关 · 07 · 异常值是错还是真 把「某一列的值正好是 32767 / 65535 / 2147483647」列为脏数据的判别信号——那就是本章第三节那张表里的三个数。
⭐ 两章合起来才是完整的一件事:
| 那一章 | 本章 |
|---|---|
| 教你认出症状:一列数据里堆着一撮 32767 | 教你认出成因:某处一个 astype(np.int16),或者一个 int16 数组做了乘法 |
| 视角是「拿到别人的数据,怎么发现它坏了」 | 视角是「我自己的代码,正在制造这种数据」 |
💀 最难查的一种:回绕之后的值仍然落在合法范围内。32768 -> -32768 不会被「值域检查」拦下来,因为 −32768 是一个完全合法的 int16。你只能靠「它和前后样本的关系不对劲」发现它,而那已经是异常检测的活了。
04 / 完整解释
让 dtype 成为显式判断。
🔗 这一章连到哪里
| 相关的地方 | 为什么 |
|---|---|
| 09 · log 域运算 | ⭐ 同一个 np.errstate,在那边真的管用。那一章讲怎么用它把静默的 inf/nan 变成异常——去看一眼「有信号」的那一半长什么样,就知道整数这一侧亏在哪 |
| 数据这一关 · 07 · 异常值是错还是真 | 那里把 32767 / 65535 / 2147483647 列为脏数据的判别信号。⭐ 读完本章你会知道那三个数是怎么被制造出来的,以及你自己的 astype 正在制造它 |
| AI 基础设施 · 06 · 混合精度 | 浮点低精度那一整侧在那里:FP16 和 BF16 怎么选、loss scaling 为什么必须有。本章的浮点例子只用于检查整数转换后是否仍能区分,训练精度选型见混合精度章节 |
| AI 基础设施 · 18 · 量化 | INT8 量化天天在做「浮点压进 8 位整数」,⭐ 本章第四节那个「越界回绕」正是量化里 clip 那一步在防的东西——去那边看这件事被认真对待时是什么样子 |
| 07 · 把循环改写成数组运算 | 那一章的套路 ② 用整数组号做 bincount。⚠️ 组号很多时用 int16 存看着省内存,但只要参与一次乘法就会回绕 |
| ML 基础 · 16 · 特征工程基础 | 特征工程里到处是「把浮点分桶成整数 ID」。⭐ 桶数超过 32767 而 ID 存成 int16 时,本章第四节那个 -32768 就会出现在你的特征里 |
| 代码题拆解 07 · 位运算与模拟 | ⭐ 反面对照:纯 Python 的整数是无限位的,所以「不用加减乘除做加法」那道题处理负数时得自己补一个 32 位掩码;进了 NumPy 则相反,位宽是定死的、越界直接回绕 |
✅ 检查点
np.array([200], np.uint8) + np.uint8(100)等于多少?为什么是这个数?它会报警告吗?- 同样的运算写成
np.uint8(200) + np.uint8(100)有什么不同? np.array([0.9999, -0.9999]).astype(np.int32)得到什么?和np.floor的结果一样吗?np.round(np.array([2.5, 3.5]))得到什么?为什么不是 3 和 4?np.array([1,2,3], np.int8) + 1的 dtype 是什么?+ np.int64(1)呢?+ 1000呢?uint8 + int8为什么提升成int16?uint64 + int64又提升成什么?with np.errstate(all="raise")能不能抓住int32最大值 +1?为什么?np.full(100, 30000, np.int16).sum()是多少?dtype 是什么?为什么它没有溢出,而raw * 2溢出了?np.array([True]) + np.array([True])等于什么?- 数据里出现一撮值正好等于 32767,最可能的成因是什么?为什么值域检查抓不住
32768 -> -32768这种回绕?
再预测一次: 把 raw * np.int16(2) 的结果转成 int32,后两项是什么?分别转为 float32 的两个整数 2**24 与 2**24 + 1 还能区分吗?
👀 答案
[44]。uint8只能表示 0–255,300 超出后取模:300 − 256 = 44。⚠️ 不报警告,实测警告条数 0。- 值同样是 44,但会报
RuntimeWarning: overflow encountered in scalar add(实测警告条数 1)。这就是全章招牌:只有标量吭声,而真实代码里遇到的永远是数组那一版。 [0, 0]——向零截断。⚠️ 和np.floor不一样:floor给[0, -1]。负数那一侧两者才分得开。[2., 4.]。np.round是银行家舍入:五往偶数那边凑,所以 2.5 → 2 而 3.5 → 4。+ 1→int8(NEP 50 的弱标量不拉高数组 dtype);+ np.int64(1)→int64(有 dtype 的标量参与提升);+ 1000→ 抛OverflowError: Python integer 1000 out of bounds for int8。- 因为
uint8是 0–255、int8是 −128–127,没有 8 位类型能覆盖 −128–255,所以升到int16。⚠️uint64 + int64找不到能装下两边的整数类型,掉到float64。超过2**53后,有些相邻整数会舍入成同一个浮点值。 - 本节 int32 数组示例抓不住,
np.array([2147483647], dtype=np.int32) + np.int32(1)在np.errstate(all="raise")中仍回绕成-2147483648。这不代表全部整数运算都如此:np.int16(32000) * np.int16(3)的标量乘法会在over="raise"下抛出FloatingPointError。它不能替代整数数组的范围检查。 - 3000000。64 位 NumPy 2.x 默认用
int64累加这批int16,这个总和装得下。指定int16累加得到 −14656。而raw * np.int16(2)在乘法阶段就让后两项变成 −15536、−3536,后面的求和没有机会恢复原值。 True(dtype 还是bool)。布尔数组相加是逻辑或,不是 2。数 True 的个数要.astype(int)或直接.sum()。- 最可能是某处
astype(np.int16)(或int16数组做了乘法)把超范围的值截断了 —— 32767 是int16的上界。💀 值域检查抓不住32768 -> -32768,因为 −32768 是一个完全合法的int16;只能靠「它和前后样本的关系不对劲」发现。
乘完再转换,后两项仍为 −15536、−3536,因为回绕已经发生。2**24 与 2**24 + 1 转为 float32 后也相同,都是 16777216,因为此处的相邻可表示数间距已经变成 2。
本节回顾
⚡ 走神救援
从一个整数出发,按存储、运算、累加、写回的顺序核对
dtype。相邻的大整数进入浮点表示后,可能成为同一个有限值。⭐ 招牌实验:
uint8的 200 加 100 得到的是 44(也就是减掉 256),⭐⭐ 而警告条数是 0。同一件事写成标量倒会报溢出警告——💀 但真实代码里你遇到的永远是数组那一版:你不会写标量加法,你会写img + delta,然后几个像素从 250 悄悄变成 4。有符号更狠:最大值加 1 直接翻成最小的负数。⭐ 记住这几个数的样子:127、255、32767、65535、21 亿多、42 亿多——它们是溢出留在数据里的指纹。⚠️ 默认整数 dtype 平台和版本相关,依赖范围的地方一律显式写 dtype。
区分三种操作:范围内的浮点转整数会向零截断(负数一侧与
floor不同);np.round遇到正中间值会取偶数(2.5 到 2,3.5 到 4);本章示例中的整数缩窄转换会静默回绕。💀 最阴的一例是只超出上界 1,符号就翻了,而结果仍是一个合法值,值域检查抓不住。类型提升四条里最容易被绊的:Python 裸整数是弱标量、不会把数组 dtype 拉高;⚠️ 而有符号加无符号会取一个能装下两边的类型,极端情况下会一路提升到浮点。
💀💀
np.errstate不是整数数组的通用越界保护。 本章数组加法在all="raise"中仍静默回绕;部分 NumPy 整数标量运算却能报告溢出。升宽后检查只在原值、操作数和精确中间结果都装得进中间类型时可靠;原add_checked的 int64 中间量也会溢出。64 位边界应运算前判界,或先用 Python int / object 精确运算再检查范围。can_cast的安全模式检查转换关系,不能代替算术结果的范围验证。要在哪一步防回绕,就在哪一步之前升宽。 用宽类型求和不能修复已经回绕的乘法结果。布尔数组逐元素相加得到逻辑或的结果,数一份数组里的真值可用
.sum()。
下一节 👉 09-log域运算.md