opython3l_Python3.1有什么新变化

Python now uses David Gay’s algorithm for finding the shortest floating

point representation that doesn’t change its value. This should help

mitigate some of the confusion surrounding binary floating point

numbers.

The significance is easily seen with a number like 1.1 which does not

have an exact equivalent in binary floating point. Since there is no exact

equivalent, an expression like float(&＃39;1.1&＃39;) evaluates to the nearest

representable value which is 0x1.199999999999ap&＃43;0 in hex or

1.100000000000000088817841970012523233890533447265625 in decimal. That

nearest value was and still is used in subsequent floating point

calculations.

What is new is how the number gets displayed. Formerly, Python used a

simple approach. The value of repr(1.1) was computed as format(1.1,

&＃39;.17g&＃39;) which evaluated to &＃39;1.1000000000000001&＃39;. The advantage of

using 17 digits was that it relied on IEEE-754 guarantees to assure that

eval(repr(1.1)) would round-trip exactly to its original value. The

disadvantage is that many people found the output to be confusing (mistaking

intrinsic limitations of binary floating point representation as being a

problem with Python itself).

The new algorithm for repr(1.1) is smarter and returns &＃39;1.1&＃39;.

Effectively, it searches all equivalent string representations (ones that

get stored with the same underlying float value) and returns the shortest

representation.

The new algorithm tends to emit cleaner representations when possible, but

it does not change the underlying values. So, it is still the case that

1.1 &＃43; 2.2 !&＃61; 3.3 even though the representations may suggest otherwise.

The new algorithm depends on certain features in the underlying floating

point implementation. If the required features are not found, the old

algorithm will continue to be used. Also, the text pickle protocols

assure cross-platform portability by using the old algorithm.

(由 Eric Smith 和 Mark Dickinson 在 bpo-1580 贡献)