Python float round precision

Round float to x decimals?

I’ve found ways to trim/truncate them (66.666666666 —> 66.6666), but not round (66.666666666 —> 66.6667).

6 Answers 6

I feel compelled to provide a counterpoint to Ashwini Chaudhary’s answer. Despite appearances, the two-argument form of the round function does not round a Python float to a given number of decimal places, and it’s often not the solution you want, even when you think it is. Let me explain.

The ability to round a (Python) float to some number of decimal places is something that’s frequently requested, but turns out to be rarely what’s actually needed. The beguilingly simple answer round(x, number_of_places) is something of an attractive nuisance: it looks as though it does what you want, but thanks to the fact that Python floats are stored internally in binary, it’s doing something rather subtler. Consider the following example:

With a naive understanding of what round does, this looks wrong: surely it should be rounding up to 52.2 rather than down to 52.1 ? To understand why such behaviours can’t be relied upon, you need to appreciate that while this looks like a simple decimal-to-decimal operation, it’s far from simple.

So here’s what’s really happening in the example above. (deep breath) We’re displaying a decimal representation of the nearest binary floating-point number to the nearest n -digits-after-the-point decimal number to a binary floating-point approximation of a numeric literal written in decimal. So to get from the original numeric literal to the displayed output, the underlying machinery has made four separate conversions between binary and decimal formats, two in each direction. Breaking it down (and with the usual disclaimers about assuming IEEE 754 binary64 format, round-ties-to-even rounding, and IEEE 754 rules):

1. First the numeric literal 52.15 gets parsed and converted to a Python float. The actual number stored is 7339460017730355 * 2**-47 , or 52.14999999999999857891452847979962825775146484375 .
2. Internally as the first step of the round operation, Python computes the closest 1-digit-after-the-point decimal string to the stored number. Since that stored number is a touch under the original value of 52.15 , we end up rounding down and getting a string 52.1 . This explains why we’re getting 52.1 as the final output instead of 52.2 .
3. Then in the second step of the round operation, Python turns that string back into a float, getting the closest binary floating-point number to 52.1 , which is now 7332423143312589 * 2**-47 , or 52.10000000000000142108547152020037174224853515625 .
4. Finally, as part of Python’s read-eval-print loop (REPL), the floating-point value is displayed (in decimal). That involves converting the binary value back to a decimal string, getting 52.1 as the final output.

In Python 2.7 and later, we have the pleasant situation that the two conversions in step 3 and 4 cancel each other out. That’s due to Python’s choice of repr implementation, which produces the shortest decimal value guaranteed to round correctly to the actual float. One consequence of that choice is that if you start with any (not too large, not too small) decimal literal with 15 or fewer significant digits then the corresponding float will be displayed showing those exact same digits:

>>> x = 15.34509809234 >>> x 15.34509809234 

Unfortunately, this furthers the illusion that Python is storing values in decimal. Not so in Python 2.6, though! Here’s the original example executed in Python 2.6:

>>> round(52.15, 1) 52.200000000000003 

Not only do we round in the opposite direction, getting 52.2 instead of 52.1 , but the displayed value doesn’t even print as 52.2 ! This behaviour has caused numerous reports to the Python bug tracker along the lines of «round is broken!». But it’s not round that’s broken, it’s user expectations. (Okay, okay, round is a little bit broken in Python 2.6, in that it doesn’t use correct rounding.)

Short version: if you’re using two-argument round, and you’re expecting predictable behaviour from a binary approximation to a decimal round of a binary approximation to a decimal halfway case, you’re asking for trouble.

So enough with the «two-argument round is bad» argument. What should you be using instead? There are a few possibilities, depending on what you’re trying to do.

If you’re rounding for display purposes, then you don’t want a float result at all; you want a string. In that case the answer is to use string formatting:

>>> format(66.66666666666, '.4f') '66.6667' >>> format(1.29578293, '.6f') '1.295783' 

Even then, one has to be aware of the internal binary representation in order not to be surprised by the behaviour of apparent decimal halfway cases.

>>> Decimal('66.66666666666').quantize(Decimal('1e-4')) Decimal('66.6667') >>> Decimal('1.29578293').quantize(Decimal('1e-6')) Decimal('1.295783') 

Источник

Python round()

The round() function returns a floating-point number rounded to the specified number of decimals.

Example

number = 13.46 
# round 13.46 to the nearest integer rounded_number = round(number)
 print(rounded_number) # Output: 13

round() Syntax

The syntax of the round() function is:

round() Parameters

The round() function takes two parameters:

• number — the number to be rounded
• ndigits (optional) — number up to which the given number is rounded; defaults to 0

round() Return Value

The round() function returns the

• nearest integer to the given number if ndigits is not provided
• number rounded off to the ndigits digits if ndigits is provided

Example 1: How round() works in Python?

# for integers 
print(round(10))
 # for floating point 
print(round(10.7))
 # even choice 
print(round(5.5))

Example 2: Round a number to the given number of decimal places

print(round(2.665, 2)) print(round(2.675, 2))

Note: The behavior of round() for floats can be surprising. Notice round(2.675, 2) gives 2.67 instead of the expected 2.68 . This is not a bug: it’s a result of the fact that most decimal fractions can’t be represented exactly as a float.

When the decimal 2.675 is converted to a binary floating-point number, it’s again replaced with a binary approximation, whose exact value is:

2.67499999999999982236431605997495353221893310546875

Due to this, it is rounded down to 2.67.

If you’re in a situation where this precision is needed, consider using the decimal module, which is designed for floating-point arithmetic:

from decimal import Decimal # normal float num = 2.675 
print(round(num, 2))
 # using decimal.Decimal (passed float as string for precision) num = Decimal('2.675') 
print(round(num, 2))

Источник

How to round a floating point number up to a certain decimal place?

Suppose I have 8.8333333333333339 , and I want to convert it to 8.84 . How can I accomplish this in Python? round(8.8333333333333339, 2) gives 8.83 and not 8.84 . I am new to Python or programming in general. I don’t want to print it as a string, and the result will be further used. For more information on the problem, please check Tim Wilson’s Python Programming Tips: Loan and payment calculator.

if you want to print the value use a format such as print «%.2f»%8.8333333333333339. this will print the value with 2 digit

12 Answers 12

8.833333333339 (or 8.833333333333334 , the result of 106.00/12 ) properly rounded to two decimal places is 8.83 . Mathematically it sounds like what you want is a ceiling function. The one in Python’s math module is named ceil :

import math v = 8.8333333333333339 print(math.ceil(v*100)/100) # -> 8.84 

Respectively, the floor and ceiling functions generally map a real number to the largest previous or smallest following integer which has zero decimal places — so to use them for 2 decimal places the number is first multiplied by 10 2 (or 100) to shift the decimal point and is then divided by it afterwards to compensate.

If you don’t want to use the math module for some reason, you can use this (minimally tested) implementation I just wrote:

def ceiling(x): n = int(x) return n if n-1 < x