🏠 总目录📚 本教程 08 · 整数 dtype 的真相 ← →

NUMPY / 08 · 08 · 整数 dtype 的真相:回绕与截断

255 再加 1,为什么不是 256?

Python 整数与固定宽度数组不是同一种边界。uint8 的格子只能表示 0 到 255。

你能把运算回绕、类型提升和显式转换分开,而不只盯着有没有警告。

uint8 机制示意本图仅说明已有 uint8 数组的加法回绕。不是将越界 Python 标量转换为 uint8;两者在不同版本下的行为不能混用。uint8:0 到 255255 + 1 = 256256 mod 256 = 0不是 Python 整数变小了是数组 dtype 的边界
本图仅说明已有 uint8 数组的加法回绕。不是将越界 Python 标量转换为 uint8;两者在不同版本下的行为不能混用。

可选小实验 · 浏览器里的简化示意

从值域的最后一格,往前走一步。

猜测可以略过,操作也可以略过。这里不运行 NumPy,不测性能;完整代码与直接结果始终可读。

x = np.array([255], dtype=np.uint8)
x + np.array([1], dtype=np.uint8)  # array([0], dtype=uint8)

默认 255+1 在 uint8 数组中回绕为 0。

不操作,直接看结果和使用条件

这个控件只接受 0..255 的整数,演示已有 uint8 数组加 1 后的模 256 结果。它不模拟 np.uint8(256) 的标量转换,也不替代版本相关的类型提升规则。原文的 200+100=44 仍是同一值域的另一组输入。

uint8 机制示意机制关系;完整条件见图注。uint8:0 到 255255 + 1 = 256256 mod 256 = 0不是 Python 整数变小了是数组 dtype 的边界
本图仅说明已有 uint8 数组的加法回绕。不是将越界 Python 标量转换为 uint8;两者在不同版本下的行为不能混用。
阅读范围、用时与原有实验记录
实验记录怎么读

本页原有耗时、内存、报错和环境值保留为原文记录;本轮内容审校未逐项复跑这些实验。版本、硬件、数据和测量方法都会影响结果,示例中的倍数也不是保证。需要复现时先核对依赖版本,再在同一输入下比较。

⏱ 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))

关键信息

数组 [200]uint8 + uint8(100) = [44] | 警告条数 0
标量 uint8(200) + uint8(100) = 44 | 警告条数 1
-> RuntimeWarning: overflow encountered in scalar add
数组+数组 = [44] | 警告条数 0
int32 最大值 +1 = [-2147483648] | 警告条数 0

⭐ 这就是全章的招牌:三个式子算的是同一件事,答案都是 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)
整数类型的表示范围
整数类型位宽范围
int88 bit-128 ~ 127
uint88 bit0 ~ 255
int1616 bit-32768 ~ 32767
uint1616 bit0 ~ 65535
int3232 bit-2147483648 ~ 2147483647
uint3232 bit0 ~ 4294967295
int6464 bit-9223372036854775808 ~ 9223372036854775807
uint6464 bit0 ~ 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()))

关键信息

直接 astype [ 0 0 2 -2 3 1000000000]
round 再 astype [ 1 -1 2 -2 4 1000000000]
floor 再 astype [ 0 -1 2 -3 3 1000000000]
int64 -> int16 [-32768 4464 -1]
int64 -> uint8 [ 0 112 255]
int16 范围 -32768 ~ 32767 | 全部装得下吗: False

这三行结果来自不同操作。 先区分主动舍入与直接转换,再看原值是否超出目标类型的范围。

现象 实证 说明
向零截断 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)

关键信息

int8 数组 + Python int 1 -> int8
int8 数组 + np.int64(1) -> int64
int8 数组 + int64 数组 -> int64
uint8 + int8 -> int16
uint8 + int16 -> int16
uint64 + int64 -> float64
int64 + float32 -> float64
int32 + float32 -> float64
int8 数组 + 1000 -> OverflowError: Python integer 1000 out of bounds for int8

规则拆开是四条:

  1. ⭐ Python 的裸整数是「弱标量」,不会拉高数组的 dtype(NEP 50)。int8 数组 + 1 还是 int8。 ⭐ 但它越界时会报 OverflowError ——a8 + 1000 直接抛异常。这是 NumPy 2 少数几个主动帮你挡了一下的地方,请珍惜,因为下一条里它就不管了。
  2. 有 dtype 的标量(np.int64(1))和数组一样参与提升。int8 + np.int64(1) → int64。 💀 所以 a8 + 1 和 a8 + np.int64(1) 结果的 dtype 不一样,而它们看起来只差一个包装。
  3. 有符号 + 无符号 = 找一个能同时装下两边的。uint8(0–255)+ int8(−128–127)→ int16,因为没有 8 位类型能覆盖 −128–255。 ⚠️ uint64 + int64 找不到这样的整数类型,于是掉到 float64 。它能表示更大的数,但超过 2**53 后,不能精确表示每一个整数。
  4. 整数与浮点混算时,整数位宽也参与选型。 int16 + float32 → float32,但 int32 + float32 → float64,因为 float32 的有效精度只有 24 个二进制位,无法逐一表示所有 int32 的值。int64 + float32 也得到 float64,仍可能舍入较大的整数。

看一次整数舍入。 三条记录的整数 ID 依次是 16777216、16777217 和 16777218。若把它们转成 float32,还能区分三条记录吗?先沿下表读中间一行,再跑代码。

把同一批整数分别转换为两种浮点类型
整数 ID转成 float32转成 float64
167772161677721616777216
167772171677721616777217
167772181677721816777218

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"))

关键信息

浮点溢出被抓到: overflow encountered in exp
整数回绕没被抓到: [-2147483648]
自己查出来了: 结果超出 int32 的范围 -2147483648~2147483647
np.can_cast(int32 -> int16, 'safe') = False
np.can_cast(int16 -> int32, 'safe') = True

⭐ 边界: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,再求总数。先把输入、乘法结果和最后的求和分别写下来。

同一份输入,比较三种升宽时机
路径乘法后得到的三项最终输出
乘完再转 int3224000、−15536、−3536同样的三项,存成 int32
乘完用 int64 求和24000、−15536、−35364928
先转 int32,再乘,再用 int64 求和24000、50000、62000136000

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]))

关键信息

原始 int16 [12000 25000 31000]
直接 *2 (int16) [ 24000 -15536 -3536]
先升 int32 再乘 [24000 50000 62000]
sum 的 dtype int64 值 3000000
逐元素累加 int16 -14656
mean 的 dtype float64 值 30000.0
int16 + float32 -> float32
bool + bool -> bool [ 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 则相反,位宽是定死的、越界直接回绕

✅ 检查点

  1. np.array([200], np.uint8) + np.uint8(100) 等于多少?为什么是这个数?它会报警告吗?
  2. 同样的运算写成 np.uint8(200) + np.uint8(100) 有什么不同?
  3. np.array([0.9999, -0.9999]).astype(np.int32) 得到什么?和 np.floor 的结果一样吗?
  4. np.round(np.array([2.5, 3.5])) 得到什么?为什么不是 3 和 4?
  5. np.array([1,2,3], np.int8) + 1 的 dtype 是什么?+ np.int64(1) 呢?+ 1000 呢?
  6. uint8 + int8 为什么提升成 int16?uint64 + int64 又提升成什么?
  7. with np.errstate(all="raise") 能不能抓住 int32 最大值 +1?为什么?
  8. np.full(100, 30000, np.int16).sum() 是多少?dtype 是什么?为什么它没有溢出,而 raw * 2 溢出了?
  9. np.array([True]) + np.array([True]) 等于什么?
  10. 数据里出现一撮值正好等于 32767,最可能的成因是什么?为什么值域检查抓不住 32768 -> -32768 这种回绕?

再预测一次: 把 raw * np.int16(2) 的结果转成 int32,后两项是什么?分别转为 float32 的两个整数 2**24 与 2**24 + 1 还能区分吗?

👀 答案
  1. [44]。uint8 只能表示 0–255,300 超出后取模:300 − 256 = 44。⚠️ 不报警告,实测警告条数 0。
  2. 值同样是 44,但会报 RuntimeWarning: overflow encountered in scalar add(实测警告条数 1)。这就是全章招牌:只有标量吭声,而真实代码里遇到的永远是数组那一版。
  3. [0, 0] ——向零截断。⚠️ 和 np.floor 不一样:floor 给 [0, -1]。负数那一侧两者才分得开。
  4. [2., 4.]。np.round 是银行家舍入:五往偶数那边凑,所以 2.5 → 2 而 3.5 → 4。
  5. + 1 → int8(NEP 50 的弱标量不拉高数组 dtype);+ np.int64(1) → int64(有 dtype 的标量参与提升);+ 1000 → 抛 OverflowError: Python integer 1000 out of bounds for int8。
  6. 因为 uint8 是 0–255、int8 是 −128–127,没有 8 位类型能覆盖 −128–255,所以升到 int16。⚠️ uint64 + int64 找不到能装下两边的整数类型,掉到 float64 。超过 2**53 后,有些相邻整数会舍入成同一个浮点值。
  7. 本节 int32 数组示例抓不住,np.array([2147483647], dtype=np.int32) + np.int32(1) 在 np.errstate(all="raise") 中仍回绕成 -2147483648。这不代表全部整数运算都如此:np.int16(32000) * np.int16(3) 的标量乘法会在 over="raise" 下抛出 FloatingPointError。它不能替代整数数组的范围检查。
  8. 3000000。64 位 NumPy 2.x 默认用 int64 累加这批 int16,这个总和装得下。指定 int16 累加得到 −14656。而 raw * np.int16(2) 在乘法阶段就让后两项变成 −15536、−3536,后面的求和没有机会恢复原值。
  9. True(dtype 还是 bool)。布尔数组相加是逻辑或,不是 2。数 True 的个数要 .astype(int) 或直接 .sum()。
  10. 最可能是某处 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

打卡记录保存在你的浏览器里,首页能看到总进度

整数可能回绕,浮点数则可能在中间步骤先溢出。结果本身有限,也不保证写法稳定。