Create successful ePaper yourself
Turn your PDF publications into a flip-book with our unique Google optimized e-Paper software.
0.0001100110011001100110011001100110011001100110011...<br />
Stop at any finite number of bits, and you get an approximation. This is why you see things like:<br />
>>> 0.1<br />
0.10000000000000001<br />
On most machines today, that is what you’ll see if you enter 0.1 at a <strong>Python</strong> prompt. You may not, though, because<br />
the number of bits used by the hardware to store floating-point values can vary across machines, and <strong>Python</strong> only<br />
prints a decimal approximation to the true decimal value of the binary approximation stored by the machine. On<br />
most machines, if <strong>Python</strong> were to print the true decimal value of the binary approximation stored for 0.1, it would<br />
have to display<br />
>>> 0.1<br />
0.1000000000000000055511151231257827021181583404541015625<br />
instead! The <strong>Python</strong> prompt uses the builtin repr() function to obtain a string version of everything it displays.<br />
For floats, repr(float) rounds the true decimal value to 17 significant digits, giving<br />
0.10000000000000001<br />
repr(float) produces 17 significant digits because it turns out that’s enough (on most machines) so that<br />
eval(repr(x)) == x exactly for all finite floats x, but rounding to 16 digits is not enough to make that<br />
true.<br />
Note that this is in the very nature of binary floating-point: this is not a bug in <strong>Python</strong>, it is not a bug in your code<br />
either. You’ll see the same kind of thing in all languages that support your hardware’s floating-point arithmetic<br />
(although some languages may not display the difference by default, or in all output modes).<br />
<strong>Python</strong>’s builtin str() function produces only 12 significant digits, and you may wish to use that instead. It’s<br />
unusual for eval(str(x)) to reproduce x, but the output may be more pleasant to look at:<br />
>>> print str(0.1)<br />
0.1<br />
It’s important to realize that this is, in a real sense, an illusion: the value in the machine is not exactly 1/10, you’re<br />
simply rounding the display of the true machine value.<br />
Other surprises follow from this one. For example, after seeing<br />
>>> 0.1<br />
0.10000000000000001<br />
you may be tempted to use the round() function to chop it back to the single digit you expect. But that makes<br />
no difference:<br />
>>> round(0.1, 1)<br />
0.10000000000000001<br />
The problem is that the binary floating-point value stored for "0.1"was already the best possible binary approximation<br />
to 1/10, so trying to round it again can’t make it better: it was already as good as it gets.<br />
92 Apêndice B. Floating Point Arithmetic: Issues and Limitations