浮点数

误差

• 大部分十进制的小数，都不能准确转换成二进制，存在误差。

  • 因为转换成二进制时，可能得到一个无限长度的小数。但计算机只能存储有限长度的数字，多余的位数会被丢弃，导致误差。

• 例：编写一个函数法，将十进制的小数，转换成二进制

  def float_to_binary(x, precision=16):
      # 如果 x 为负数，则转换成正数，再处理
      prefix = '+'
      if x < 0:
          x = -x
          prefix = '-'
  
      # 提取 x 的整数部分
      integer_part = int(x)
      # 整数部分可以直接转换成二进制，没有误差
      binary_integer_part = bin(integer_part)
  
      # 提取 x 的小数部分
      fractional_part = x - int(x)
      # 第 n 次循环，将十进制小数乘以 2 ，此时个位数取值为 0 或 1 ，将这个值记作第 n 位二进制小数
      binary_fractional_part = ''
      while precision > 0 and fractional_part > 0:
          fractional_part *= 2
          bit = int(fractional_part)
          binary_fractional_part += str(bit)
          fractional_part -= bit    # 去掉个位数，进入下一次循环
          precision -= 1
  
      return prefix + binary_integer_part + '.' + binary_fractional_part
  

  • 转换的示例：

    >>> float_to_binary(0.1)  # 十进制的 0.1 ，转换成二进制之后，是一个无限循环小数
    '+0b0.0001100110011001'
    >>> float_to_binary(0.2)
    '+0b0.0011001100110011'
    >>> float_to_binary(0.3)
    '+0b0.0100110011001100'
    >>> float_to_binary(0.4)
    '+0b0.0110011001100110'
    >>> float_to_binary(0.5)
    '+0b0.1'
    

  • 可见，如果 x 反复乘以 2 之后，依然存在小数部分，则说明 x 不能准确转换成二进制。

• 因此，即使浮点数的小数部分不超过 16 位，存储为 float 类型的对象时，也会存在很小的误差。例如：

  >>> 0.1 + 0.2
  0.30000000000000004
  >>> 0.1 * 3
  0.30000000000000004
  

• 因此，如果想对浮点数进行精确的数学运算，可以将它乘以 10^n ，转换为 int 类型的对象。等到显示时，才转换成 float 类型。

  >>> ratio = 10
  >>> a = 0.1
  >>> a = int(a*ratio)
  >>> a
  1
  >>> print(a/ratio)
  0.1
  

  或者使用 decimal 等模块进行精确运算。

import decimal

：Python 的标准库，用于存储高精度的浮点数。

• 官方文档 (opens new window)

用法

• 使用 decimal.Decimal 对象可以存储高精度的浮点数。

  >>> from decimal import Decimal
  >>> Decimal(-10)
  Decimal('-10')
  >>> Decimal('3.14')       # 输入可以是 int 或 str 类型的数值
  Decimal('3.14')
  >>> Decimal(3.14)         # 将 float 对象直接转换成 Decimal 会有误差，这里应该改为 Decimal(str(3.14))
  Decimal('3.140000000000000124344978758017532527446746826171875')
  >>> str(Decimal('3.14'))  # Decimal 对象可以直接转换成字符串
  '3.14'
  

• Decimal、int 对象之间可以直接进行运算，结果会返回一个 Decimal 对象。

  >>> Decimal('0.1') + Decimal('0.2')
  Decimal('0.3')
  >>> Decimal('0.1') + 0.2        # Decimal、float 对象之间不能进行运算
  TypeError: unsupported operand type(s) for +: 'decimal.Decimal' and 'float'
  >>> Decimal('0.1') + 2
  Decimal('2.1')
  >>> 0 / Decimal('0.1')          # 被除数为 0 时，结果为 0
  Decimal('0E+1')
  >>> Decimal('0.1') / 0          # 除数为 0 时，抛出异常
  decimal.DivisionByZero: [<class 'decimal.DivisionByZero'>]
  >>> Decimal('3.14') < 3.14
  True
  

• Decimal 对象的有效位数默认为 28 。

  >>> from decimal import Decimal, getcontext
  >>> getcontext().prec
  28
  >>> getcontext().prec = 4       # 设置有效位数
  >>> Decimal('0.1') / 3
  Decimal('0.03333')
  >>> Decimal('0.1234567') / 1    # 超出有效位数时，会自动四舍五入
  Decimal('0.1235')
  

import fractions

：Python 的标准库，用于以分数的形式进行数学运算。

• 官方文档 (opens new window)
• 优点：
  • float 在存储时存在微小误差，而分数没有误差。
  • 一个很长的浮点数，对应的分数可能很短，方便供人查看。

用法

• 例：创建 Fraction 对象

  >>> from fractions import Fraction
  >>> a = Fraction(1, 3)  # 输入分子、分母，创建一个 Fraction 对象
  >>> a
  Fraction(1, 3)
  >>> a.numerator         # 查看分子
  1
  >>> a.denominator       # 查看分母
  3
  >>> a.numerator = 2     # Fraction 对象是只读的，不允许修改
  AttributeError: can't set attribute
  >>> str(a)              # 转换成 str 类型
  '1/3'
  >>> float(a)            # 转换成 float 类型
  0.3333333333333333
  >>> int(a)              # 转换成 int 类型，这不会四舍五入，而是只保留 float 的整数部分
  0
  

  • 分子、分母必须都是 int 类型，否则抛出异常：

    >>> Fraction(1, 1.5)
    TypeError: both arguments should be Rational instances
    

  • 创建一个 Fraction 对象时，会自动进行约分，将分子、分母同时除以公约数。

    >>> Fraction(2, 2)
    Fraction(1, 1)
    >>> Fraction(4, 2)
    Fraction(2, 1)
    >>> Fraction(1, -2)     # 如果分母带有负号，则自动改为分子带负号
    Fraction(-1, 2)
    

  • 也可以通过其它方式，创建 Fraction 对象：

    >>> Fraction(0.3333)    # 输入一个 float 类型的数字
    Fraction(6004199023210345, 18014398509481984)
    >>> Fraction('0.3333')  # 输入一个 str 类型的浮点数
    Fraction(3333, 10000)
    >>> Fraction('1/3')     # 输入一个 str 类型的分数
    Fraction(1, 3)
    

• 调用 Fraction.limit_denominator() 方法，可以限制分母的最大值：

  >>> Fraction(0.3333)
  Fraction(6004199023210345, 18014398509481984)
  >>> _.limit_denominator(100)  # 这会返回一个新的 Fraction 对象，取值接近 0.3333 ，但是分母不超过 100
  Fraction(1, 3)
  >>> _.limit_denominator(3)
  Fraction(0, 1)
  >>> _.limit_denominator(2)    # 如果分母的取值太小，则取值可能远离 0.3333
  Fraction(1, 2)
  >>> _.limit_denominator(1)    # 这里取值变成 0/1=0
  Fraction(0, 1)
  >>> _.limit_denominator(0)
  ValueError: max_denominator should be at least 1
  

• 两个 Fraction 对象之间，可以进行算术运算：

  >>> Fraction(1, 2) + Fraction(1, 3)
  Fraction(5, 6)
  >>> Fraction(1, 2) * Fraction(1, 3)
  Fraction(1, 6)