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()
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()
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
模块会带来一些性能开销，但对于对精度有严格要求的应用来说，这是值得的。