Python负数求余数怎么算？%运算符的计算规则

很多从 C、C++ 或 Java 转到 Python 的开发者，在第一次执行 -7 % 3 时往往会得到出乎意料的答案：在 C 语言中结果是 -1，而在 Python 中得到的确是 2。这并不是 Python 的计算 Bug，而是源于底层对除法取整规则的不同设计哲学。

一、底层数学逻辑：整除与取模的绑定关系

在任何现代编程语言中，除法、整除与取模必须满足欧几里得整除定理的基本恒等式：

a = b * q + r  （其中 a 为被除数，b 为除数，q 为商，r 为余数）

变换该式，余数 r 的计算公式永远是：

r = a - b * q

这意味着余数的值完全取决于商 q 是如何被截断或取整的。在编程语言的设计中，主要存在两种主流的整除取整策略：

• 向零截断（Truncated Division，以 C/C++/Java 为代表）： 商直接扔掉小数部分，向 0 方向靠拢。例如 -7 / 3 = -2.333...，向零截断后商 q = -2。代入公式得 r = -7 - 3 * (-2) = -1。余数符号与被除数一致。
• 向下取整（Floor Division，以 Python 为代表）： 商向负无穷大方向舍入（数学记号 ⌊a / b⌋）。同样是 -7 / 3 = -2.333...，向下取整后商 q = -3。代入公式得 r = -7 - 3 * (-3) = 2。余数符号与除数一致。

二、四种正负符号组合实测与逐步拆解

为了让读者彻底掌握实际计算，我们将除数与被除数的正负组合划分为四种情况，统一以绝对值 7 和 3 为例逐一展开演练。

1. 正数 % 正数：7 % 3 = 1

这是最基础的常识情况：

• 真值除法：7 / 3 = 2.333...
• 向下取整：7 // 3 = 2
• 代入公式：r = 7 - 3 * 2 = 1
• 验证符号：除数 3 为正数，余数 1 落在区间 [0, 3) 内，符号一致。

2. 负数 % 正数：-7 % 3 = 2

初学者最容易出错的情况：

• 真值除法：-7 / 3 = -2.333...
• 向下取整：在数轴上，小于等于 -2.333... 的最大整数是 -3，因此 -7 // 3 = -3。
• 代入公式：r = -7 - 3 * (-3) = -7 - (-9) = 2
• 验证符号：除数 3 为正数，余数 2 为正数，落在区间 [0, 3) 内。

3. 正数 % 负数：7 % -3 = -2

除数为负数时的情况：

• 真值除法：7 / -3 = -2.333...
• 向下取整：小于等于 -2.333... 的最大整数同样是 -3，即 7 // -3 = -3。
• 代入公式：r = 7 - (-3) * (-3) = 7 - 9 = -2
• 验证符号：除数 -3 为负数，余数 -2 为负数，落在区间 (-3, 0] 内。

4. 负数 % 负数：-7 % -3 = -1

两个操作数均为负数：

• 真值除法：-7 / -3 = 2.333...
• 向下取整：小于等于 2.333... 的最大整数是 2，即 -7 // -3 = 2。
• 代入公式：r = -7 - (-3) * 2 = -7 - (-6) = -1
• 验证符号：除数 -3 为负数，余数 -1 同样为负数。

在 Python 交互式命令行（REPL）中执行上述代码进行验证：

# 示例代码：验证四种符号情况
print(7 % 3)    # 输出: 1
print(-7 % 3)   # 输出: 2
print(7 % -3)   # 输出: -2
print(-7 % -3)  # 输出: -1

三、数轴几何视角：为什么 Python 坚持向下取整？

为什么 Python 之父 Guido van Rossum 在设计语言时不采用 C 语言经典的“向零截断”，而坚持使用“向下取整”？从数轴几何和工程连续性的角度来看，Python 的做法具有极高的实用价值。

假设我们正在开发一个钟表循环系统或网格坐标系统。时间在不断流逝（无论是正向还是倒序），我们希望时间的周期索引永远落在 [0, N-1] 的范围之内。如果采用向下取整：

• 当时间为 2 秒时，2 % 60 = 2
• 当时间为 1 秒时，1 % 60 = 1
• 当时间为 0 秒时，0 % 60 = 0
• 当时间倒流到 -1 秒时，-1 % 60 = 59
• 当时间倒流到 -2 秒时，-2 % 60 = 58

这种平滑自然的周期过渡，正是数学上同余群（Modular Arithmetic）的标准表现。而在 C 语言中，-1 % 60 = -1，程序员必须编写额外的 if (r < 0) r += 60; 判断逻辑来修正负索引。

四、内置函数与工程扩展：divmod() 与 math.fmod()

在日常开发中，除了直接使用 % 运算符，Python 还提供了相关的标准库工具，用于不同的工程场景。

1. 内置函数 divmod(a, b)

如果程序中需要同时获取商和余数，推荐使用内置函数 divmod(a, b)，它在一个原子操作内直接返回元组 (a // b, a % b)，内部运算完全遵循 Python 的向下取整原则：

# 示例代码：divmod 行为演示
q, r = divmod(-7, 3)
print(f"商: {q}, 余数: {r}")  # 输出: 商: -3, 余数: 2

# 验证基本等式：b * q + r == a
print(3 * q + r == -7)       # 输出: True

2. math.fmod()：获取 C 语言风格的余数

如果读者正在将一段 C/C++ 算法代码翻译为 Python，且业务逻辑严重依赖“余数与被除数同号”的特性，不要手动改写负数逻辑，可以直接使用标准数学库中的 math.fmod() 函数：

import math

# Python 原生 % 运算符
print(-7 % 3)            # 输出: 2

# math.fmod 遵循 C 语言规则（向零截断）
print(math.fmod(-7, 3))   # 输出: -1.0

五、语言对比与知识总结

为了便于随时查阅，下表总结了在常见正负组合下，Python 的 % 与 C/Java 取模运算符的结果对比：

六、总结与结语

综上所述，Python 负数求余数的计算过程可拆解为清晰的三个步骤：

1. 计算精确除法值 a / b。
2. 执行向下取整获得商 q = a // b = math.floor(a / b)（始终向负无穷大方向寻找最接近的整数）。
3. 代入欧几里得余数公式 r = a - b * q 获得最终余数。

这一机制保证了无论被除数是正是负，只要除数为正数 N，余数范围都稳稳落在 [0, N-1] 的合法闭区间内。这为循环数组、时钟计算、散列哈希映射提供了天然的便利性与一致性。