問題描述
我知道大多數小數都沒有精確的浮點表示(浮點數學有問題嗎?).p>
但我不明白為什么 4*0.1 可以很好地打印為 0.4，但 3*0.1 不是，當這兩個值實際上都有丑陋的十進制表示:
>>>3*0.10.30000000000000004>>>4*0.10.4>>>從十進制導入十進制>>>十進制(3*0.1)十進制('0.30000000000000000444089209850062616169452667236328125')>>>十進制(4*0.1)十進制('0.400000000000000002220446049250313080847263336181640625')簡單的答案是因為 3*0.1 != 0.3 由于量化(舍入)誤差(而 4*0.1== 0.4 因為乘以 2 的冪通常是精確"運算).Python 試圖找到可以四舍五入到所需值的最短字符串，因此它可以將 4*0.1 顯示為 0.4，因為它們是相等的，但它不能將 3*0.1 顯示為 0.3 因為它們不相等.
您可以使用 Python 中的 .hex 方法查看數字的內部表示(基本上是 exact 二進制浮點值，而不是 base-10近似).這有助于解釋幕后發生的事情.
>>>(0.1).hex()'0x1.999999999999ap-4'>>>(0.3).hex()'0x1.3333333333333p-2'>>>(0.1*3).hex()'0x1.3333333333334p-2'>>>(0.4).hex()'0x1.999999999999ap-2'>>>(0.1*4).hex()'0x1.999999999999ap-2'0.1 是 0x1.999999999999a 乘以 2^-4.一個"最后表示數字 10 - 換句話說，二進制浮點中的 0.1 非常輕微 比精確"大.值 0.1(因為最終的 0x0.99 向上舍入為 0x0.a).當您將此乘以 4(2 的冪)時，指數會向上移動(從 2^-4 到 2^-2)，但數字不會改變，因此 4*0.1 == 0.4.
但是，當您乘以 3 時，0x0.99 和 0x0.a0 (0x0.07) 之間的微小差異會放大為 0x0.15 錯誤，在最后一個位置顯示為一位數錯誤.這會導致 0.1*3 比 0.3 的舍入值非常輕微大.
Python 3 的浮點 repr 被設計為 round-trippable，也就是說，顯示的值應該完全可以轉換為原始值(float(repr(f)) == f 對于所有浮點數 f).因此，它不能以完全相同的方式顯示0.3和0.1*3，否則兩個不同的數字會在往返后最終相同.因此，Python 3 的 repr 引擎選擇顯示一個帶有輕微明顯錯誤的文件.
I know that most decimals don't have an exact floating point representation (Is floating point math broken?).
But I don't see why 4*0.1 is printed nicely as 0.4, but 3*0.1 isn't, when
both values actually have ugly decimal representations:
>>> 3*0.1
0.30000000000000004
>>> 4*0.1
0.4
>>> from decimal import Decimal
>>> Decimal(3*0.1)
Decimal('0.3000000000000000444089209850062616169452667236328125')
>>> Decimal(4*0.1)
Decimal('0.40000000000000002220446049250313080847263336181640625')
The simple answer is because 3*0.1 != 0.3 due to quantization (roundoff) error (whereas 4*0.1 == 0.4 because multiplying by a power of two is usually an "exact" operation). Python tries to find the shortest string that would round to the desired value, so it can display 4*0.1 as 0.4 as these are equal, but it cannot display 3*0.1 as 0.3 because these are not equal.
You can use the .hex method in Python to view the internal representation of a number (basically, the exact binary floating point value, rather than the base-10 approximation). This can help to explain what's going on under the hood.
>>> (0.1).hex()
'0x1.999999999999ap-4'
>>> (0.3).hex()
'0x1.3333333333333p-2'
>>> (0.1*3).hex()
'0x1.3333333333334p-2'
>>> (0.4).hex()
'0x1.999999999999ap-2'
>>> (0.1*4).hex()
'0x1.999999999999ap-2'
0.1 is 0x1.999999999999a times 2^-4. The "a" at the end means the digit 10 - in other words, 0.1 in binary floating point is very slightly larger than the "exact" value of 0.1 (because the final 0x0.99 is rounded up to 0x0.a). When you multiply this by 4, a power of two, the exponent shifts up (from 2^-4 to 2^-2) but the number is otherwise unchanged, so 4*0.1 == 0.4.
However, when you multiply by 3, the tiny little difference between 0x0.99 and 0x0.a0 (0x0.07) magnifies into a 0x0.15 error, which shows up as a one-digit error in the last position. This causes 0.1*3 to be very slightly larger than the rounded value of 0.3.
Python 3's float repr is designed to be round-trippable, that is, the value shown should be exactly convertible into the original value (float(repr(f)) == f for all floats f). Therefore, it cannot display 0.3 and 0.1*3 exactly the same way, or the two different numbers would end up the same after round-tripping. Consequently, Python 3's repr engine chooses to display one with a slight apparent error.
這篇關于為什么 4*0.1 的浮點值在 Python 3 中看起來不錯，但 3*0.1 不好看?的文章就介紹到這了，希望我們推薦的答案對大家有所幫助，也希望大家多多支持html5模板網！