为什么你需要少看垃圾博客以及如何在Python里精确地四舍五入

╰半夏微凉° 2022-01-20 15:17 123阅读 0赞

今天又有一个Python初学者被中文技术博客中的垃圾文章给误导了。

这位初学者的问题是：

> 在Python中，如何精确地进行浮点数的四舍五入，保留两位小数？

如果你在Google或者百度上搜索，你会发现大量的来自CSDN、百家号、头条号或者简书上面的文章讲到这一点，但是他们的说法无外乎下面几种：

## 连例子都不举的垃圾文章 ##

如下图所示，懒得吐槽。

## 使用round函数 ##

他们举的例子为：

>>> round(1.234, 2)
    1.23
    复制代码

这种文章，他只演示了`四舍`，但是却没有演示`五入`。所以如果你代码稍作修改，就会发现有问题：

>>> round(11.245, 2)
    11.24
    复制代码

## 先放大再缩小 ##

这种文章稍微好一点，知道多举几个例子：

然而这种文章也是漏洞百出，只要你多尝试几个数字就会发现问题，在Python 2和Python 3下面，效果是不一样的。先来看看Python 2下面的运行效果：

在Python 2里面，直接使用`round`，`1.125`精确到两位小数后为`1.13`，而`1.115`精确到两位小数后是`1.11`。

再来看看Python 3下面的效果：

在Python 3下面，`1.125`在精确到两位小数以后是`1.12`。

他举的例子，在Python 3中先放大再缩小，也并不总是正确。

### 装逼货 ###

还有一种装逼货，文章和先放大再缩小差不多，但是他还知道`decimal`这个模块。

不过他的使用方法，大家看他吧

`具体原因不详` ？？？？

`不推荐使用这个方法`？？？

这种人要先装个逼，表示自己知道有这样一个库，但是用起来发现有问题，而且不知道原因，所以不建议大家使用。

decimal是专门为高精度计算用的模块，他竟然说不建议大家使用？？？

## round到底出了什么问题？ ##

骂完了，我们来说说，在Python 3里面，`round`这个内置的函数到底有什么问题。

网上有人说，因为在计算机里面，小数是不精确的，例如`1.115`在计算机中实际上是`1.1149999999999999911182`，所以当你对这个小数精确到小数点后两位的时候，实际上小数点后第三位是`4`，所以四舍五入，因此结果为`1.11`。

这种说法，对了一半。

因为并不是所有的小数在计算机中都是不精确的。例如`0.125`这个小数在计算机中就是精确的，它就是`0.125`，没有省略后面的值，没有近似，它确确实实就是`0.125`。

但是如果我们在Python中把`0.125`精确到小数点后两位，那么它的就会变成`0.12`：

>>> round(0.125, 2)
    0.12
    复制代码

为什么在这里`四舍`了？

还有更奇怪的，另一个在计算机里面能够精确表示的小数`0.375`，我们来看看精确到小数点后两位是多少：

>>> round(0.375, 2)
    0.38
    复制代码

为什么这里又`五入`了？

因为在Python 3里面，`round`对小数的精确度采用了`四舍六入五成双`的方式。

如果你写过大学物理的实验报告，那么你应该会记得老师讲过，直接使用四舍五入，最后的结果可能会偏高。所以需要使用`奇进偶舍`的处理方法。

例如对于一个小数`a.bcd`，需要精确到小数点后两位，那么就要看小数点后第三位：

1.  如果`d`小于5，直接舍去
2.  如果`d`大于5，直接进位
3.  如果`d`等于5：
    
    1.  `d`后面没有数据，且c为`偶数`，那么不进位，保留c
    2.  `d`后面没有数据，且c为`奇数`，那么进位，c变成(c + 1)
    3.  如果`d`后面还有非0数字，例如实际上小数为`a.bcdef`，此时一定要进位，c变成(c + 1)

关于奇进偶舍，有兴趣的同学可以在维基百科搜索这两个词条：`数值修约`和`奇进偶舍`。

所以，`round`给出的结果如果与你设想的不一样，那么你需要考虑两个原因：

1.  你的这个小数在计算机中能不能被精确储存？如果不能，那么它可能并没有达到四舍五入的标准，例如`1.115`，它的小数点后第三位实际上是`4`，当然会被舍去。
2.  如果你的这个小数在计算机中能被精确表示，那么，`round`采用的进位机制是`奇进偶舍`，所以这取决于你要保留的那一位，它是奇数还是偶数，以及它的下一位后面还有没有数据。

## 如何正确进行四舍五入 ##

如果要实现我们数学上的四舍五入，那么就需要使用decimal模块。

如何正确使用decimal模块呢？

看官方文档，不要看中文垃圾博客！！！

不要担心看不懂英文，Python已经推出了官方中文文档（有些函数的使用方法还没有翻译完成）。

我们来看一下：[docs.python.org/zh-cn/3/lib…][docs.python.org_zh-cn_3_lib]

官方文档给出了具体的写法：

>>>Decimal('1.41421356').quantize(Decimal('1.000'))
    Decimal('1.414')
    复制代码

那么我们来测试一下，`0.125`和`0.375`分别保留两位小数是多少：

>>> from decimal import Decimal
    >>> Decimal('0.125').quantize(Decimal('0.00'))
    Decimal('0.12')
    >>> Decimal('0.375').quantize(Decimal('0.00'))
    Decimal('0.38')
    复制代码

怎么结果和`round`一样？我们来看看文档中`quantize`的函数原型和文档说明：

这里提到了可以通过指定`rounding`参数来确定进位方式。如果没有指定`rounding`参数，那么默认使用上下文提供的进位方式。

现在我们来查看一下默认上下文中的进位方式是什么：

>>> from decimal import getcontext
    >>> getcontext().rounding
    'ROUND_HALF_EVEN'
    复制代码

如下图所示：

`ROUND_HALF_EVEN`实际上就是`奇进偶舍`！如果要指定真正的四舍五入，那么我们需要在`quantize`中指定进位方式为`ROUND_HALF_UP`：

>>> from decimal import Decimal, ROUND_HALF_UP
    >>> Decimal('0.375').quantize(Decimal('0.00'), rounding=ROUND_HALF_UP)
    Decimal('0.38')
    >>> Decimal('0.125').quantize(Decimal('0.00'), rounding=ROUND_HALF_UP)
    Decimal('0.13')
    复制代码

现在看起来一切都正常了。

那么会不会有人进一步追问一下，如果Decimal接收的参数不是字符串，而是浮点数会怎么样呢？

来实验一下：

>>> Decimal(0.375).quantize(Decimal('0.00'), rounding=ROUND_HALF_UP)
    Decimal('0.38')
    >>> Decimal(0.125).quantize(Decimal('0.00'), rounding=ROUND_HALF_UP)
    Decimal('0.13')
    复制代码

那是不是说明，在Decimal的第一个参数，可以直接传浮点数呢？

我们换一个数来测试一下：

>>> Decimal(11.245).quantize(Decimal('0.00'), rounding=ROUND_HALF_UP)
    Decimal('11.24')
    >>> Decimal('11.245').quantize(Decimal('0.00'), rounding=ROUND_HALF_UP)
    Decimal('11.25')
    复制代码

为什么浮点数`11.245`和字符串`'11.245'`，传进去以后，结果不一样？

我们继续在文档在寻找答案。

官方文档已经很清楚地说明了，如果你传入的参数为浮点数，并且这个浮点值在计算机里面不能被精确存储，那么它会先被转换为一个不精确的二进制值，然后再把这个不精确的二进制值转换为`等效的十进制值`。

对于不能精确表示的小数，当你传入的时候，Python在拿到这个数前，这个数就已经被转成了一个不精确的数了。所以你虽然参数传入的是`11.245`，但是Python拿到的实际上是`11.244999999999...`。

但是如果你传入的是字符串`'11.245'`，那么Python拿到它的时候，就能知道这是`11.245`，不会提前被转换为一个不精确的值，所以，建议给`Decimal`的第一个参数传入字符串型的浮点数，而不是直接写浮点数。

总结，如果想实现精确的四舍五入，代码应该这样写：

from decimal import Decimal, ROUND_HALF_UP
    
    origin_num = Decimal('11.245')
    answer_num = origin_num.quantize(Decimal('0.00'), rounding=ROUND_HALF_UP)
    print(answer_num)
    复制代码

运行效果如下图所示：

特别注意，一旦要做精确计算，那么就不应该再单独使用浮点数，而是应该总是使用`Decimal('浮点数')`。否则，当你赋值的时候，精度已经被丢失了，建议全程使用Decimal举例：

a = Decimal('0.1')
    b = Decimal('0.2')
    c = a + b
    print(c)
    复制代码

最后，如果有同学想知道为什么0.125和0.375能被精确的储存，而1.115、11.245不能被精确储存，请在这篇文章下面留言，如果想知道的同学多，我就写一篇文章来说明。

最后的最后，如果英文看不懂，中文文档也太枯燥，那么就用掘金吧。掘金的高质量中文文章，比CSDN之流高出一万倍。

如果文章对你有帮助，请考虑关注我的微信公众号：未闻Code（ID：istkingname）

转载于:https://juejin.im/post/5ca046fcf265da30c64ae6b6

[docs.python.org_zh-cn_3_lib]: https://link.juejin.im?target=https%3A%2F%2Fdocs.python.org%2Fzh-cn%2F3%2Flibrary%2Fdecimal.html%23decimal.Decimal.quantize