Python 对浮点数取模

Question

谁能解释模运算符在 Python 中的工作原理？ 我不明白为什么3.5 % 0.1 = 0.1。

Answer 1

实际上，3.5 % 0.1 不是 0.1。您可以很容易地对此进行测试：

>>> print(3.5 % 0.1)
0.1
>>> print(3.5 % 0.1 == 0.1)
False

实际上，在大多数系统上，3.5 % 0.1 是 0.099999999999999811。但是，在某些版本的 Python 中，str(0.099999999999999811) 是 0.1：

>>> 3.5 % 0.1
0.099999999999999811
>>> repr(3.5 % 0.1)
'0.099999999999999811'
>>> str(3.5 % 0.1)
'0.1'

现在，您可能想知道为什么 3.5 % 0.1 是 0.099999999999999811 而不是 0.0。这是因为通常的浮点舍入问题。如果您还没有阅读过What Every Computer Scientist Should Know About Floating-Point Arithmetic，那么您应该阅读——或者至少阅读一下Wikipedia 这个特定问题的简短摘要。

还要注意3.5/0.1 不是34，而是35。所以，3.5/0.1 * 0.1 + 3.5%0.1 是3.5999999999999996，甚至与3.5 都不接近。这对于模数的定义非常重要，但在 Python 和几乎所有其他编程语言中都是错误的。

但是 Python 3 来拯救那里。大多数了解// 的人都知道这是在整数之间进行“整数除法”的方式，但没有意识到这是在任何 类型之间进行模数兼容除法的方式。 3.5//0.1 是 34.0，所以 3.5//0.1 * 0.1 + 3.5%0.1 是（至少在一个小的舍入误差范围内）3.5。这已被向后移植到 2.x，因此（取决于您的确切版本和平台）您可以依赖它。如果没有，您可以使用divmod(3.5, 0.1)，它返回（在舍入误差内）(34.0, 0.09999999999999981) 一直回到时间的迷雾中。当然，您仍然希望这是 (35.0, 0.0)，而不是 (34.0, almost-0.1)，但由于舍入错误，您不能拥有它。

如果您正在寻找快速解决方案，请考虑使用 Decimal 类型：

>>> from decimal import Decimal
>>> Decimal('3.5') % Decimal('0.1')
Decimal('0.0')
>>> print(Decimal('3.5') % Decimal('0.1'))
0.0
>>> (Decimal(7)/2) % (Decimal(1)/10)
Decimal('0.0')

这不是灵丹妙药——例如，当运算的确切值不能以 10 为基数有限表示时，您仍然需要处理舍入误差——但舍入误差更符合情况人类的直觉预计会有问题。 （Decimal 与float 相比也有优势，因为您可以指定显式精度、跟踪有效数字等，并且它实际上在从 2.4 到 3.3 的所有 Python 版本中都是相同的，而有关 float 的详细信息在同一时间更改了两次。只是它并不完美，因为那是不可能的。）但是当您事先知道您的数字都可以精确地以 10 为基数表示时，它们不需要比精度更多的数字你已经配置好了，它会工作的。

Answer 2

Modulo 为您提供一个部门的rest。 3.5 除以0.1 应该给你35 和0 的其余部分。但由于浮点数基于 2 的幂，因此数字并不精确，并且会出现舍入错误。

如果您需要对十进制数字进行精确除法，请使用十进制模块：

>>> from decimal import Decimal
>>> Decimal('3.5') / Decimal('0.1')
Decimal('35')
>>> Decimal('3.5') % Decimal('0.1')
Decimal('0.0')

---

当我被抨击我的回答具有误导性时，整个故事就来了：

Python float 0.1 略大于十分之一：

>>> '%.50f' % 0.1
'0.10000000000000000555111512312578270211815834045410'

如果你将浮点数 3.5 除以这个数字，你得到的几乎是 0.1。

让我们从数字0.11 开始，继续在两个1 数字之间添加零，以使其更小，同时保持大于0.1。

>>> '%.10f' % (3.5 % 0.101)
'0.0660000000'
>>> '%.10f' % (3.5 % 0.1001)
'0.0966000000'
>>> '%.10f' % (3.5 % 0.10001)
'0.0996600000'
>>> '%.10f' % (3.5 % 0.100001)
'0.0999660000'
>>> '%.10f' % (3.5 % 0.1000001)
'0.0999966000'
>>> '%.10f' % (3.5 % 0.10000001)
'0.0999996600'
>>> '%.10f' % (3.5 % 0.100000001)
'0.0999999660'
>>> '%.10f' % (3.5 % 0.1000000001)
'0.0999999966'
>>> '%.10f' % (3.5 % 0.10000000001)
'0.0999999997'
>>> '%.10f' % (3.5 % 0.100000000001)
'0.1000000000'

最后一行给人的印象是我们终于到达了0.1，但更改格式字符串揭示了真正的本质：

>>> '%.20f' % (3.5 % 0.100000000001)
'0.09999999996600009156'

python 的默认浮点格式根本没有显示足够的精度，因此 3.5 % 0.1 = 0.1 和 3.5 % 0.1 = 35.0.真的是3.5 % 0.100000... = 0.999999... 和3.5 / 0.100000... = 34.999999....。在除法的情况下，您甚至会得到 exact 结果，因为 34.9999... 最终会四舍五入到 35.0。

---

有趣的事实：如果您使用一个比0.1 稍小的数字并执行相同的操作，您最终会得到一个比0 稍大的数字：

>>> 1.0 - 0.9
0.09999999999999998
>>> 35.0 % (1.0 - 0.9)
7.771561172376096e-15
>>> '%.20f' % (35.0 % (1.0 - 0.9))
'0.00000000000000777156'

---

使用 C++，您甚至可以证明 3.5 除以浮点数 0.1 不是 35，而是更小一些。

#include <iostream>
#include <iomanip>

int main(int argc, char *argv[]) {
    // double/float, rounding errors do not cancel out
    std::cout << "double/float: " << std::setprecision(20) << 3.5 / 0.1f << std::endl;
    // double/double, rounding errors cancel out
    std::cout << "double/double: " << std::setprecision(20) << 3.5 / 0.1 << std::endl;
    return 0;
}

http://ideone.com/fTNVho

在 Python 中，3.5 / 0.1 为您提供了 35 的确切结果，因为舍入误差相互抵消。真的是3.5 / 0.100000... = 34.9999999...。而34.9999... 最终会很长，以至于你最终得到的正是35。 C++ 程序很好地展示了这一点，因为您可以混合使用 double 和 float 并使用浮点数的精度。

Answer 3

这与浮点运算的不精确性有关。 3.5 % 0.1 得到我0.099999999999999811，所以 Python 认为 0.1 最多可以分为 3.5 34 次，剩下 0.099999999999999811。我不确定究竟使用了什么算法来实现这个结果，但这就是要点。