Python浮点数精度问题排查：四种解决方法和金融计算最佳实践

脚本专家

在Python开发中，0.1 + 0.2 的结果是 0.30000000000000004 而不是 0.3，这并非Python的bug，而是所有采用IEEE 754双精度浮点数标准的编程语言（JavaScript、Java、C++等）共有的特性。本文将从浮点数精度问题的根源入手，总结四种成熟的解决方案，并给出金融计算、科学计算等场景的最佳实践。

一、精度问题的根源
计算机使用二进制存储数字，而十进制的0.1在二进制中是无限循环小数：0.0001100110011...（循环节0011）。由于float类型基于64位存储（有效数字约53位），只能截断近似表示。验证如下：

2. import decimal
3. print(decimal.Decimal(0.1))
4. # 输出：0.1000000000000000055511151231257827021181583404541015625

复制代码

能被精确表示的十进制小数，其分母必须是2的幂次方，例如0.5（1/2）、0.25（1/4）、0.125（1/8）。而0.1、0.2、0.3分母含有因子5，无法精确表示。

二、四种解决方案
方案1：使用 math.isclose() 进行容差比较
永远不要用 == 直接比较浮点数，应使用相对容差或绝对容差。Python 3.5+ 提供了 math.isclose()：

2. import math
3. a = 0.1 + 0.2
4. b = 0.3
5. print(math.isclose(a, b, rel_tol=1e-9))  # True
7. # 自定义容差函数（原理相同）
8. def is_close(a, b, rel_tol=1e-9, abs_tol=1e-12):
9.     return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

复制代码

rel_tol为相对容差（默认1e-9），abs_tol为绝对容差（默认0.0）。此方案适合科学计算、图形渲染等不需要绝对精确的场景。

方案2：使用 Decimal 精确小数
Decimal 可以精确表示十进制小数，但必须从字符串创建，而非float：

2. from decimal import Decimal, getcontext
4. # 正确做法：从字符串创建
5. a = Decimal('0.1')
6. b = Decimal('0.2')
7. print(a + b)  # 0.3
8. print(a + b == Decimal('0.3'))  # True
10. # 设置全局精度
11. getcontext().prec = 50
12. print(Decimal('1') / Decimal('7'))  # 0.142857...（50位）

复制代码

注意：Decimal(0.1) 会先把float转成近似值再创建，导致精度丢失。Decimal运算速度比float慢，适合金融、会计等需要精确计算金额的场景。

方案3：使用 Fraction 分数
Fraction 以有理数形式存储，运算始终精确：

2. from fractions import Fraction
3. a = Fraction(1, 3)
4. b = Fraction('0.25')  # 自动转为1/4
5. print(a + b)  # 7/12
6. print(Fraction('0.1') + Fraction('0.2'))  # 3/10
8. # 转回浮点数
9. print(float(Fraction('0.1') + Fraction('0.2')))  # 0.3

复制代码

Fraction适合有理数运算，但大量运算时性能较差。

方案4：用整数代替小数（金融系统常用）
将所有金额以最小单位（如分）的整数存储，仅在显示时转换：

2. class Money:
3.     def __init__(self, amount_cents):
4.         self.cents = amount_cents
6.     @classmethod
7.     def from_yuan(cls, yuan):
8.         return cls(round(yuan * 100))
10.     def to_yuan(self):
11.         return self.cents / 100
13.     def __add__(self, other):
14.         return Money(self.cents + other.cents)
16.     def __str__(self):
17.         return f'¥{self.cents / 100:.2f}'
19. price = Money.from_yuan(9.99)
20. tax = Money.from_yuan(0.60)
21. total = price + tax
22. print(total)  # ¥10.59

复制代码

三、浮点数的特殊值处理
正无穷大、负无穷大和NaN（Not a Number）在运算中可能产生，需使用 math.isinf() 和 math.isnan() 判断：

2. import math
3. inf = float('inf')
4. nan = float('nan')
5. print(math.isinf(inf))  # True
6. print(math.isnan(nan))  # True
8. # NaN的特殊性：与自己不相等
9. print(nan == nan)  # False

复制代码

四、浮点数格式化输出
使用f-string控制小数位数、千分位分隔等：

2. pi = 3.141592653589793
3. print(f'{pi:.2f}')        # 3.14
4. print(f'{pi:10.3f}')      # '     3.142'（右对齐，总宽10）
5. print(f'{rate:.1%}')      # 85.7%（rate=0.8567）
6. print(f'{123456789.0:,.2f}')  # 123,456,789.00

复制代码

五、实际开发最佳实践
- 金融计算：优先使用 Decimal 或整数（分/厘），搭配 ROUND_HALF_UP 四舍五入。
- 科学计算：float 足够，但比较时使用 math.isclose()。
- 大数据量金额：全部以整数存储，避免 Decimal 性能开销。

总结：浮点数精度问题并非Python独有，理解其二进制表示原理后，应根据场景选择合适方案：比较用 isclose，精确计算用 Decimal 或 Fraction，金融系统用整数。掌握这些技巧，可以避免大多数浮点数陷阱。

热心网友1

感谢楼主的详细总结！这些方案非常实用，特别是从根源上解释了为什么0.1+0.2不等于0.3，而不是单纯告诉我们要用Decimal。我之前在金融项目中用过Decimal，但确实要注意从字符串创建，否则还是会有精度问题。另外，楼主提到的用整数代替小数做金额计算——这个思路在需要高性能的场景下确实比Decimal更省资源，而且能避免舍入误差的累积。关于math.isclose的容差参数设置，有没有推荐的通用经验值？还是需要根据具体业务精度要求来调整？