我需要将浮点数舍入以显示在 UI 中。例如，一个有效数字：
1234 -> 1000
0.12 -> 0.1
0.012 -> 0.01
0.062 -> 0.06
6253 -> 6000
1999 -> 2000
有没有使用 Python 库的好方法，还是我必须自己编写？
问问题
274534 次
24 回答
173
您可以使用负数来舍入整数：
>>> round(1234, -3)
1000.0
因此，如果您只需要最重要的数字：
>>> from math import log10, floor
>>> def round_to_1(x):
... return round(x, -int(floor(log10(abs(x)))))
...
>>> round_to_1(0.0232)
0.02
>>> round_to_1(1234243)
1000000.0
>>> round_to_1(13)
10.0
>>> round_to_1(4)
4.0
>>> round_to_1(19)
20.0
如果它大于 1，您可能必须注意将浮点数转换为整数。
于 2010-08-05T02:57:33.163 回答
121
字符串格式中的 %g 将格式化一个四舍五入到一些有效数字的浮点数。它有时会使用 'e' 科学记数法，因此将四舍五入的字符串转换回浮点数，然后通过 %s 字符串格式化。
>>> '%s' % float('%.1g' % 1234)
'1000'
>>> '%s' % float('%.1g' % 0.12)
'0.1'
>>> '%s' % float('%.1g' % 0.012)
'0.01'
>>> '%s' % float('%.1g' % 0.062)
'0.06'
>>> '%s' % float('%.1g' % 6253)
'6000.0'
>>> '%s' % float('%.1g' % 1999)
'2000.0'
于 2010-08-05T04:24:19.273 回答
65
如果您想要的有效小数不是 1 个（否则与 Evgeny 相同）：
>>> from math import log10, floor
>>> def round_sig(x, sig=2):
... return round(x, sig-int(floor(log10(abs(x))))-1)
...
>>> round_sig(0.0232)
0.023
>>> round_sig(0.0232, 1)
0.02
>>> round_sig(1234243, 3)
1230000.0
于 2010-08-05T09:49:43.993 回答
55
f'{float(f"{i:.1g}"):g}'
# Or with Python <3.6,
'{:g}'.format(float('{:.1g}'.format(i)))
此解决方案与所有其他解决方案不同，因为：
- 它完全解决了 OP 问题
- 它不需要任何额外的包
- 它不需要任何用户定义的辅助函数或数学运算
对于任意数量n的有效数字，您可以使用：
print('{:g}'.format(float('{:.{p}g}'.format(i, p=n))))
测试：
a = [1234, 0.12, 0.012, 0.062, 6253, 1999, -3.14, 0., -48.01, 0.75]
b = ['{:g}'.format(float('{:.1g}'.format(i))) for i in a]
# b == ['1000', '0.1', '0.01', '0.06', '6000', '2000', '-3', '0', '-50', '0.8']
注意：使用此解决方案，无法根据输入动态调整有效数字的数量，因为没有标准方法来区分具有不同数量的尾随零 ( 3.14 == 3.1400) 的数字。如果您需要这样做，则需要非标准函数，如to-precision包中提供的函数。
于 2018-02-15T17:10:34.140 回答
11
我已经创建了精确的包，可以满足您的需求。它允许您为您的数字提供或多或少的有效数字。
它还输出具有指定数量有效数字的标准、科学和工程符号。
在接受的答案中有一行
>>> round_to_1(1234243)
1000000.0
这实际上指定了 8 个 sig 无花果。对于数字 1234243，我的库仅显示一个有效数字：
>>> from to_precision import to_precision
>>> to_precision(1234243, 1, 'std')
'1000000'
>>> to_precision(1234243, 1, 'sci')
'1e6'
>>> to_precision(1234243, 1, 'eng')
'1e6'
它还将舍入最后一个有效数字，如果未指定符号，它可以自动选择要使用的符号：
>>> to_precision(599, 2)
'600'
>>> to_precision(1164, 2)
'1.2e3'
于 2017-05-23T11:59:15.277 回答
11
为了直接回答这个问题，这是我使用R 函数命名的版本：
import math
def signif(x, digits=6):
if x == 0 or not math.isfinite(x):
return x
digits -= math.ceil(math.log10(abs(x)))
return round(x, digits)
我发布此答案的主要原因是抱怨“0.075”舍入为0.07而不是0.08的评论。正如“新手 C”所指出的，这是由于具有有限精度和 base-2 表示的浮点算术的组合。实际可以表示的最接近 0.075 的数字略小，因此四舍五入的结果与您可能天真的预期的不同。
另请注意，这适用于任何使用非十进制浮点算术，例如 C 和 Java 都有相同的问题。
为了更详细地显示，我们要求 Python 将数字格式化为“十六进制”格式：
0.075.hex()
这给了我们：0x1.3333333333333p-4. 这样做的原因是正常的十进制表示通常涉及四舍五入，因此不是计算机实际“看到”数字的方式。如果您不习惯这种格式，一些有用的参考资料是Python 文档和C 标准。
为了说明这些数字是如何工作的，我们可以通过执行以下操作回到我们的起点：
0x13333333333333 / 16**13 * 2**-4
应该打印出来0.075。 16**13是因为小数点后有 13 位十六进制数字，并且2**-4是因为十六进制指数是以 2 为底的。
现在我们对浮点数的表示方式有了一些了解，我们可以使用该decimal模块给我们一些更精确的信息，向我们展示发生了什么：
from decimal import Decimal
Decimal(0x13333333333333) / 16**13 / 2**4
给予：0.07499999999999999722444243844并希望解释为什么round(0.075, 2)评估为0.07
于 2019-07-10T16:21:09.163 回答
5
要将整数四舍五入为 1 位有效数字，基本思想是将其转换为在该点之前有 1 位数字的浮点并四舍五入，然后将其转换回其原始整数大小。
为此，我们需要知道小于整数 10 的最大幂。为此，我们可以使用 log 10 函数的 floor。
from math import log10, floor def round_int(i,places): if i == 0: return 0 isign = i/abs(i) i = abs(i) if i < 1: return 0 max10exp = floor(log10(i)) if max10exp+1 < places: return i sig10pow = 10**(max10exp-places+1) floated = i*1.0/sig10pow defloated = round(floated)*sig10pow return int(defloated*isign)
于 2012-03-04T18:18:19.250 回答
5
def round_to_n(x, n):
if not x: return 0
power = -int(math.floor(math.log10(abs(x)))) + (n - 1)
factor = (10 ** power)
return round(x * factor) / factor
round_to_n(0.075, 1) # 0.08
round_to_n(0, 1) # 0
round_to_n(-1e15 - 1, 16) # 1000000000000001.0
希望能从上述所有答案中得到最好的（减去能够将其作为单行 lambda ;) ）。尚未探索，请随时编辑此答案：
round_to_n(1e15 + 1, 11) # 999999999999999.9
于 2016-07-13T21:55:17.610 回答
4
我修改了 indgar 的解决方案来处理负数和小数（包括零）。
from math import log10, floor
def round_sig(x, sig=6, small_value=1.0e-9):
return round(x, sig - int(floor(log10(max(abs(x), abs(small_value))))) - 1)
于 2016-03-26T19:50:51.517 回答
3
我想不出任何可以开箱即用的方法。但它对于浮点数处理得相当好。
>>> round(1.2322, 2)
1.23
整数更棘手。它们不会以 10 为基数存储在内存中，因此重要的地方并不是一件自然而然的事情。不过，一旦它们是字符串，实现起来就相当简单了。
或者对于整数：
>>> def intround(n, sigfigs):
... n = str(n)
... return n[:sigfigs] + ('0' * (len(n)-(sigfigs)))
>>> intround(1234, 1)
'1000'
>>> intround(1234, 2)
如果您想创建一个处理任何数字的函数，我的偏好是将它们都转换为字符串并查找小数位来决定要做什么：
>>> def roundall1(n, sigfigs):
... n = str(n)
... try:
... sigfigs = n.index('.')
... except ValueError:
... pass
... return intround(n, sigfigs)
另一种选择是检查类型。这将不那么灵活，并且可能无法很好地与其他数字（例如Decimal对象）一起使用：
>>> def roundall2(n, sigfigs):
... if type(n) is int: return intround(n, sigfigs)
... else: return round(n, sigfigs)
于 2010-08-05T01:35:11.227 回答
3
发布的答案是给出时最好的答案，但它有许多限制，并且不会产生技术上正确的有效数字。
numpy.format_float_positional直接支持所需的行为。以下片段返回x格式化为 4 位有效数字的浮点数，并抑制科学计数法。
import numpy as np
x=12345.6
np.format_float_positional(x, precision=4, unique=False, fractional=False, trim='k')
> 12340.
于 2019-10-21T17:01:15.883 回答
3
如果你想在不涉及字符串的情况下进行舍入，我在上面的评论中找到的链接：
http://code.activestate.com/lists/python-tutor/70739/
我觉得最好。然后，当您使用任何字符串格式描述符进行打印时，您会得到合理的输出，并且可以将数字表示用于其他计算目的。
链接上的代码是三行代码：def、doc 和 return。它有一个错误：您需要检查爆炸对数。这很容易。将输入与 进行比较sys.float_info.min。完整的解决方案是：
import sys,math
def tidy(x, n):
"""Return 'x' rounded to 'n' significant digits."""
y=abs(x)
if y <= sys.float_info.min: return 0.0
return round( x, int( n-math.ceil(math.log10(y)) ) )
它适用于任何标量数值，float如果您出于某种原因需要移动响应，则 n 可以是 a。您实际上可以将限制推到：
sys.float_info.min*sys.float_info.epsilon
如果由于某种原因您正在使用微小的值，则不会引起错误。
于 2018-04-13T06:49:58.847 回答
1
使用 python 2.6+新样式格式（不推荐使用 %-style）：
>>> "{0}".format(float("{0:.1g}".format(1216)))
'1000.0'
>>> "{0}".format(float("{0:.1g}".format(0.00356)))
'0.004'
在 python 2.7+ 中，您可以省略前导0s。
于 2018-01-08T13:34:33.833 回答
0
鉴于一个问题如此彻底地回答为什么不添加另一个
这更适合我的审美，尽管上面的许多都是可比的
import numpy as np
number=-456.789
significantFigures=4
roundingFactor=significantFigures - int(np.floor(np.log10(np.abs(number)))) - 1
rounded=np.round(number, roundingFactor)
string=rounded.astype(str)
print(string)
这适用于单个数字和 numpy 数组，并且对于负数应该可以正常工作。
我们可能会添加一个额外的步骤 - np.round() 返回一个十进制数，即使舍入是一个整数（即对于显着数字 = 2，我们可能希望返回 -460，但我们得到 -460.0）。我们可以添加这一步来纠正这个问题：
if roundingFactor<=0:
rounded=rounded.astype(int)
不幸的是，这最后一步不适用于一组数字——亲爱的读者，我将把它留给你，看看你是否需要。
于 2019-08-03T08:59:11.277 回答
0
import math
def sig_dig(x, n_sig_dig):
num_of_digits = len(str(x).replace(".", ""))
if n_sig_dig >= num_of_digits:
return x
n = math.floor(math.log10(x) + 1 - n_sig_dig)
result = round(10 ** -n * x) * 10 ** n
return float(str(result)[: n_sig_dig + 1])
>>> sig_dig(1234243, 3)
>>> sig_dig(243.3576, 5)
1230.0
243.36
于 2020-03-26T21:29:08.933 回答
0
我也遇到了这个问题，但我需要控制舍入类型。因此，我编写了一个快速函数（参见下面的代码），它可以考虑值、舍入类型和所需的有效数字。
import decimal
from math import log10, floor
def myrounding(value , roundstyle='ROUND_HALF_UP',sig = 3):
roundstyles = [ 'ROUND_05UP','ROUND_DOWN','ROUND_HALF_DOWN','ROUND_HALF_UP','ROUND_CEILING','ROUND_FLOOR','ROUND_HALF_EVEN','ROUND_UP']
power = -1 * floor(log10(abs(value)))
value = '{0:f}'.format(value) #format value to string to prevent float conversion issues
divided = Decimal(value) * (Decimal('10.0')**power)
roundto = Decimal('10.0')**(-sig+1)
if roundstyle not in roundstyles:
print('roundstyle must be in list:', roundstyles) ## Could thrown an exception here if you want.
return_val = decimal.Decimal(divided).quantize(roundto,rounding=roundstyle)*(decimal.Decimal(10.0)**-power)
nozero = ('{0:f}'.format(return_val)).rstrip('0').rstrip('.') # strips out trailing 0 and .
return decimal.Decimal(nozero)
for x in list(map(float, '-1.234 1.2345 0.03 -90.25 90.34543 9123.3 111'.split())):
print (x, 'rounded UP: ',myrounding(x,'ROUND_UP',3))
print (x, 'rounded normal: ',myrounding(x,sig=3))
于 2017-09-28T16:52:46.080 回答
0
我改编了其中一个答案。我喜欢这个：
def sigfiground(number:float, ndigits=3)->float:
return float(f"{number:.{ndigits}g}")
当我仍然想要一个浮点数时我会使用它（我在其他地方进行格式化）。
于 2021-12-17T15:21:02.753 回答
0
如果数字大于 10**(-decimal_positions)，则此函数执行正常循环，否则添加更多小数，直到达到有意义的小数位数：
def smart_round(x, decimal_positions):
dp = - int(math.log10(abs(x))) if x != 0.0 else int(0)
return round(float(x), decimal_positions + dp if dp > 0 else decimal_positions)
希望能帮助到你。
于 2018-07-19T09:38:51.710 回答
0
这些答案中的大多数都涉及数学、十进制和/或 numpy 导入或输出值作为字符串。这是基本 python 中的一个简单解决方案，可以处理大小数字并输出浮点数：
def sig_fig_round(number, digits=3):
power = "{:e}".format(number).split('e')[1]
return round(number, -(int(power) - digits))
于 2020-12-16T18:23:48.423 回答
0
https://stackoverflow.com/users/1391441/gabriel，以下是否解决了您对 rnd(.075, 1) 的担忧？警告：以浮点数形式返回值
def round_to_n(x, n):
fmt = '{:1.' + str(n) + 'e}' # gives 1.n figures
p = fmt.format(x).split('e') # get mantissa and exponent
# round "extra" figure off mantissa
p[0] = str(round(float(p[0]) * 10**(n-1)) / 10**(n-1))
return float(p[0] + 'e' + p[1]) # convert str to float
>>> round_to_n(750, 2)
750.0
>>> round_to_n(750, 1)
800.0
>>> round_to_n(.0750, 2)
0.075
>>> round_to_n(.0750, 1)
0.08
>>> math.pi
3.141592653589793
>>> round_to_n(math.pi, 7)
3.141593
于 2019-02-22T18:46:01.790 回答
0
这将返回一个字符串，以便正确显示没有小数部分的结果，以及在 E 表示法中出现的小值：
def sigfig(x, num_sigfig):
num_decplace = num_sigfig - int(math.floor(math.log10(abs(x)))) - 1
return '%.*f' % (num_decplace, round(x, num_decplace))
于 2019-03-15T12:04:01.423 回答
0
此函数接受正数和负数，并进行适当的有效数字舍入。
from math import floor
def significant_arithmetic_rounding(n, d):
'''
This function takes a floating point number and the no. of significant digit d, perform significant digits
arithmetic rounding and returns the floating point number after rounding
'''
if n == 0:
return 0
else:
# Checking whether the no. is negative or positive. If it is negative we will take the absolute value of it and proceed
neg_flag = 0
if n < 0:
neg_flag = 1
n = abs(n)
n1 = n
# Counting the no. of digits to the left of the decimal point in the no.
ld = 0
while(n1 >= 1):
n1 /= 10
ld += 1
n1 = n
# Counting the no. of zeros to the right of the decimal point and before the first significant digit in the no.
z = 0
if ld == 0:
while(n1 <= 0.1):
n1 *= 10
z += 1
n1 = n
# No. of digits to be considered after decimal for rounding
rd = (d - ld) + z
n1 *= 10**rd
# Increase by 0.5 and take the floor value for rounding
n1 = floor(n1+0.5)
# Placing the decimal point at proper position
n1 /= 10 ** rd
# If the original number is negative then make it negative
if neg_flag == 1:
n1 = 0 - n1
return n1
测试：
>>> significant_arithmetic_rounding(1234, 3)
1230.0
>>> significant_arithmetic_rounding(123.4, 3)
123.0
>>> significant_arithmetic_rounding(0.0012345, 3)
0.00123
>>> significant_arithmetic_rounding(-0.12345, 3)
-0.123
>>> significant_arithmetic_rounding(-30.15345, 3)
-30.2
于 2021-12-07T15:08:07.007 回答
0
使用标准十进制库的简单变体
from decimal import Decimal
def to_significant_figures(v: float, n_figures: int) -> str:
d = Decimal(v)
d = d.quantize(Decimal((0, (), d.adjusted() - n_figures + 1)))
return str(d.quantize(Decimal(1)) if d == d.to_integral() else d.normalize())
测试它
>>> to_significant_figures(1.234567, 3)
'1.23'
>>> to_significant_figures(1234567, 3)
'1230000'
>>> to_significant_figures(1.23, 7)
'1.23'
>>> to_significant_figures(123, 7)
'123'
于 2021-09-04T21:47:12.180 回答