这是一个让无数程序员困惑的问题：为什么在Python中0.1 + 0.2不等于0.3？这个问题不仅存在于Python中，几乎所有使用IEEE 754浮点数标准的编程语言都有这个问题。理解这个问题的根源，对于写出正确的数值计算代码至关重大。

问题演示

# 经典的浮点数精度问题
print(0.1 + 0.2)  # 0.30000000000000004
print(0.1 + 0.2 == 0.3)  # False

# 更多例子
print(0.1 + 0.1 + 0.1)  # 0.30000000000000004
print(0.1 + 0.1 + 0.1 == 0.3)  # False

# 看起来正常的例子
print(0.5 + 0.5)  # 1.0
print(0.25 + 0.25)  # 0.5

为什么会这样？

这个问题的根源在于计算机如何表明浮点数。计算机使用二进制来表明数字，但许多十进制小数无法准确地用二进制表明。

十进制转二进制的例子

# 让我们看看一些数字的二进制表明
def decimal_to_binary(decimal, precision=20):
    """将十进制小数转换为二进制"""
    if decimal == 0:
        return "0"
    
    result = []
    for _ in range(precision):
        decimal *= 2
        if decimal >= 1:
            result.append("1")
            decimal -= 1
        else:
            result.append("0")
        
        if decimal == 0:
            break
    
    return "0." + "".join(result)

# 测试
print("0.1 in binary:", decimal_to_binary(0.1))
print("0.2 in binary:", decimal_to_binary(0.2))
print("0.3 in binary:", decimal_to_binary(0.3))

输出会显示0.1和0.2的二进制表明是无限循环的，这就是精度问题的根源。

实际开发中的陷阱

1. 金融计算

# 错误的金融计算
def calculate_total(prices):
    total = 0.0
    for price in prices:
        total += price
    return total

# 测试
prices = [0.1, 0.2, 0.3]
total = calculate_total(prices)
print(f"Total: {total}")  # 0.6000000000000001
print(f"Total == 0.6: {total == 0.6}")  # False

2. 循环条件

# 错误的循环
def count_up():
    x = 0.0
    count = 0
    while x < 1.0:  # 可能永远不会结束
        x += 0.1
        count += 1
        if count > 20:  # 防止无限循环
            break
    return count

print(f"Count: {count_up()}")  # 可能不是期望的10

3. 比较操作

# 错误的比较
def is_equal(a, b):
    return a == b

# 测试
print(is_equal(0.1 + 0.2, 0.3))  # False

# 在条件判断中
if 0.1 + 0.2 == 0.3:
    print("Equal")  # 不会执行
else:
    print("Not equal")  # 会执行

正确的解决方案

方案1：使用epsilon比较

def is_close(a, b, epsilon=1e-9):
    """比较两个浮点数是否接近"""
    return abs(a - b) < epsilon

# 测试
print(is_close(0.1 + 0.2, 0.3))  # True
print(is_close(0.1 + 0.1 + 0.1, 0.3))  # True

方案2：使用math.isclose

import math

# Python 3.5+提供了math.isclose
print(math.isclose(0.1 + 0.2, 0.3))  # True
print(math.isclose(0.1 + 0.1 + 0.1, 0.3))  # True

# 可以自定义相对和绝对容差
print(math.isclose(0.1 + 0.2, 0.3, rel_tol=1e-9, abs_tol=1e-9))  # True

方案3：使用decimal模块

from decimal import Decimal, getcontext

# 设置精度
getcontext().prec = 28

# 使用Decimal进行准确计算
a = Decimal('0.1')
b = Decimal('0.2')
c = Decimal('0.3')

print(a + b)  # 0.3
print(a + b == c)  # True

# 金融计算示例
def calculate_total_precise(prices):
    total = Decimal('0')
    for price in prices:
        total += Decimal(str(price))
    return total

prices = [0.1, 0.2, 0.3]
total = calculate_total_precise(prices)
print(f"Precise total: {total}")  # 0.6

方案4：使用fractions模块

from fractions import Fraction

# 使用分数进行准确计算
a = Fraction(1, 10)  # 0.1
b = Fraction(2, 10)  # 0.2
c = Fraction(3, 10)  # 0.3

print(a + b)  # 3/10
print(float(a + b))  # 0.3
print(a + b == c)  # True

实际应用示例

金融计算系统

from decimal import Decimal, getcontext

class FinancialCalculator:
    def __init__(self, precision=28):
        getcontext().prec = precision
    
    def add(self, a, b):
        return Decimal(str(a)) + Decimal(str(b))
    
    def multiply(self, a, b):
        return Decimal(str(a)) * Decimal(str(b))
    
    def calculate_interest(self, principal, rate, time):
        """计算复利"""
        p = Decimal(str(principal))
        r = Decimal(str(rate))
        t = Decimal(str(time))
        return p * (1 + r) ** t

# 测试
calc = FinancialCalculator()
print(calc.add(0.1, 0.2))  # 0.3
print(calc.calculate_interest(1000, 0.05, 2))  # 1102.5

科学计算

import math

class ScientificCalculator:
    @staticmethod
    def is_equal(a, b, rel_tol=1e-9, abs_tol=1e-9):
        """比较两个浮点数是否相等"""
        return math.isclose(a, b, rel_tol=rel_tol, abs_tol=abs_tol)
    
    @staticmethod
    def safe_divide(a, b):
        """安全除法，避免除零错误"""
        if ScientificCalculator.is_equal(b, 0.0):
            raise ValueError("Division by zero")
        return a / b
    
    @staticmethod
    def calculate_distance(x1, y1, x2, y2):
        """计算两点间距离"""
        dx = x2 - x1
        dy = y2 - y1
        return math.sqrt(dx*dx + dy*dy)

# 测试
calc = ScientificCalculator()
print(calc.is_equal(0.1 + 0.2, 0.3))  # True
print(calc.calculate_distance(0, 0, 3, 4))  # 5.0

游戏开发中的坐标系统

class GamePosition:
    def __init__(self, x, y):
        self.x = float(x)
        self.y = float(y)
    
    def __eq__(self, other):
        """重写相等比较，使用epsilon比较"""
        if not isinstance(other, GamePosition):
            return False
        return (math.isclose(self.x, other.x) and 
                math.isclose(self.y, other.y))
    
    def distance_to(self, other):
        """计算到另一个位置的距离"""
        dx = self.x - other.x
        dy = self.y - other.y
        return math.sqrt(dx*dx + dy*dy)
    
    def __repr__(self):
        return f"GamePosition({self.x}, {self.y})"

# 测试
pos1 = GamePosition(0.1, 0.2)
pos2 = GamePosition(0.1, 0.2)
print(pos1 == pos2)  # True
print(pos1.distance_to(pos2))  # 0.0

性能思考

不同的解决方案有不同的性能特征：

import time

def benchmark_comparisons():
    """比较不同方法的性能"""
    a, b = 0.1, 0.2
    n = 1000000
    
    # 测试math.isclose
    start = time.time()
    for _ in range(n):
        result = math.isclose(a + b, 0.3)
    isclose_time = time.time() - start
    
    # 测试epsilon比较
    start = time.time()
    for _ in range(n):
        result = abs((a + b) - 0.3) < 1e-9
    epsilon_time = time.time() - start
    
    # 测试Decimal
    start = time.time()
    for _ in range(n):
        result = Decimal(str(a)) + Decimal(str(b)) == Decimal('0.3')
    decimal_time = time.time() - start
    
    print(f"math.isclose: {isclose_time:.4f}s")
    print(f"epsilon: {epsilon_time:.4f}s")
    print(f"Decimal: {decimal_time:.4f}s")

benchmark_comparisons()

最佳实践

• 永远不要用==比较浮点数：使用math.isclose或epsilon比较
• 金融计算使用Decimal：确保准确性
• 科学计算使用math.isclose：平衡性能和精度
• 设置合适的容差：根据应用场景选择
• 测试边界情况：确保代码在各种情况下都能工作

调试技巧

def debug_float_precision(a, b):
    """调试浮点数精度问题"""
    print(f"a = {a}")
    print(f"b = {b}")
    print(f"a + b = {a + b}")
    print(f"a + b == 0.3: {a + b == 0.3}")
    print(f"math.isclose(a + b, 0.3): {math.isclose(a + b, 0.3)}")
    print(f"abs((a + b) - 0.3): {abs((a + b) - 0.3)}")
    print(f"repr(a + b): {repr(a + b)}")

# 测试
debug_float_precision(0.1, 0.2)

写在最后

浮点数精度问题是计算机科学中的一个基础问题，理解它对于写出正确的数值计算代码至关重大。记住这些要点：

• 浮点数精度问题是IEEE 754标准的特性，不是bug
• 永远不要用==比较浮点数
• 根据应用场景选择合适的解决方案
• 金融计算用Decimal，科学计算用math.isclose

理解这个问题不仅能帮你避免bug，还能让你更好地理解计算机如何表明和处理数字。