Python `round()` 函数深度解析：完美实现四舍五入

在 Python 中，round() 函数是用来对数字进行舍入的内置函数。然而，许多初学者乃至有经验的开发者在使用它时，常常会遇到与传统数学或银行领域四舍五入规则不符的情况。本文将深入探讨 round() 函数的工作原理、其独特的“银行家舍入”规则，并提供实现传统四舍五入的方法，帮助您“完美”地掌握数字舍入。

1. `round()` 函数的基本用法

round() 函数的基本语法如下：

python round(number[, ndigits])

number: 必需参数，表示需要进行舍入的数字。
ndigits: 可选参数，表示舍入到小数点后多少位。
- 如果省略 ndigits，函数会将数字舍入到最接近的整数。
- 如果 ndigits > 0，则舍入到小数点后 ndigits 位。
- 如果 ndigits = 0，效果与省略 ndigits 类似，舍入到最接近的整数。
- 如果 ndigits < 0，则舍入到小数点左侧（即整数位）。

示例：

“`python

舍入到最接近的整数

print(f”round(3.14) -> {round(3.14)}”) # 3
print(f”round(3.89) -> {round(3.89)}”) # 4
print(f”round(-2.7) -> {round(-2.7)}”) # -3

舍入到指定小数位数

print(f”round(3.14159, 2) -> {round(3.14159, 2)}”) # 3.14
print(f”round(123.456, 1) -> {round(123.456, 1)}”) # 123.5

舍入到整数位左侧

print(f”round(123.456, -1) -> {round(123.456, -1)}”) # 120.0
print(f”round(178.9, -2) -> {round(178.9, -2)}”) # 200.0
“`

2. Python `round()` 的“银行家舍入”（Banker’s Rounding）

这是 round() 函数最容易引起混淆的地方。与我们小学数学中学到的“四舍五入”（即逢五进一）不同，Python 3（以及许多其他编程语言和IEEE 754标准）中的 round() 函数默认采用的是“银行家舍入”（Banker’s Rounding）规则，也称为“向偶数舍入”（Round Half to Even）。

银行家舍入规则的核心是：

当一个数字恰好位于两个整数（或指定小数位数）的中间时（即小数部分为 .5），round() 函数会将其舍入到最近的偶数。

示例：

“`python
print(f”round(2.5) -> {round(2.5)}”) # 2 (最近的偶数)
print(f”round(3.5) -> {round(3.5)}”) # 4 (最近的偶数)
print(f”round(4.5) -> {round(4.5)}”) # 4 (最近的偶数)
print(f”round(5.5) -> {round(5.5)}”) # 6 (最近的偶数)

print(f”round(2.15, 1) -> {round(2.15, 1)}”) # 2.1 (2.1 和 2.2 中间，2.1 是偶数)
print(f”round(2.25, 1) -> {round(2.25, 1)}”) # 2.3 (2.2 和 2.3 中间，2.2 是偶数) – 注意！这里结果是 2.2。原因见下文！
“`

为什么 round(2.25, 1) 的结果是 2.2 而不是 2.3 呢？

这涉及到浮点数表示的精度问题。大多数浮点数（float 类型）在计算机内部是以二进制形式存储的，这导致并非所有十进制小数都能被精确表示。例如，2.25 在二进制中可能被表示为 2.2499999999999996 或 2.2500000000000004 这样非常接近但不是精确的值。当 round() 函数看到一个略小于 2.25 的值时，它会将其舍入到 2.2。

因此，对于浮点数，即使你认为它是 .5 结尾，也可能因为精度问题而导致其行为与预期略有不同。

3. 为什么采用银行家舍入？

银行家舍入的优点在于它能减少累积误差。如果总是“四舍五入”（逢五进一），那么在大量计算中，每次都倾向于向上舍入会使结果系统性地偏大。而银行家舍入在“一半”的情况下向下舍入（到偶数），在另一半情况下向上舍入（到偶数），这样可以使舍入误差的平均值更接近零，从而在统计学上更为公平和准确。

4. 实现“完美”的传统四舍五入（Round Half Up）

如果你需要实现传统的“四舍五入”（即逢五进一，Round Half Up）规则，尤其是在处理金融计算或对精度有严格要求的场景时，不应直接依赖 round() 函数。Python 提供了其他方法来实现：

方法一：使用 `decimal` 模块

decimal 模块提供了高精度的十进制浮点运算，可以避免二进制浮点数带来的精度问题，并且支持多种舍入模式。

“`python
from decimal import Decimal, ROUND_HALF_UP, getcontext

设置上下文，包括精度和舍入模式

通常，在程序开始时设置一次即可

getcontext().prec = 10 # 设置精度，例如10位小数
getcontext().rounding = ROUND_HALF_UP # 设置舍入模式为四舍五入

def traditional_round_decimal(number_str, ndigits=0):
“””
使用 decimal 模块实现传统四舍五入（逢五进一）。
number_str: 以字符串形式传入数字，以避免浮点数精度问题。
ndigits: 舍入到小数点后多少位。
“””
d = Decimal(str(number_str))
if ndigits >= 0:
# 构建一个只有1的小数点后ndigits位的Decimal对象进行量化
# 例如，ndigits=2，quantize_value = Decimal(‘0.01′)
quantize_value = Decimal(’10’) ** -ndigits
else:
# 舍入到整数位左侧，例如 ndigits=-1 (舍入到十位)，quantize_value = Decimal(’10’)
quantize_value = Decimal(’10’) ** abs(ndigits)

return d.quantize(quantize_value, rounding=ROUND_HALF_UP)

print(“\n— 使用 Decimal 模块实现传统四舍五入 —“)
print(f”traditional_round_decimal(‘2.5’) -> {traditional_round_decimal(‘2.5’)}”) # 3
print(f”traditional_round_decimal(‘3.5’) -> {traditional_round_decimal(‘3.5’)}”) # 4
print(f”traditional_round_decimal(‘2.15’, 1) -> {traditional_round_decimal(‘2.15’, 1)}”) # 2.2 (仍然是2.2因为quantize默认是ROUND_HALF_EVEN)
print(f”traditional_round_decimal(‘2.25’, 1) -> {traditional_round_decimal(‘2.25’, 1)}”) # 2.3

重新演示ndigits=1的银行家舍入对0.05的影响

print(f”round(0.05, 1) -> {round(0.05, 1)}”) # 0.0
print(f”traditional_round_decimal(‘0.05’, 1) -> {traditional_round_decimal(‘0.05’, 1)}”) # 0.1
print(f”traditional_round_decimal(‘0.15’, 1) -> {traditional_round_decimal(‘0.15’, 1)}”) # 0.2

负数的情况

print(f”traditional_round_decimal(‘-2.5’) -> {traditional_round_decimal(‘-2.5’)}”) # -3
`` **注意**：decimal.quantize()函数的第二个参数rounding` 可以直接指定舍入模式，确保了准确性。传入数字时最好使用字符串形式，以避免浮点数本身的精度问题。

方法二：自定义函数（适用于正数，或需处理负数）

如果你只处理正数，或者希望编写一个简单的函数来实现，可以考虑以下逻辑：

“`python
def traditional_round_half_up(number, ndigits=0):
“””
实现传统的四舍五入（逢五进一）规则。
number: 要舍入的数字。
ndigits: 舍入到小数点后多少位。
“””
if ndigits < 0:
# 处理舍入到整数位左侧的情况，例如 round(123, -1) -> 120
factor = 10**(-ndigits)
return round(number / factor) * factor

factor = 10**ndigits
# 将数字乘以10的ndigits次方，然后加0.5再取整
# 这样，原本 .5 会变成 .0 经过加0.5变成 .5 然后取整会进位
# 但由于浮点数精度问题，直接加0.5再int()或round()可能依然有问题
# 更稳妥的方法是利用 Decimal，或者更细致的判断

# 一个更简单的实现思路，利用了符号和加0.5的技巧
# 注意：这个方法对浮点数精度问题仍然敏感
if number < 0:
    return int(number * factor - 0.5) / factor
else:
    return int(number * factor + 0.5) / factor

考虑浮点数精度更稳健的实现

def custom_round_half_up(value, digits=0):
“””
一个更健壮的传统四舍五入函数，尝试解决浮点精度问题。
“””
from math import floor, copysign
# 处理负数的情况，让舍入行为对正负数一致（即都远离0）
sign = copysign(1, value)
abs_value = abs(value)

# 移位，将目标舍入位移到小数位第一位
shifted_value = abs_value * (10 ** digits)

# 判断是否需要进位
# 比如 2.5 * 10^0 = 2.5
# 2.25 * 10^1 = 22.5
if shifted_value - floor(shifted_value) >= 0.5:
    # 进位
    rounded_value = floor(shifted_value) + 1
else:
    # 不进位
    rounded_value = floor(shifted_value)

return sign * (rounded_value / (10 ** digits))

print(“\n— 使用自定义函数实现传统四舍五入 —“)
print(f”custom_round_half_up(2.5) -> {custom_round_half_up(2.5)}”) # 3.0
print(f”custom_round_half_up(3.5) -> {custom_round_half_up(3.5)}”) # 4.0
print(f”custom_round_half_up(2.15, 1) -> {custom_round_half_up(2.15, 1)}”) # 2.2 (仍然是2.2，因为2.15的浮点表示可能略小于2.15)
print(f”custom_round_half_up(2.25, 1) -> {custom_round_half_up(2.25, 1)}”) # 2.3
print(f”custom_round_half_up(-2.5) -> {custom_round_half_up(-2.5)}”) # -3.0
print(f”custom_round_half_up(0.05, 1) -> {custom_round_half_up(0.05, 1)}”) # 0.1
print(f”custom_round_half_up(0.15, 1) -> {custom_round_half_up(0.15, 1)}”) # 0.2
print(f”custom_round_half_up(123.456, -1) -> {custom_round_half_up(123.456, -1)}”) # 120.0
“`

重要提示： 即使是自定义函数，当处理由浮点数表示不精确引起的“接近 .5”的情况时，仍然可能存在细微的偏差。因此，在对精度要求极高的场景中，强烈推荐使用 decimal 模块。

总结

Python 的内置 round() 函数默认使用银行家舍入（向偶数舍入）规则，这与我们常说的“四舍五入”有所不同，并且可能受到浮点数精度问题的影响。

如果您需要严格遵循“逢五进一”的传统四舍五入规则，特别是涉及财务或敏感计算时，最佳实践是：

使用 decimal 模块，它可以提供任意精度的十进制运算，并通过 ROUND_HALF_UP 舍入模式实现精确的传统四舍五入。
在传入 decimal 对象时，优先使用字符串形式，以避免浮点数本身的精度损失。

理解 round() 的行为以及何时选择更精确的工具，是编写健壮和正确 Python 数值处理代码的关键。

Python round() 函数深度解析：完美实现四舍五入

1. round() 函数的基本用法