方法一：

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]

方法二：

for i in [ 12.12300 , 12.00 , 200.12000 , 200.0 ]:
 print ( '{:g}' . format (i))

補充：Python 只有1%的程序員搞懂過浮點數陷阱

稍有標題黨味道，但內容純干貨，先從一個例子說起

>>> 0.1+0.2==0.3
False

當你第一次看到這個結果時可能會非常驚訝，原來還有個這么大的bug，再來看看表達式 0.1+0.2 到底等于多少？

>>> 0.1+0.2
0.30000000000000004

完全超出我們的想象。那么這個操作在計算機里面到底發生了什么事情？

我們還是回到二進制。

首先，需要明確一點，在計算機中無論是整數、浮點數、還是字符串最終都是用二進制來表示的。

整數的二進制表示法

整數 9 在計算機中二進制表示是： 1001 ，怎么得來的？

用十進制整數整除以2，得到商和余數，該余數就是二進制數的最低位，然后繼續用商整除以2，得到新的商和余數，以此類推，直到商等于0，由所有余數倒排組成了該整數的二進制表現形式。用代碼表示是：

>>> n = 9
>>> while n >0:
  n,e = divmod(n, 2) # divmod返回n除以2的商和余數
  print(e)
1 # 低位
0
0
1 # 高位

二進制轉化為十進制整數

我們知道，十進制用科學計算法可表示為：

123 = 1*10^2 + 2*10^1 + 3*10^0 
= 100 + 20 + 3 
= 123

同樣的道理，如果是二進制數，可表示：

1001 = 1*2^3 + 0*2^2 +0*2^1 + 1*2^0
= 8+0+0+1 
= 9

再來看浮點數

浮點數的二進制表示法

二進制小數和二進制整數沒什么區別，都是由0和1組成，只是多了一個點，例如：101.11 就是一個二進制小數，對應的十進制數是：

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轉換二進制是：

0.25 * 2 = 0.5 整數為0，小數為0.5
0.5 * 2 = 1.0  整數為1，小數為0

所以 2.25 表示成二進制小數是 10.01 ， 但并不是每一個浮點數都這么幸運最后乘2小數為0的，比如 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*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進制是：

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=M2

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。

基于以上規則，我們可以對浮點數進行驗證，可以用下面這個函數查看一個浮點數在計算機中實際存儲的值：

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，最后變成：

0 01111100 10011001100110011001101

最高位為0，所以表示正數，接著8位 01111100 是指數位E，對應整數是124，根據IEEE 754規定，E的真實值要減去127，所以E=-3，最后23為是M的值，因為前面省略了一位，所以M的真實值是：

1.10011001100110011001101

最后V的值就是：

1.10011001100110011001101*2^-3
=
0.00110011001100110011001101
=
1/8 + 1/16 +1/128 + 1/256 + 1/2048 + 1/4096 + ...
=
0.20000000298023224

它的實際值比 0.2 要大一點點，所以才看到了最開始的那一幕。

以上為個人經驗，希望能給大家一個參考，也希望大家多多支持腳本之家。如有錯誤或未考慮完全的地方，望不吝賜教。