为什么 Python 浮点数整除结果可能不精确？

在 Python 中对浮点数使用整除运算符 // 时，之所以经常出现结果比预期少 1（例如 1.0 // 0.1 得到 9.0 而非 10.0），根本原因在于二进制浮点数的近似存储与向下取整（Floor）在临界点对微小负偏差的放大效应共同作用。只要除数在底层存储中比字面值略大一丝，或者被除数比字面值略小一点，商在跨越整数边界前就会被直接截断到下一个更小的整数。理解这一底层机制后，在涉及金额拆分、步长计数或倍率换算的场景中，可以通过整数化缩放或 decimal.Decimal 模块彻底规避误差。

一、典型现象：明明能整除，结果却少了 1

许多人在编写分页步长计算、商品件数折算或时间片切分代码时，会自然地用 a // b 求取 a 中包含多少个完整的 b。在整数运算中，10 // 1 永远精确等于 10；然而一旦操作数变成浮点数，结果就可能偏离直觉。

在 Python 3.8 及以上版本的交互式终端（REPL）或脚本中执行以下代码，可以直观看到三组常见异常情况：

# 场景 1：1.0 中包含多少个 0.1？
print("1.0 / 0.1  =", 1.0 / 0.1)
print("1.0 // 0.1 =", 1.0 // 0.1)

# 场景 2：0.6 中包含多少个 0.2？
print("0.6 / 0.2  =", 0.6 / 0.2)
print("0.6 // 0.2 =", 0.6 // 0.2)

# 场景 3：单价 0.29 元放大 100 倍后取整
print("(0.29 * 100) / 1  =", (0.29 * 100) / 1)
print("(0.29 * 100) // 1 =", (0.29 * 100) // 1)

1.0 / 0.1  = 10.0
1.0 // 0.1 = 9.0
0.6 / 0.2  = 3.0
0.6 // 0.2 = 2.0
(0.29 * 100) / 1  = 28.999999999999996
(0.29 * 100) // 1 = 28.0

对比前两组输出可以发现一个极具迷惑性的现象：普通真除法 1.0 / 0.1 和 0.6 / 0.2 的显示结果分别是 10.0 和 3.0，看起来毫无误差；但换成整除 // 后，结果却突然变成了 9.0 和 2.0。这并非 Python 解释器的算术缺陷，而是底层数值表示与整除定义严格结合后的必然结果。

二、底层原因拆解：从二进制近似到整除边界截断

要弄清 1.0 // 0.1 为什么等于 9.0，需要顺着 Python 处理浮点数整除的两个核心环节逐步拆解：第一步是十进制小数如何存入内存，第二步是 CPython 如何计算浮点数的整除与余数。

1. 除数 0.1 在内存中实际上比 0.1 大一点点

Python 的 float 类型遵循 IEEE 754 双精度（64 位）浮点数标准，使用 53 位二进制有效数字来表示数值。十进制的 0.1 转换为二进制是无限循环小数 0.00011001100110011...。由于尾数位只有 53 位，超出部分必须按照“向最近偶数舍入”的规则截断。

截断进位后，内存中实际保存的 0.1 换算回精确十进制，是一个比 0.1 略大一点的数：

0.1000000000000000055511151231257827021181583404541015625

同样地，0.6 // 0.2 出现偏差是因为 0.6 的二进制近似值比真实值略小（约为 0.5999999999999999778...），而 0.2 的二进制近似值比真实值略大（约为 0.2000000000000000111...）。一正一负的微小偏移叠加后，0.6 里自然装不下 3 个完整的 0.2。

2. 为什么普通除法 1.0 / 0.1 能算出 10.0，整除却算不出？

不少读者会疑惑：既然 0.1 比实际值偏大，为什么 1.0 / 0.1 没有算出 9.999999999999999，而是正常显示 10.0？这就要对比普通真除法 / 与整除 // 对尾数误差的不同处理方式。

在 CPython 源码（Objects/floatobject.c 中的 float_divmod 函数）中，a // b 并不是简单地先算出 a / b 再调用 math.floor()，而是与取模运算 a % b 绑定计算，严格保证以下数学恒等式成立：

a == (a // b) * b + (a % b)，且余数 a % b 与除数 b 同号、绝对值严格小于 |b|。

对于 1.0 和 0.1，如果让商等于 10.0，那么 10.0 * 0.10000000000000000555... 就会大于 1.0，导致余数变成负数，违反了正数除数下余数必须大于等于 0 的规则。因此，CPython 会把商往回调小 1，定为 9.0，并留下一个极其接近 0.1 的正余数 0.09999999999999995。

三、如何排查与验证浮点数整除异常

当线上或脚本中的 // 运算结果与手算不一致时，不要只看 print(a, b) 的默认输出，因为 Python 会自动格式化输出简短的十进制形式（例如把 0.10000000000000000555... 直接打印成 0.1）。应当按照以下四个步骤定位问题并替换为可靠实现。

在终端或调试器中，运行以下诊断脚本即可直接看清任意一组浮点数整除的内部状态：

from decimal import Decimal

def inspect_floordiv(a: float, b: float) -> None:
    q, r = divmod(a, b)
    print(f"表达式: {a} // {b}")
    print(f"  a 的真实存储值: {Decimal.from_float(a)}")
    print(f"  b 的真实存储值: {Decimal.from_float(b)}")
    print(f"  整除商 q = {q}, 余数 r = {r}")
    print(f"  余数 r 与除数 b 的差值 (b - r) = {b - r:.3e}\n")

inspect_floordiv(1.0, 0.1)
inspect_floordiv(0.6, 0.2)

表达式: 1.0 // 0.1
  a 的真实存储值: 1
  b 的真实存储值: 0.1000000000000000055511151231257827021181583404541015625
  整除商 q = 9.0, 余数 r = 0.09999999999999995
  余数 r 与除数 b 的差值 (b - r) = 5.551e-17

表达式: 0.6 // 0.2
  a 的真实存储值: 0.59999999999999997779553950749686919152736663818359375
  b 的真实存储值: 0.200000000000000011102230246251565404236316680908203125
  整除商 q = 2.0, 余数 r = 0.19999999999999996
  余数 r 与除数 b 的差值 (b - r) = 5.551e-17

只要看到余数 r 与除数 b 的差值处于 1e-16 到 1e-17 量级，就可以百分之百确认是二进制浮点数表示误差引起的临界点退位。

四、三种可靠的精确整除解决方案

要消除浮点数整除的不精确性，核心原则是不要直接对二进制浮点数做临界整除。根据业务对性能、小数位数和负数取整方向的要求，可以从以下三种方案中选择最合适的一种。

方案一：放大为整数后配合 round() 整除（适合已知固定小数位数）

如果数据的小数位数固定（例如人民币金额最多到“分”，即两位小数；或者传感器采样步长固定为 0.1 毫秒），最轻量、执行速度最快的做法是将被除数和除数同时乘以 $10^n$，通过内置的 round() 函数四舍五入为 Python 整数（int），再使用整数的 // 运算。

def scaled_floordiv(a: float, b: float, decimals: int = 2) -> int:
    scale = 10 ** decimals
    int_a = round(a * scale)
    int_b = round(b * scale)
    return int_a // int_b

print("1.0 // 0.1 (1位小数):", scaled_floordiv(1.0, 0.1, decimals=1))
print("0.6 // 0.2 (1位小数):", scaled_floordiv(0.6, 0.2, decimals=1))
print("0.29 元包含多少个 0.01 元:", scaled_floordiv(0.29, 0.01, decimals=2))

1.0 // 0.1 (1位小数): 10
0.6 // 0.2 (1位小数): 3
0.29 元包含多少个 0.01 元: 29

方案二：使用 decimal.Decimal 模块（适合金融核算与通用十进制场景）

当小数位数不固定，或者项目本身属于财务、计费、电商订单等严谨的十进制计算场景时，应当使用 Python 标准库中的 decimal.Decimal。它在底层直接按十进制数位存储和计算，0.1 就是精确的十进制 0.1，不存在二进制无限循环问题。

使用 Decimal 时有两个必须遵守的细节：

1. 传入字符串而非浮点数：必须写 Decimal('0.1') 或先用 Decimal(str(x)) 转换。如果直接写 Decimal(0.1)，会把浮点数已经带有的 0.10000000000000000555... 误差原样继承进去。
2. 注意负数的取整方向差异：Python 原生的 float // float 是向下取整（向负无穷方向，Floor），例如 -1.0 // 0.3 等于 -4.0；而 Decimal // Decimal 遵循 IEEE 854 十进制算术标准，采用向零截断（Truncate toward zero），即 Decimal('-1.0') // Decimal('0.3') 等于 Decimal('-3')。如果需要对负数也保持向下取整，应使用 math.floor(Decimal(str(a)) / Decimal(str(b)))。

import math
from decimal import Decimal

def decimal_floordiv(a: str | float, b: str | float) -> int:
    dec_a = Decimal(str(a))
    dec_b = Decimal(str(b))
    # 使用精确十进制相除后通过 math.floor 保持向负无穷取整的一致行为
    return math.floor(dec_a / dec_b)

print("正数整除 1.0 // 0.1:", decimal_floordiv("1.0", "0.1"))
print("正数整除 0.6 // 0.2:", decimal_floordiv(0.6, 0.2))
print("负数向零整除 (Decimal //):", int(Decimal("-1.0") // Decimal("0.3")))
print("负数向下整除 (math.floor):", decimal_floordiv("-1.0", "0.3"))

正数整除 1.0 // 0.1: 10
正数整除 0.6 // 0.2: 3
负数向零整除 (Decimal //): -3
负数向下整除 (math.floor): -4

方案三：使用 fractions.Fraction 模块（适合含 1/3、1/7 等非十进制分数场景）

如果除数本身无法表示为有限位的十进制小数（例如步长为 $1/3$、$1/6$ 的几何网格划分或比例运算），即使用 Decimal 也会在除法时产生十进制截断误差。此时可以使用标准库 fractions.Fraction 将数值表示为精确的分子与分母之比，其 // 运算符直接基于精确有理数向下取整。

from fractions import Fraction

# 字符串传入会精确解析十进制小数：Fraction('0.1') == Fraction(1, 10)
q1 = Fraction("1.0") // Fraction("0.1")

# 对于无限十进制小数（如 1/3），直接用分子分母构造
step = Fraction(1, 3)
total = Fraction(2, 1)
q2 = total // step

print("Fraction('1.0') // Fraction('0.1') =", q1)
print("2 中包含多少个 1/3 =", q2)

Fraction('1.0') // Fraction('0.1') = 10
2 中包含多少个 1/3 = 6

五、总结与方案选型对照

回到最初的问题：Python 浮点数整除之所以可能不精确，是因为 float 用有限位数的二进制分数近似表示十进制小数，而整除运算符 // 在整数边界处属于不连续的阶跃操作，哪怕真实商比目标整数小 $5.55 \times 10^{-17}$，也会被严格截断到前一个整数。在实际开发中，可以根据下图总结的判断标准直接选择替代方案。