Python format default rounding when formatting float number

Question

I'm trying to solve some floating-point problems in my code in Python 2.7.10. When testing I've encountered a strange behaviour with the format method:

print "{}".format(0.3000000000004) # 13 decimals

Prints: 0.3

But:

print "{}".format(0.300000000004) # 12 decimals

Prints: 0.300000000004

Since I'm not specifying the format, why does it round the first number? Is there a default number of allowed decimal places?

You are just seeing that the default `str()` conversion formats to 12 decimals, while `repr()` shows more. — Martijn Pieters, Apr 03 '17 at 11:54
@Chris_Rands: I was planning to look for a suitable dupe (but out of battery and time for the moment). — Martijn Pieters, Apr 03 '17 at 12:00
@Chris_Rands: [Why does str(float) return more digits in Python 3 than Python 2?](//stackoverflow.com/q/25898733) for the Py 2 vs 3 changes. — Martijn Pieters, Apr 03 '17 at 12:13
@Chris_Rands: in-depth explanation for how things are formatted when using `str()` vs `repr()`: [Precision of repr(f), str(f), print(f) when f is float](//stackoverflow.com/q/28493114) — Martijn Pieters, Apr 03 '17 at 12:14

Moses Koledoye · Accepted Answer · 2017-11-14T18:09:44.463

Since you do not specify a format, the default type coercion to string is used. So this isn't really an issue with format. Python 2 truncates to a precision of 12 characters (excluding the leading zero, if any) for float.__str__, and after truncation in this case, all trailing zeros are cleaned up:

>>> str(0.3000000000004) # unlike str(0.3000000000014) -> '0.300000000001'
'0.3'

Adding the format_spec :f gives you the default precision of 6:

>>> '{:f}'.format(0.3000000000004)
'0.300000'

Specify the width and precision or use repr to get a good representation:

>>> '{!r}'.format(0.3000000000004)
'0.3000000000004'

The behavior is different in Python 3 though:

>>> str(0.3000000000004)
'0.3000000000004'

The formatting of floats is handled by just one function float_repr in Python 3 (it does not have a special float_str function):

(reprfunc)float_repr,                       /* tp_repr */
...
(reprfunc)float_repr,                        /* tp_str */

whereas Python2.7 defines a separate handler float_str and float_repr for __str__ and __repr__ respectively:

(reprfunc)float_repr,                       /* tp_repr */
...
(reprfunc)float_str,                        /* tp_str */

The deciding variable here which I think is the reason for the precision loss beyond 12d.p. is PyFloat_STR_PRECISION (defined in Python 2):

#define PyFloat_STR_PRECISION 12

It reverses to a truncation for floats taking more than 12 characters in the default conversion.

But `str(0.3000000000004)` `return`s `'0.3000000000004'` in Py3.6 — Chris_Rands, Apr 03 '17 at 11:56
@Chris_Rands A lot has changed with strings, between 2.7 and 3.6, so I wouldn't consider that as surprising — Moses Koledoye, Apr 03 '17 at 11:57
Didn't say it was surprising, but it's not intuitive (to me at least) so perhaps it is worth explaining in your answer :) — Chris_Rands, Apr 03 '17 at 12:01
Ok it make sense, i just wanted to know if it was an expected behaviour. Then can i be sure that this rounding solves floating-point problems on number to string conversion? — mck89, Apr 03 '17 at 12:03
@Chris_Rands took some time to walk through the c code, but there you have it — Moses Koledoye, Apr 03 '17 at 12:34

score -3 · Answer 2 · answered Apr 03 '17 at 11:54

-3

This is just the way python (and many other languages) deal with float point inaccuracy. So internally this number is actually equals 0.3. There's a website dedicated to this problem in many languages: http://0.30000000000000004.com/

To this specific print, you can simply quote the number (make it a string), and the compiler will not try to round the number:

print "{}".format("0.3000000000004")

But then you also wouldn't need to use the format:

print "0.3000000000004"

answered Apr 03 '17 at 11:54

Fernando Cezar

858
7
22

2

No, this is about formatting accuracy, not general FP accuracy. – Martijn Pieters Apr 03 '17 at 11:54
1

It is not possible for an IEEE 754 binary floating point number to have the value 0.3. The closest 64 bit binary float is 0.299999999999999988897769753748434595763683319091796875 – Patricia Shanahan Apr 03 '17 at 14:06

Python format default rounding when formatting float number

2 Answers2

Linked