Python - 如何将浮点数舍入为1位有效数字

Question

I want to round down a float to a specific number of significant digits. Very similar to this answer: https://stackoverflow.com/a/3411435/281021 but instead of the normal round() behavior, it should round down always. I can't use math.floor() because it turns the float into an int.

Basically, 0.45 should become 0.4 instead of 0.5 . And 1945.01 should become 1000.0 instead of 2000.0 .

Answer 1

Scientific representation seems to be the way to go, but numerical techniques usually end up faster for me than string techniques. You do get the occasional floating point error however...

from math import *


def roundDown(x, sigfigs=1): #towards -inf 
    exponent = floor(log10(copysign(x,1))) #we don't want to accidentally try and get an imaginary log (it won't work anyway)
    mantissa = x/10**exponent #get full precision mantissa
    # change floor here to ceil or round to round up or to zero
    mantissa = floor(mantissa * 10**(sigfigs-1)) / 10**(sigfigs-1) #round mantissa to sigfigs
    return mantissa * 10**exponent

Rounding towards zero or +inf is as easy as changing the floor to ceil or round . Another benefit of computing the mantissa and exponent numerically rather than casting to a string is that the number of sigfigs can be easily changed

Answer 2

Use scientific notion to take the significant digit and the power, and calculate the result

def significant_1 (s):
    l = len(str(s))   ####make sure there is enough precision
    a = ('%.' + str(l) + 'E') % decimal.Decimal(s)
    #print (a)
    significate_d = a.split(".")[0]
    times = a.split("E")[1]

    result = int(significate_d) * (10 ** int(times))

    return result


print (significant_1(1999))

print (significant_1(1945.01))

print (significant_1(0.45))

output:

1000
1000
0.4

Answer 3

I think it's a good and simple way:

def convert(number, interval):
    return int(number/interval)*interval

Sample outputs:

1923,1000 -> 1000
12.45,0.1 -> 12.4

Answer 4

 round(number[, ndigits])

Return the floating point value number rounded to ndigits digits after the decimal point. If ndigits is omitted, it defaults to zero. The result is a floating point number. Values are rounded to the closest multiple of 10 to the power minus ndigits; if two multiples are equally close, rounding is done away from 0 (so, for example, round(0.5) is 1.0 and round(-0.5) is -1.0).

https://docs.python.org/2/library/functions.html#round