我正在遇到round()函数的一种奇怪行为：
for i in range(1, 15, 2):
n = i / 2
print(n, "=>", round(n))
这段代码输出：
0.5 => 0
1.5 => 2
2.5 => 2
3.5 => 4
4.5 => 4
5.5 => 6
6.5 => 6
我原本期望浮点数总是向上取整，但实际上它们被舍入到最接近的偶数。
为什么会出现这种行为，有什么方法可以获得正确的结果?
我尝试使用fractions，但结果仍然相同。
在Numeric Types部分，明确记录了这种行为：
round(x[, n])
将x四舍五入到n位小数，采用“银行家舍入”方式。如果省略n，则默认为0。
请注意“银行家舍入”。这也称为“银行家舍入法”；通过将数字四舍五入至最接近的偶数，而不总是向上或向下舍入（避免累积舍入误差），您可以平均四舍五入误差。
如果需要更多精确地控制舍入行为，请使用decimal模块，该模块允许指定正好使用哪种舍入策略。
例如，要从一半的数字向上舍入：
>>> from decimal import localcontext, Decimal, ROUND_HALF_UP
>>> with localcontext() as ctx:
... ctx.rounding = ROUND_HALF_UP
... for i in range(1, 15, 2):
... n = Decimal(i) / 2
... print(n, '=>', n.to_integral_value())
...
0.5 => 1
1.5 => 2
2.5 => 3
3.5 => 4
4.5 => 5
5.5 => 6
6.5 => 7
rounding 参数更有优势，例如：n.to_integral_value(rounding=ROUND_HALF_UP)？ - dhobbsfrom decimal import Decimal, ROUND_HALF_UP
Decimal(1.5).quantize(0, ROUND_HALF_UP)
# This also works for rounding to the integer part:
Decimal(1.5).to_integral_value(rounding=ROUND_HALF_UP)
你可以使用这个：
import math
def normal_round(n):
if n - math.floor(n) < 0.5:
return math.floor(n)
return math.ceil(n)
它将适当地将数字四舍五入。
round()函数会根据数字的奇偶性进行四舍五入。只想向上取整的一个简单方法是：
int(num + 0.5)
((num > 0) - (num < 0)) * int(abs(num) + 0.5)
注意，对于大数字或非常精确的数字例如5000000000000001.0和0.49999999999999994，这可能会出现问题。
num = -2.4，这个解决方案会给出什么结果？如果 num = 0.49999999999999994 或 num = 5000000000000001.0 呢？在使用 IEEE 754 格式和语义的典型计算机上，这个解决方案对这三种情况都给出了错误的答案。 - Mark Dickinson为什么要搞得这么复杂？（仅适用于正数）
def HalfRoundUp(value):
return int(value + 0.5)
HalfRoundUp = lambda value: int(value + 0.5)
不幸的是，这个简单的答案不能处理负数，但可以通过数学中的floor函数进行修正：（这也适用于正数和负数）
from math import floor
def HalfRoundUp(value):
return floor(value + 0.5)
喜欢fedor2612的回答。我用一个可选的“decimals”参数扩展了它，以便那些想要使用此函数四舍五入任意数量小数的人使用（例如，如果您想将货币 $26.455 四舍五入为 $26.46）。
import math
def normal_round(n, decimals=0):
expoN = n * 10 ** decimals
if abs(expoN) - abs(math.floor(expoN)) < 0.5:
return math.floor(expoN) / 10 ** decimals
return math.ceil(expoN) / 10 ** decimals
oldRounding = round(26.455,2)
newRounding = normal_round(26.455,2)
print(oldRounding)
print(newRounding)
输出:
26.45
26.46
简单来说，使用decimal模块。它可以精确表示像2.675这样的数字，而不像Python中的浮点数，其中2.675实际上是真的2.67499999999999982236431605997495353221893310546875（确切地说）。并且您可以指定所需的舍入方式：ROUND_CEILING、ROUND_DOWN、ROUND_FLOOR、ROUND_HALF_DOWN、ROUND_HALF_EVEN、ROUND_HALF_UP、ROUND_UP和ROUND_05UP都是选项。
由于某些解决方案中的四舍五入有可能在某些情况下无法按预期工作，因此需要进行小幅修改。
例如，使用上述函数：
from decimal import Decimal, ROUND_HALF_UP
def round_half_up(x: float, num_decimals: int) -> float:
if num_decimals < 0:
raise ValueError("Num decimals needs to be at least 0.")
target_precision = "1." + "0" * num_decimals
rounded_x = float(Decimal(x).quantize(Decimal(target_precision), ROUND_HALF_UP))
return rounded_x
round_half_up(1.35, 1)
1.4
round_half_up(4.35, 1)
4.3
我原本期望的是4.4，但对我有用的是先将x转换为字符串。
from decimal import Decimal, ROUND_HALF_UP
def round_half_up(x: float, num_decimals: int) -> float:
if num_decimals < 0:
raise ValueError("Num decimals needs to be at least 0.")
target_precision = "1." + "0" * num_decimals
rounded_x = float(Decimal(str(x)).quantize(Decimal(target_precision), ROUND_HALF_UP))
return rounded_x
round_half_up(4.35, 1)
4.4
这里有另一种解决方案。它将像Excel中的普通四舍五入一样工作。
from decimal import Decimal, getcontext, ROUND_HALF_UP
round_context = getcontext()
round_context.rounding = ROUND_HALF_UP
def c_round(x, digits, precision=5):
tmp = round(Decimal(x), precision)
return float(tmp.__round__(digits))
c_round(0.15, 1) -> 0.2, c_round(0.5, 0) -> 1
round()的行为，但如果您始终想向上舍入，可以使用math.ceil()。 - yurib1.3四舍五入为1，因此不能使用ceil()。 - Delgan5*10**-k的四舍五入取决于它前面的数字。通过将奇数数字向上舍入，偶数数字向下舍入，理论上你会得到一半时间正误差和一半时间偶误差。当进行许多加法运算时，这些误差可以互相抵消。 - StoryTeller - Unslander Monica