嘿，作为Python新手碰到浮点精度的坑太正常了！你想通过自定义类来让浮点运算自动舍入的思路完全没问题，咱们先看看你写的代码哪里出了问题，再一步步解决～

原代码的问题分析 #

你的Float类有几个小问题导致运行无效：

• count_decimal_places方法没有绑定实例：作为类里的方法，要么加@staticmethod装饰器，要么第一个参数用self（实例方法），否则调用时会报错。
• 调用方法时没有指定类/实例：直接写count_decimal_places(self)是找不到这个函数的，得用Float.count_decimal_places(self)或者self.count_decimal_places()（如果是实例方法）。
• 未处理非Float类型的操作数：比如你用3 + -1.6，这里3是int，-1.6是普通float，运算时不会触发你的__add__方法，或者计算时需要先把它们转成Float类型。
• 小数位数计算逻辑有漏洞：比如1.0转字符串是"1.0"，会被判定为1位小数，但实际它是整数；另外二进制浮点的字符串表示可能有冗余位数（比如0.1实际是0.10000000000000000555...），这样统计的位数不准确。

修正后的自定义Float类 #

先把你的代码修复，让它能正确运行：

class Float(float):
    @staticmethod
    def count_decimal_places(num):
        # 先处理整数情况
        if isinstance(num, int):
            return 0
        # 转字符串处理，注意处理科学计数法的情况（比如1e-5）
        num_str = str(num)
        if 'e' in num_str.lower():
            exp = int(num_str.split('e')[-1])
            return max(-exp, 0)
        if '.' not in num_str:
            return 0
        decimal_part = num_str.split('.')[1].rstrip('0')  # 去掉末尾的0
        return len(decimal_part) if decimal_part else 0

    def __add__(self, other):
        # 把other转成Float类型，确保统一处理
        other = Float(other)
        # 获取两个数的最大小数位数
        max_decimals = max(self.count_decimal_places(self), self.count_decimal_places(other))
        # 计算后舍入
        result = super().__add__(other)
        return Float(round(result, max_decimals))

    # 还要重载其他运算方法，比如__radd__处理左操作数不是Float的情况
    def __radd__(self, other):
        return self.__add__(other)

测试一下：

print(Float(3) + Float(-1.6))  # 输出1.4
print(3 + Float(-1.6))  # 因为重载了__radd__，也能输出1.4

更灵活的方案：指定固定精度的自定义类 #

如果你想让整个程序里的浮点运算都自动舍入到固定的小数位数（比如2位），可以修改类，让它初始化时指定精度，所有运算都用这个精度：

class PreciseFloat(float):
    def __new__(cls, value, precision=2):
        # 初始化时就先舍入到指定精度
        rounded_val = round(float(value), precision)
        instance = super().__new__(cls, rounded_val)
        instance.precision = precision
        return instance

    def __add__(self, other):
        other = self._convert_to_precise(other)
        result = super().__add__(other)
        return PreciseFloat(result, self.precision)

    def __sub__(self, other):
        other = self._convert_to_precise(other)
        result = super().__sub__(other)
        return PreciseFloat(result, self.precision)

    def __mul__(self, other):
        other = self._convert_to_precise(other)
        result = super().__mul__(other)
        return PreciseFloat(result, self.precision)

    def __truediv__(self, other):
        other = self._convert_to_precise(other)
        result = super().__truediv__(other)
        return PreciseFloat(result, self.precision)

    # 处理反向运算（比如普通int/float和PreciseFloat运算）
    def __radd__(self, other):
        return self.__add__(other)

    def __rsub__(self, other):
        other = self._convert_to_precise(other)
        result = other - self
        return PreciseFloat(result, self.precision)

    def __rmul__(self, other):
        return self.__mul__(other)

    def __rtruediv__(self, other):
        other = self._convert_to_precise(other)
        result = other / self
        return PreciseFloat(result, self.precision)

    def _convert_to_precise(self, value):
        # 把其他类型转成PreciseFloat，用当前实例的精度
        if not isinstance(value, PreciseFloat):
            return PreciseFloat(value, self.precision)
        return value

使用示例：

# 指定精度为1位
a = PreciseFloat(3, precision=1)
b = PreciseFloat(-1.6, precision=1)
print(a + b)  # 输出1.4

# 普通float和它运算也会自动舍入
print(0.1 + PreciseFloat(0.2, precision=1))  # 输出0.3，而不是0.30000000000000004

注意事项 #

• 重载运算方法要全面：除了__add__，你可能还需要重载__sub__、__mul__、__truediv__等，以及对应的反向方法（__radd__、__rsub__等），不然只有当左操作数是你的自定义类时才会触发自定义逻辑。
• 精度选择要谨慎：固定精度适合业务场景（比如金额计算），但如果是科学计算，可能还是用decimal.Decimal更靠谱，因为它能精确表示十进制数，而不是二进制近似。

内容的提问来源于stack exchange，提问作者Anmol Saksena