Python的round()函数采用“银行家舍入”规则，即四舍六入五成双，而非传统四舍五入。当小数部分为0.5时，向最近的偶数取整，如round(2.5)得2，round(3.5)得4。此规则减少统计偏差，但可能导致不符合直觉的结果。此外，浮点数精度问题可能影响舍入准确性，如2.675在内部可能表示为略小于其值的形式，导致round(2.675, 2)结果为2.67而非2.68。若需传统“五入”行为，推荐使用decimal模块并设置ROUND_HALF_UP模式，或自定义函数实现。decimal模块可避免二进制浮点误差，适合高精度需求场景。
Python中对数字进行四舍五入，最直接的方式就是使用内置的
round()函数。但这里有个小小的“陷阱”，它并不总是我们传统意义上的“四舍五入”（即0.5向上取整），而是遵循一种叫做“银行家舍入”的规则。
在Python里，如果你想对一个数字进行四舍五入，
round()函数是你的首选工具。它的用法非常直观：
round(number)
：将数字四舍五入到最接近的整数。round(number, ndigits)
：将数字四舍五入到指定的小数位数ndigits
。
这里需要特别注意
round()处理“刚好在中间”的数字（例如X.5）时的行为。Python 3 遵循 IEEE 754 标准，采用“四舍六入五成双”（或称“银行家舍入”）的规则。这意味着当小数部分刚好是0.5时，它会向最近的偶数取整。
举个例子：
round(2.5)的结果是
2，因为2是偶数。
round(3.5)的结果是
4，因为4是偶数。
round(2.675, 2)的结果是
2.68，因为保留两位小数后第三位是5，而
2.67的末位是奇数7，所以向上取整到偶数8。
round(2.685, 2)的结果是
2.68，因为保留两位小数后第三位是5，而
2.68的末位是偶数8，所以保持不变。
这种行为在统计学和金融计算中被认为是更公平的，因为它避免了总是向上或向下取整导致的累积误差。但如果你期望的是传统的“0.5一律向上取整”规则，那么
round()可能不会给你想要的结果，需要考虑其他方法。
立即学习“Python免费学习笔记（深入）”；
Python round()
函数的工作原理是什么？它总是四舍五入吗？
我们通常所说的“四舍五入”习惯上是指“四舍五入，五进一”，也就是0.5的时候总是向上进位。但在Python的
round()函数中，尤其是在Python 3及更高版本中，它采用的是“四舍六入五成双”的策略，也被称为“银行家舍入”或“偶数舍入”。
这个规则的核心是：
- 当要舍弃的数字小于5时，直接舍弃。
- 当要舍弃的数字大于5时，进位。
- 当要舍弃的数字刚好是5时，看它前面的数字：
- 如果前面是偶数，则舍弃5，保持不变。
- 如果前面是奇数，则进位。
这背后的考量主要是为了减少在大量数据处理时，由于舍入误差累积而产生的偏差。如果总是0.5向上取整，那么在处理大量正数时，结果会倾向于偏大；反之，如果总是向下取整，则会偏小。“银行家舍入”通过在0.5时一半情况向上取整，一半情况向下取整，使得这种系统性偏差得以抵消，让结果在统计学上更接近真实值。
一个常见的误解是，很多人会认为
round(2.5)应该得到
3，但实际上它返回
2。同样，
round(1.5)也返回
2。这是因为2是偶数，所以当小数部分是0.5时，它会向最近的偶数靠拢。这种行为对于初学者来说，确实需要一点时间来适应和理解。
如何在 Python 中实现传统的‘四舍五入’（round half up）？
如果
round()函数的“银行家舍入”不符合你的需求，你希望实现传统的“四舍五入”（即0.5一律向上取整），Python也提供了几种灵活的替代方案。
一种非常精确且推荐的方法是使用
decimal模块。这个模块专为高精度浮点数运算设计，可以精确控制舍入行为。
import decimal
# 设置精度，例如保留两位小数
decimal.getcontext().prec = 10 # 设置更高的精度以避免中间计算误差
D = decimal.Decimal
# 设置舍入模式为 ROUND_HALF_UP (传统四舍五入)
# decimal.ROUND_HALF_UP 表示四舍五入，0.5向上进位
# decimal.ROUND_HALF_EVEN (默认) 对应银行家舍入
# decimal.ROUND_UP 总是向上取整
# decimal.ROUND_DOWN 总是向下取整
# decimal.ROUND_CEILING 向上取整 (正无穷方向)
# decimal.ROUND_FLOOR 向下取整 (负无穷方向)
def traditional_round(number, ndigits=0):
# 将数字转换为Decimal类型
num_str = str(number)
if '.' not in num_str and ndigits > 0:
num_str += '.0' # 确保整数也能处理小数位
# 构造格式字符串，例如 '0.00' 表示两位小数
if ndigits == 0:
quantize_str = '1'
else:
quantize_str = '0.' + '0' * ndigits
return float(D(num_str).quantize(D(quantize_str), rounding=decimal.ROUND_HALF_UP))
print(traditional_round(2.5)) # 输出 3.0
print(traditional_round(3.5)) # 输出 4.0
print(traditional_round(2.675, 2)) # 输出 2.68
print(traditional_round(2.685, 2)) # 输出 2.69
print(traditional_round(2.345, 2)) # 输出 2.35另一种更“手动”的方法，适用于不需要
decimal模块那样极致精度，但又想实现传统四舍五入的场景：
import math
def custom_round_half_up(number, ndigits=0):
if ndigits < 0:
raise ValueError("ndigits cannot be negative")
factor = 10 ** ndigits
# 将数字放大，然后加上0.5，再向下取整
# 这样，X.5经过放大后变成Y.5，加0.5变成Z.0，向下取整就是Z
# X.4经过放大后变成Y.4，加0.5变成Y.9，向下取整就是Y
return math.floor(number * factor + 0.5) / factor
print(custom_round_half_up(2.5)) # 输出 3.0
print(custom_round_half_up(3.5)) # 输出 4.0
print(custom_round_half_up(2.675, 2)) # 输出 2.68
print(custom_round_half_up(2.685, 2)) # 输出 2.69
print(custom_round_half_up(2.345, 2)) # 输出 2.35这种自定义函数在处理浮点数精度问题时，仍然可能遇到一些细微的挑战，因为
number * factor本身可能不是精确的。例如，
0.1 + 0.2并不是精确的
0.3。因此，对于金融或科学计算中对精度要求极高的场景，
decimal模块依然是更稳健的选择。
处理浮点数精度问题时，Python round()
有哪些局限性？
Python 的
round()函数，以及所有基于标准浮点数（
float类型，通常是双精度浮点数 IEEE 754）的操作，都不可避免地会受到浮点数精度问题的困扰。这不是Python特有的问题，而是计算机表示非精确小数的普遍现象。
我们知道，很多小数，比如0.1，0.2，0.3，在二进制中是无法精确表示的，它们会被存储为一个非常接近的近似值。例如，当你输入
0.1时，计算机内部存储的可能是
0.1000000000000000055511151231257827021181583404541015625。
这种微小的误差在进行
round()操作时就可能显现出来，导致一些看似反直觉的结果。
考虑以下例子：
round(2.675, 2)理论上应该得到
2.68（因为2.67是奇数，根据银行家舍入规则，0.005向上取整）。 但在某些Python版本或特定浮点数计算后，你可能会发现
round(2.675, 2)得到
2.67。 这是因为
2.675在内部可能被表示为
2.6749999999999998这种形式。当
round()函数看到这个内部值时，它会认为要舍弃的数字是4（或更小），而不是5，因此就直接舍弃了，导致结果是
2.67。
同样，
round(4.45, 1)理论上应该得到
4.4(因为4是偶数，0.05向下取整)。但如果
4.45内部被表示为
4.4500000000000002，那么
round()可能会将其视为
4.5，导致结果是
4.5。
这种浮点数表示的固有不精确性，使得
round()在处理那些“刚好在边界上”的数字时，其行为变得不那么可预测。对于需要绝对精确舍入的场景，尤其是金融计算、科学数据分析等，仅仅依赖
float类型和
round()函数是非常危险的。
为了避免这些潜在的精度陷阱，
decimal模块是更专业的选择。它通过将数字存储为十进制字符串并进行十进制运算，从根本上规避了二进制浮点数表示的精度问题。虽然使用
decimal模块会带来一些性能开销，但对于对精度有严格要求的应用来说，这是值得的。
