繁体   English   中英

如何将 Python 中的数字舍入为有效数字

How to round a number to significant figures in Python

提示:本站收集StackOverFlow近2千万问答,支持中英文搜索,鼠标放在语句上弹窗显示对应的参考中文或英文, 本站还提供   中文繁体   英文版本   中英对照 版本,有任何建议请联系yoyou2525@163.com。

我需要将浮点数舍入以显示在 UI 中。 例如,一个有效数字:

1234 -> 1000

0.12 -> 0.1

0.012 -> 0.01

0.062 -> 0.06

6253 -> 6000

1999 -> 2000

有没有使用 Python 库的好方法,还是我必须自己编写?

26 个回复

您可以使用负数来舍入整数:

>>> 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,您可能需要注意将浮点数转换为整数。

字符串格式中的 %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'

如果您想拥有 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
f'{float(f"{i:.1g}"):g}'
# Or with Python <3.6,
'{:g}'.format(float('{:.1g}'.format(i)))

此解决方案与所有其他解决方案不同,因为:

  1. 正好解决了 OP 问题
  2. 不需要任何额外
  3. 不需要任何用户定义的辅助功能数学运算

对于任意数量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包中提供的非标准函数。

我已经创建了可以满足您要求的精度包。 它允许您提供或多或少的有效数字。

它还输出具有指定数量的有效数字的标准、科学和工程符号。

在接受的答案中有一行

>>> round_to_1(1234243)
1000000.0

这实际上指定了 8 个无花果。 对于数字 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'

为了直接回答这个问题,这是我使用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 新手”所指出的那样,这是由于具有有限精度和基数 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

要将整数四舍五入为 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)

我修改了 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)
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

我想不出有什么可以开箱即用地处理这个问题。 但它对于浮点数处理得相当好。

>>> 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)

如果你想在不涉及字符串的情况下舍入,我在上面的评论中找到的链接:

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)) ) )

它适用于任何标量数值,如果出于某种原因需要移动响应,n 可以是float 您实际上可以将限制推到:

sys.float_info.min*sys.float_info.epsilon

不会引起错误,如果出于某种原因您正在使用微不足道的值。

发布的答案在给出时是最好的,但它有许多限制,并且不会产生技术上正确的有效数字。

numpy.format_float_positional直接支持所需的行为。 以下片段返回格式化为 4 位有效数字的浮点数x ,科学记数法被抑制。

import numpy as np
x=12345.6
np.format_float_positional(x, precision=4, unique=False, fractional=False, trim='k')
> 12340.

sigfig包/库涵盖了这一点。 安装后,您可以执行以下操作:

>>> from sigfig import round
>>> round(1234, 1)
1000
>>> round(0.12, 1)
0.1
>>> round(0.012, 1)
0.01
>>> round(0.062, 1)
0.06
>>> round(6253, 1)
6000
>>> round(1999, 1)
2000

使用 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+ 中,您可以省略前导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))

如果数字大于 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)

希望能帮助到你。

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

这将返回一个字符串,以便正确显示没有小数部分的结果和否则会出现在 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))

鉴于一个问题得到如此彻底的回答,为什么不添加另一个

这更适合我的审美,尽管以上许多都具有可比性

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)

不幸的是,这最后一步不适用于一组数字 - 我将把它留给亲爱的读者来确定您是否需要。

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

这些答案中的大多数都涉及作为字符串的数学、十进制和/或 numpy 导入或输出值。 这是基本python中的一个简单解决方案,它可以处理大数和小数并输出一个浮点数:

def sig_fig_round(number, digits=3):
    power = "{:e}".format(number).split('e')[1]
    return round(number, -(int(power) - digits))

使用标准十进制库的简单变体

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'

此函数采用正数和负数,并进行适当的有效数字舍入。

from math import floor

def significant_arithmetic_rounding(n, d):
    # 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

我改编了其中一个答案。 我喜欢这个:

def sigfiground(number:float, ndigits=3)->float:
    return float(f"{number:.{ndigits}g}")

当我仍然想要一个浮点数时我会使用它(我在其他地方进行格式化)。

当包含示例时,更容易知道答案是否适合您的需求。 以下是基于以前的解决方案构建的,但提供了更通用的 function,它可以四舍五入到 1、2、3、4 或任意数量的有效数字。

import math

# Given x as float or decimal, returns as string a number rounded to "sig" significant digts
# Return as string in order to control significant digits, could be a float or decimal 
def round_sig(x, sig=2):
  r = round(x, sig-int(math.floor(math.log10(abs(x))))-1)
  floatsig = "%." + str(sig) + "g"
  return "%d"%r if abs(r) >= 10**(sig-1) else '%s'%float(floatsig % r) 

>>> a = [1234, 123.4, 12.34, 1.234, 0.1234, 0.01234, 0.25, 1999, -3.14, -48.01, 0.75]
>>> [print(i, "->", round_sig(i,1), round_sig(i), round_sig(i,3), round_sig(i,4)) for i in a]

1234 -> 1000 1200 1230 1234
123.4 -> 100 120 123 123.4
12.34 -> 10 12 12.3 12.34
1.234 -> 1 1.2 1.23 1.234
0.1234 -> 0.1 0.12 0.123 0.1234
0.01234 -> 0.01 0.012 0.0123 0.01234
0.25 -> 0.2 0.25 0.25 0.25
1999 -> 2000 2000 2000 1999
-3.14 -> -3 -3.1 -3.14 -3.14
-48.01 -> -50 -48 -48.0 -48.01
0.75 -> 0.8 0.75 0.75 0.75

在很多情况下,重要的数量取决于评估的过程,例如错误。 我编写了一些代码,它们根据错误(或一些所需的数字)以及字符串形式(不会消除右侧有效零)返回一个数字

import numpy as np

def Sig_Digit(x, *N,):
    if abs(x) < 1.0e-15:
        return(1)
    N = 1 if N ==() else N[0]
    k = int(round(abs(N)-1))-int(np.floor(np.log10(abs(x))))
    return(k);

def Sig_Format(x, *Error,):
    if abs(x) < 1.0e-15:
        return('{}')
    Error = 1 if Error ==() else abs(Error[0])
    k = int(np.floor(np.log10(abs(x))))
    z = x/10**k
    k = -Sig_Digit(Error, 1)
    m = 10**k
    y = round(x*m)/m
    if k < 0:
        k = abs(k)
        if z >= 9.5:
            FMT = '{:'+'{}'.format(1+k)+'.'+'{}'.format(k-1)+'f}'
        else:
            FMT = '{:'+'{}'.format(2+k)+'.'+'{}'.format(k)+'f}'
    elif k == 0:
        if z >= 9.5:
            FMT = '{:'+'{}'.format(1+k)+'.0e}'
        else:
            FMT = '{:'+'{}'.format(2+k)+'.0f}'
    else:
        FMT = '{:'+'{}'.format(2+k)+'.'+'{}'.format(k)+'e}'
    return(FMT)

def Sci_Format(x, *N):
    if abs(x) < 1.0e-15:
        return('{}')
    N = 1 if N ==() else N[0]
    N = int(round(abs(N)-1))
    y = abs(x)
    k = int(np.floor(np.log10(y)))
    z = x/10**k
    k = k-N
    m = 10**k
    y = round(x/m)*m
    if k < 0:
        k = abs(k)
        if z >= 9.5:
            FMT = '{:'+'{}'.format(1+k)+'.'+'{}'.format(k-1)+'f}'
        else:
            FMT = '{:'+'{}'.format(2+k)+'.'+'{}'.format(k)+'f}'
    elif k == 0:
        if z >= 9.5:
            FMT = '{:'+'{}'.format(1+k)+'.0e}'
        else:
            FMT = '{:'+'{}'.format(2+k)+'.0f}'
    else:
        FMT = '{:'+'{}'.format(2+N)+'.'+'{}'.format(N)+'e}'
    return(FMT)

def Significant(x, *Error):
    N = 0 if Error ==() else Sig_Digit(abs(Error[0]), 1)
    m = 10**N
    y = round(x*m)/m
    return(y)

def Scientific(x, *N):
    m = 10**Sig_Digit(x, *N)
    y = round(x*m)/m
    return(y)

def Scientific_Str(x, *N,): 
    FMT = Sci_Format(x, *N)
    return(FMT.format(x))

def Significant_Str(x, *Error,):    
    FMT = Sig_Format(x, *Error)
    return(FMT.format(x))

测试代码:

X = [19.03345607, 12.075, 360.108321344, 4325.007605343]
Error = [1.245, 0.1245, 0.0563, 0.01245, 0.001563, 0.0004603]
for x in X:
    for error in Error:
        print(x,'+/-',error, end='   \t==> ')
        print(' (',Significant_Str(x, error), '+/-', Scientific_Str(error),')')

  

打印出:

19.03345607 +/- 1.245       ==>  ( 19 +/-  1 )

19.03345607 +/- 0.1245      ==>  ( 19.0 +/- 0.1 )

19.03345607 +/- 0.0563      ==>  ( 19.03 +/- 0.06 )

19.03345607 +/- 0.01245     ==>  ( 19.03 +/- 0.01 )

19.03345607 +/- 0.001563    ==>  ( 19.033 +/- 0.002 )

19.03345607 +/- 0.0004603       ==>  ( 19.0335 +/- 0.0005 )

12.075 +/- 1.245    ==>  ( 12 +/-  1 )

12.075 +/- 0.1245       ==>  ( 12.1 +/- 0.1 )

12.075 +/- 0.0563       ==>  ( 12.07 +/- 0.06 )

12.075 +/- 0.01245      ==>  ( 12.07 +/- 0.01 )

12.075 +/- 0.001563     ==>  ( 12.075 +/- 0.002 )

12.075 +/- 0.0004603    ==>  ( 12.0750 +/- 0.0005 )

360.108321344 +/- 1.245     ==>  ( 360 +/-  1 )

360.108321344 +/- 0.1245    ==>  ( 360.1 +/- 0.1 )

360.108321344 +/- 0.0563    ==>  ( 360.11 +/- 0.06 )

360.108321344 +/- 0.01245       ==>  ( 360.11 +/- 0.01 )

360.108321344 +/- 0.001563      ==>  ( 360.108 +/- 0.002 )

360.108321344 +/- 0.0004603     ==>  ( 360.1083 +/- 0.0005 )

4325.007605343 +/- 1.245    ==>  ( 4325 +/-  1 )

4325.007605343 +/- 0.1245       ==>  ( 4325.0 +/- 0.1 )

4325.007605343 +/- 0.0563       ==>  ( 4325.01 +/- 0.06 )

4325.007605343 +/- 0.01245      ==>  ( 4325.01 +/- 0.01 )

4325.007605343 +/- 0.001563     ==>  ( 4325.008 +/- 0.002 )

4325.007605343 +/- 0.0004603    ==>  ( 4325.0076 +/- 0.0005 )
2 如何在Java中将数字四舍五入到6位有效数字?

所以我有这个代码 所以我在这里找到一个例子,告诉我这样做 那就是我尝试过的,它绕着米数四舍五入,但是英寸,英尺,码等数字却没有四舍五入。 我做错了吗? 解决这个问题的正确方法是什么? 编辑 :好的,所以我发现了一些可以解决的问题,以防其他人使用它而不是使用它: ...

3 如何在Python中将度量及其误差估计四舍五入为指定数量的有效数字?

我想要一个给出测量值和误差估计的函数,将误差四舍五入到指定数量的有效数字,并将测量值四舍五入到相应的数字。 这是输入和预期输出的示例: 错误通常以2个有效数字来报告。 我想要一个函数,该函数将以这种精度返回值的错误估计,并且还将值截断为正确的小数位。 ...

4 四舍五入到有效数字,VB

在vb函数“舍入”中,我希望能够舍入到小数点后一位。 似乎在以下代码中: 圆([SHAPE_Area] / 10000,1)&“ ha” 我想四舍五入到小数点后一位,如果小数点后那个地方的值是0,那么它四舍五入到一个整数(即1而不是1.0),我希望将其舍入到1.0。 [SH ...

7 在 numpy 中四舍五入到有效数字

我试过搜索这个,但找不到满意的答案。 我想获取一个数字列表/数组并将它们全部四舍五入为 n 个有效数字。 我已经写了一个函数来做到这一点,但我想知道是否有一个标准的方法? 我已经搜索过,但找不到。 例子: 谢谢 ...

8 四舍五入到任意数量的有效数字

如何将任何数字(不仅仅是整数 &gt; 0)四舍五入为 N 个有效数字? 例如,如果我想四舍五入到三位有效数字,我正在寻找一个可以采用的公式: 1,239,451 并返回 1,240,000 12.1257 并返回 12.1 .0681 并返回 .0681 5 并返回 5 自然地 ...

9 四舍五入有效数字规则

有什么方法可以将有效数字规则应用于Excel工作表,即从宏打印值? 还是以任何方式通过VBA宏计算出的值都通过有效数字规则,然后打印在excel表上? ...

暂无
暂无

声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.

 
粤ICP备18138465号  © 2020-2022 STACKOOM.COM