1 In [1]: a = 5.026

 2 
 3 In [2]: b = 5.000
 4 
 5 In [3]: round(a,2)
 6 Out[3]: 5.03
 7 
 8 In [4]: round(b,2)
 9 Out[4]: 5.0
10 
11 In [5]: '%.2f' % a
12 Out[5]: '5.03'
13 
14 In [6]: '%.2f' % b
15 Out[6]: '5.00'
16 
17 In [7]: float('%.2f' % a)
18 Out[7]: 5.03
19 
20 In [8]: float('%.2f' % b)
21 Out[8]: 5.0
22 
23 In [9]: from decimal import Decimal
24 
25 In [10]: Decimal('5.026').quantize(Decimal('0.00'))
26 Out[10]: Decimal('5.03')
27 
28 In [11]: Decimal('5.000').quantize(Decimal('0.00'))
29 Out[11]: Decimal('5.00')

这里有三种方法，

round(a,2)

'%.2f' % a

Decimal('5.000').quantize(Decimal('0.00'))

当需要输出的结果要求有两位小数的时候，字符串形式的：'%.2f' % a 方式最好，其次用Decimal。

需要注意的：

1. 可以传递给Decimal整型或者字符串参数，但不能是浮点数据，因为浮点数据本身就不准确。

2. Decimal还可以用来限定数据的总位数。

基础

浮点数是用机器上浮点数的本机双精度(64 bit)表示的。提供大约17位的精度和范围从-308到308的指数。和C语言里面的double类型相同。Python不支持32bit的单精度浮点数。如果程序需要精确控制区间和数字精度，可以考虑使用numpy扩展库。

Python 3.X对于浮点数默认的是提供17位数字的精度。

关于单精度和双精度的通俗解释：

单精度型和双精度型，其类型说明符为float 单精度说明符，double 双精度说明符。在Turbo C中单精度型占4个字节（32位）内存空间，其数值范围为3.4E-38～3.4E+38，只能提供七位有效数字。双精度型占8 个字节（64位）内存空间，其数值范围为1.7E-308～1.7E+308，可提供16位有效数字。

要求较小的精度

将精度高的浮点数转换成精度低的浮点数。

1.round()内置方法

这个是使用最多的，刚看了round()的使用解释，也不是很容易懂。round()不是简单的四舍五入的处理方式。

For the built-in types supporting round(), values are rounded to the closest multiple of 10 to the power minus ndigits; if two multiples are equally close, rounding is done toward the even choice (so, for example, both round(0.5) and round(-0.5) are 0, and round(1.5) is 2).

1 >>> round(2.5)
2 2
3 >>> round(1.5)
4 2
5 >>> round(2.675)
6 3
7 >>> round(2.675, 2)
8 2.67

round()如果只有一个数作为参数，不指定位数的时候，返回的是一个整数，而且是最靠近的整数（这点上类似四舍五入）。但是当出现.5的时候，两边的距离都一样，round()取靠近的偶数，这就是为什么round(2.5) = 2。当指定取舍的小数点位数的时候，一般情况也是使用四舍五入的规则，但是碰到.5的这样情况，如果要取舍的位数前的小数是奇数，则向下取舍，如果偶数则向上取舍。看下面的示例：

 1 >>> round(2.635, 2)
 2 2.63
 3 >>> round(2.645, 2)
 4 2.65
 5 >>> round(2.655, 2)
 6 2.65
 7 >>> round(2.665, 2)
 8 2.67
 9 >>> round(2.675, 2)
10 2.67

 2. 使用格式化

效果和round（）是一样的。

1 >>> a = ("%.2f" % 2.635)
2 >>> a
3 '2.63'
4 >>> a = ("%.2f" % 2.645)
5 >>> a
6 '2.65'
7 >>> a = int(2.5)
8 >>> a
9 2

要求超过17位的精度分析

python默认的是17位小数的精度，但是这里有一个问题，就是当我们的计算需要使用更高的精度（超过17位小数）的时候该怎么做呢？

1. 使用格式化(不推荐)

1 >>> a = "%.30f" % (1/3)
2 >>> a
3 '0.333333333333333314829616256247'

可以显示，但是不准确，后面的数字往往没有意义。

2. 高精度使用decimal模块，配合getcontext

 1 >>> from decimal import *
 2 >>> print(getcontext())
 3 Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
 4 >>> getcontext().prec = 50
 5 >>> b = Decimal(1)/Decimal(3)
 6 >>> b
 7 Decimal('0.33333333333333333333333333333333333333333333333333')
 8 >>> c = Decimal(1)/Decimal(17)
 9 >>> c
10 Decimal('0.058823529411764705882352941176470588235294117647059')
11 >>> float(c)
12 0.058823529411764705

 默认的context的精度是28位，可以设置为50位甚至更高，都可以。这样在分析复杂的浮点数的时候，可以有更高的自己可以控制的精度。其实可以留意下context里面的这rounding=ROUND_HALF_EVEN 参数。ROUND_HALF_EVEN， 当half的时候，靠近even.

关于小数和取整

既然说到小数，就必然要说到整数。一般取整会用到这些函数：

1. round()

这个不说了，前面已经讲过了。一定要注意它不是简单的四舍五入，而是ROUND_HALF_EVEN的策略。

2. math模块的ceil(x)

取大于或者等于x的最小整数。

3. math模块的floor(x)

去小于或者等于x的最大整数。

 1 >>> from math import ceil, floor
 2 >>> round(2.5)
 3 2
 4 >>> ceil(2.5)
 5 3
 6 >>> floor(2.5)
 7 2
 8 >>> round(2.3)
 9 2
10 >>> ceil(2.3)
11 3
12 >>> floor(2.3)
13 2
14 >>>