总结Python各种ROUND方式

Round的英文含义，就有舍入的意思，最典型的就对浮点数的四舍五入。其实，还存在多种不同的Round方式，本文总结Python支持的浮点数的各种舍入方式。

这里ROUND DOWN的含义，是向0的方向舍入，取满足小数点后位数的需要后，最靠近0的那个数。从数轴上来看，就是向中心的0点靠近。（ Round towards Zero. ）

在python中，int()函数对小数的取整，就是采用的ROUND DOWN方式：

>>> int(1.2)
1
>>> int(1.9)
1
>>> int(-1.2)
-1
>>> int(-1.9)
-1

int函数虽然使用ROUND DOWN方式，但是是取整，去掉了小数部分，得到的结果是integer。如果你的需求是要保留小数点后几位，就要使用decimal模块的接口：

>>> from decimal import *
>>> Decimal('1.2222').quantize(Decimal('.00'), rounding=ROUND_DOWN)
Decimal('1.22')
>>> Decimal('1.9999').quantize(Decimal('.00'), rounding=ROUND_DOWN)
Decimal('1.99')
>>> Decimal('-1.2222').quantize(Decimal('.00'), rounding=ROUND_DOWN)
Decimal('-1.22')
>>> Decimal('-1.9999').quantize(Decimal('.00'), rounding=ROUND_DOWN)
Decimal('-1.99')

注意一个细节：在python代码中写1.2这样的小数，注意1.2的计算机浮点数表示，1.2只是这个浮点数的近似值，1.2的值并不是真的小数1.2，而是下面这个数：

>>> Decimal(1.2)
Decimal('1.1999999999999999555910790149937383830547332763671875')
>>> Decimal('1.2')  # decimal number
Decimal('1.2')

C语言中的整数除操作（取商），就如同python的int()函数一样：

$ cat test_int.c
#include <stdio.h>


int main(void) {
    int a = 5/2;
    int b = -5/2;
    printf("a=%d\n", a);
    printf("b=%d\n", b);
    return 0;
}
$ gcc test_int.c
$ ./a.out
a=2
b=-2

ROUND FLOOR

floor是地板的意思，ROUND FLOOR的意思，就是向下舍入，下的方向，在数轴上是向着负无穷的方向。（ Round towards -Infinity. ）

Python的 // 符号，做的计算，就是ROUND FLOOR，如果有float参与//运算，结果就是float：

>>> 3//2
1
>>> 7//2
3
>>> 7//-2
-4
>>> -3//2
-2
>>> 7//2.1
3.0
>>> 7.1//2
3.0
>>> 7.1//2.1
3.0

如果您的需求要保留几位小数，同样需要使用decimal模块的接口：

>>> Decimal('1.2222').quantize(Decimal('.00'), rounding=ROUND_FLOOR)
Decimal('1.22')
>>> Decimal('1.9999').quantize(Decimal('.00'), rounding=ROUND_FLOOR)
Decimal('1.99')
>>> Decimal('-1.2222').quantize(Decimal('.00'), rounding=ROUND_FLOOR)
Decimal('-1.23')
>>> Decimal('-1.9999').quantize(Decimal('.00'), rounding=ROUND_FLOOR)
Decimal('-2.00')

右移也是round floor，但需特别注意，对于负数除2的幂次，不能使用移位来实现，移位得到的结果是round floor，但正确的结果需要round to zero，如下：

>>> -9 >> 1
-5
>>> -9 // 2
-5
>>> int(-9/2)
-4

ROUND HALF EVEN

ROUND HALF EVEN也被称为银行家舍入法，这种舍入方法的规则是：如果数字与两边（相同位数）的数字相等，就向偶数方向舍入，如果不相等，就是就近舍入。（ Round to nearest with ties going to nearest even integer. ）

Python内置的round函数，采用的就是ROUND HALF EVEN舍入方法（清楚了哈，round函数不是在做四舍五入）：

>>> round(1.2222,0)
1.0
>>> round(1.9999,0)
2.0
>>> round(1.265,2)
1.26
>>> round(1.275,2)  # round 1.275 in float format
1.27
>>> round(1.285,2)
1.28
>>> round(1.235,2)
1.24
>>> round(-1.235,2)
-1.24
>>> round(-1.265,2)
-1.26
>>> round(-1.285,2)
-1.28

round函数只能对浮点数（写出来的1.2不是真的1.2，见上文）进行ROUND HALF EVEN舍入，decimal模块的接口就是对真的小数进行舍入：

>>> Decimal('1.265').quantize(Decimal('.00'), rounding=ROUND_HALF_EVEN)
Decimal('1.26')
>>> Decimal('1.275').quantize(Decimal('.00'), rounding=ROUND_HALF_EVEN)
Decimal('1.28')
>>> Decimal('1.235').quantize(Decimal('.00'), rounding=ROUND_HALF_EVEN)
Decimal('1.24')
>>> Decimal('-1.265').quantize(Decimal('.00'), rounding=ROUND_HALF_EVEN)
Decimal('-1.26')
>>> Decimal('-1.275').quantize(Decimal('.00'), rounding=ROUND_HALF_EVEN)
Decimal('-1.28')
>>> Decimal('-1.235').quantize(Decimal('.00'), rounding=ROUND_HALF_EVEN)
Decimal('-1.24')

round函数的第2个参数，可以取负值，表示在某个整数位上进行round：

>>> round(123456.78, -1)
123460.0
>>> round(123456.78, -2)
123500.0
>>> round(123456.78, -3)
123000.0

IEEE754定义的浮点数规范，里面定义了4种浮点数的舍入方式，默认就是这样！这种round-to-even舍入的本质，是在满足达到两端距离相等时，将least significant digit/bit取even值，即取0。这就是为什么round接口要默认采用这种方式。采用这种舍入法有个好处，在处理大量数据的时候，有些数据可能会往大了的方向舍入，有些数据可能会往小了的方向舍入，综合来看，各占一半，加总时的数据的误差会更加接近真实的值。这也就是为什么这种舍入方式被称为银行家舍入法的原因，帐要尽可能的准确！

ROUND CEILING

从这里开始，后续所有的舍入方法，都只在decimal模块中支持。

ROUND CEILING对应ROUND FLOOR，表示向上舍入，上就是无穷大的方向（ Round towards Infinity. ）：

>>> Decimal('1.234').quantize(Decimal('.00'), rounding=ROUND_CEILING)
Decimal('1.24')
>>> Decimal('-1.234').quantize(Decimal('.00'), rounding=ROUND_CEILING)
Decimal('-1.23')

ROUND UP

ROUND UP对应ROUND DOWN，永远向着远离0的方向舍入（ Round away from zero. ）：

>>> Decimal('1.234').quantize(Decimal('.00'), rounding=ROUND_UP)
Decimal('1.24')
>>> Decimal('-1.234').quantize(Decimal('.00'), rounding=ROUND_UP)
Decimal('-1.24')

ROUND HALF DOWN

就近舍入，如果与两边的数距离相等，向0方向舍入。（ Round to nearest with ties going towards zero. ）

>>> Decimal('1.235').quantize(Decimal('.00'), rounding=ROUND_HALF_DOWN)
Decimal('1.23')
>>> Decimal('-1.235').quantize(Decimal('.00'), rounding=ROUND_HALF_DOWN)
Decimal('-1.23')

ROUND HALF UP

就近舍入，如果与两边的数距离相等，向远离0的方向舍入。（ Round to nearest with ties going away from zero. ）

>>> Decimal('1.235').quantize(Decimal('.00'), rounding=ROUND_HALF_UP)
Decimal('1.24')
>>> Decimal('-1.235').quantize(Decimal('.00'), rounding=ROUND_HALF_UP)
Decimal('-1.24')

>>> Decimal('2.15').quantize(Decimal('.0'), rounding=ROUND_HALF_UP)
Decimal('2.2')
>>> Decimal('3.15').quantize(Decimal('.0'), rounding=ROUND_HALF_UP)
Decimal('3.2')
>>> Decimal('3.14159265').quantize(Decimal('.0000'), rounding=ROUND_HALF_UP)
Decimal('3.1416')
>>> Decimal('3.14159265').quantize(Decimal('.000'), rounding=ROUND_HALF_UP)
Decimal('3.142')
>>> Decimal('3.14159265').quantize(Decimal('.00'), rounding=ROUND_HALF_UP)
Decimal('3.14')
>>> str(Decimal('3.14'))
'3.14'

ROUND 05UP

Round away from zero if last digit after rounding towards zero would have been 0 or 5; otherwise round towards zero. 如果rounding之后，最后的数字是0或5，就向UP方向（远离0的方向）舍入；否则，就像靠近0的方向舍入。

>>> Decimal('1.204').quantize(Decimal('.00'), rounding=ROUND_05UP)
Decimal('1.21')
>>> Decimal('1.254').quantize(Decimal('.00'), rounding=ROUND_05UP)
Decimal('1.26')
>>>
>>> Decimal('1.214').quantize(Decimal('.00'), rounding=ROUND_05UP)
Decimal('1.21')
>>> Decimal('1.274').quantize(Decimal('.00'), rounding=ROUND_05UP)
Decimal('1.27')
>>>
>>> Decimal('-1.204').quantize(Decimal('.00'), rounding=ROUND_05UP)
Decimal('-1.21')
>>> Decimal('-1.254').quantize(Decimal('.00'), rounding=ROUND_05UP)
Decimal('-1.26')
>>>
>>> Decimal('-1.214').quantize(Decimal('.00'), rounding=ROUND_05UP)
Decimal('-1.21')
>>> Decimal('-1.274').quantize(Decimal('.00'), rounding=ROUND_05UP)
Decimal('-1.27')