方法一：
|
1
2
3
4
5
6
7
8
9
|
a = 12.12300 #结果要求为12.123
b = 12.00 #结果为12
c = 200.12000 #结果为200.12
d = 200.0 #结果为200
print 'a==>' ,[ str (a), int (a)][ int (a) = = a]
print 'b==>' ,[ str (b), int (b)][ int (b) = = b]
print 'c==>' ,[ str (c), int (c)][ int (c) = = c]
print 'd==>' ,[ str (d), int (d)][ int (d) = = d]
|
方法二：
|
1
2
|
for i in [ 12.12300 , 12.00 , 200.12000 , 200.0 ]:
print ( '{:g}' . format (i))
|
补充：Python 只有1%的程序员搞懂过浮点数陷阱
稍有标题党味道，但内容纯干货，先从一个例子说起
|
1
2
|
>>> 0.1+0.2==0.3
False
|
当你第一次看到这个结果时可能会非常惊讶，原来还有个这么大的bug，再来看看表达式 0.1+0.2 到底等于多少？
|
1
2
|
>>> 0.1+0.2
0.30000000000000004
|
完全超出我们的想象。那么这个操作在计算机里面到底发生了什么事情？
我们还是回到二进制。
首先，需要明确一点，在计算机中无论是整数、浮点数、还是字符串最终都是用二进制来表示的。
整数的二进制表示法
整数 9 在计算机中二进制表示是： 1001 ，怎么得来的？
用十进制整数整除以2，得到商和余数，该余数就是二进制数的最低位，然后继续用商整除以2，得到新的商和余数，以此类推，直到商等于0，由所有余数倒排组成了该整数的二进制表现形式。用代码表示是：
|
1
2
3
4
5
6
7
8
|
>>> n = 9
>>> while n >0:
n,e = divmod(n, 2) # divmod返回n除以2的商和余数
print(e)
1 # 低位
0
0
1 # 高位
|
二进制转化为十进制整数
我们知道，十进制用科学计算法可表示为：
|
1
2
3
|
123 = 1*10^2 + 2*10^1 + 3*10^0
= 100 + 20 + 3
= 123
|
同样的道理，如果是二进制数，可表示：
|
1
2
3
|
1001 = 1*2^3 + 0*2^2 +0*2^1 + 1*2^0
= 8+0+0+1
= 9
|
再来看浮点数
浮点数的二进制表示法
二进制小数和二进制整数没什么区别，都是由0和1组成，只是多了一个点，例如：101.11 就是一个二进制小数，对应的十进制数是：
|
1
2
3
4
|
101.11 = 1*2^2 + 0*2^1 + 1*2^0 + 1*2^-1 + 1* 2^-2
= 4 + 0 + 1 + 1/2 + 1/4
= 5 + 0.5 + 0.25
= 5.75
|
小数点左边用 2^n 表示，小数点右边的值用 2^-n来表示。
浮点数转换成二进制小数
十进制的浮点数转换成二进制小数的步骤：
小数点前面的整数部分按照十进制转二进制的方式操作
小数部分乘以2，取整数0或者1，剩下的小数继续乘2一直重复，直到小数部分为0或达到指定的精度为止
例如 2.25 转换成二进制小数,整数2转换为二进制是 10， 小数部分0.25转换二进制是：
|
1
2
|
0.25 * 2 = 0.5 整数为0，小数为0.5
0.5 * 2 = 1.0 整数为1，小数为0
|
所以 2.25 表示成二进制小数是 10.01 ， 但并不是每一个浮点数都这么幸运最后乘2小数为0的，比如 0.2 转换成二进制是：
|
1
2
3
4
5
6
7
8
|
0.2*2 = 0.4 整数为0，小数为0.4
0.4*2 = 0.8 整数为0，小数为0.8
0.8*2 = 1.6 整数为1，小数为0.6
0.6*2 = 1.2 整数为1，小数为0.2
0.2*2 = 0.4 整数为0，小数为0.4
0.4*2 = 0.8 整数为0，小数为0.8
0.8*2 = 1.6 整数为1，小数为0.6
0.6*2 = 1.2 整数为1，小数为0.2
|
一直重复 ....
0.2 用二进制表示是 0.001100110011… ，你会发现 0.2 根本没法用二进制来精确表示。就像 1/3 无法用小数精确表示一样，只能取一个近似值。
如果把这个二进制小数 0.001100110011 转换回10进制是：
|
1
2
3
|
0.001100110011 = 1*2^-3 + 1* 2^-4 + 1* 2^-7 + 1* 2^-8 + 1* 2^-11 + 1* 2^-12
= 1/8 + 1/16 +1/128 + 1/256 + 1/2048 + 1/4096
= 0.199951171875
|
这只是一个接近 0.2 的数，精度越高就越靠近 0.2， 但永远不可能等于0.2。那么在计算机内部，浮点数到底怎么存储的呢？
根据国际标准IEEE 754，一个二进制浮点数 V 分为3部分，可以用下面这个公式来表示：
s表示符号位，当s=0，V为正数；
当s=1，V为负数
M表示有效数字， 1<=M<2
E表示指数位
例如十进制1.25，写成二进制是1.01，用该公式表示相当于 1.01×2^0。可以得出s=0，M=1.01，E=0。
IEEE 754规定
1、对于32位的浮点数，最高位是符号位s，接着的8位是指数E，剩下的23位为有效数字M。
2、对于64位的浮点数，最高的1位是符号位S，接着的11位是指数E，剩下的52位为有效数字M
3、M的第一位总是1，会被舍去，比如保存1.01的时候，实际上只保存小数点后面的01部分
4、E的真实值必须再减去一个中间数，对于8位的E，这个中间数是127；对于11位的E，这个中间数是1023。
基于以上规则，我们可以对浮点数进行验证，可以用下面这个函数查看一个浮点数在计算机中实际存储的值：
|
1
2
3
4
5
6
7
8
9
|
import struct
def float_to_bits(f):
s = struct.pack('>f', f)
return struct.unpack('>l', s)[0]
>>>print(float_to_bits(0.2))
1045220557
print(bin(float_to_bits(0.2)))
0b111110010011001100110011001101
|
浮点数 0.2 实际存储的值是 1045220557，对应的二进制是 111110010011001100110011001101，转换成32位整数还要在前面补2个0，最后变成：
|
1
|
0 01111100 10011001100110011001101
|
最高位为0，所以表示正数，接着8位 01111100 是指数位E，对应整数是124，根据IEEE 754规定，E的真实值要减去127，所以E=-3，最后23为是M的值，因为前面省略了一位，所以M的真实值是：
|
1
|
1.10011001100110011001101
|
最后V的值就是：
|
1
2
3
4
5
6
7
|
1.10011001100110011001101*2^-3
=
0.00110011001100110011001101
=
1/8 + 1/16 +1/128 + 1/256 + 1/2048 + 1/4096 + ...
=
0.20000000298023224
|
它的实际值比 0.2 要大一点点，所以才看到了最开始的那一幕。
以上为个人经验，希望能给大家一个参考，也希望大家多多支持服务器之家。如有错误或未考虑完全的地方，望不吝赐教。
原文链接：https://blog.csdn.net/woddle/article/details/78497289