格式化没有尾随零的浮点数

Question

如何格式化浮点数以使其不包含尾随零？ 换句话说，我希望生成的字符串尽可能短。

例如：

3 -> "3"
3. -> "3"
3.0 -> "3"
3.1 -> "3.1"
3.14 -> "3.14"
3.140 -> "3.14"

Answer 1

我，我会这样做('%f' % x).rstrip('0').rstrip('.') -- 保证定点格式而不是科学记数法等。是的，没有那么圆滑和优雅作为%g ，但是，它有效（我不知道如何强制%g从不使用科学记数法；-）。

Answer 2

您可以使用%g来实现这一点：

'%g'%(3.140)

或者，使用 Python ≥ 2.6：

'{0:g}'.format(3.140)

或者，使用 Python ≥ 3.6：

f'{3.140:g}'

来自format的文档： g原因（除其他外）

[要]从有效数中删除无关紧要的尾随零，如果后面没有剩余数字，小数点也会被删除。

Answer 3

在查看了几个类似问题的答案后，这对我来说似乎是最好的解决方案：

def floatToString(inputValue):
    return ('%.15f' % inputValue).rstrip('0').rstrip('.')

我的推理：

%g没有摆脱科学记数法。

>>> '%g' % 0.000035
'3.5e-05'

15 位小数似乎避免了奇怪的行为，并且对我的需要有足够的精度。

>>> ('%.15f' % 1.35).rstrip('0').rstrip('.')
'1.35'
>>> ('%.16f' % 1.35).rstrip('0').rstrip('.')
'1.3500000000000001'

我可以使用format(inputValue, '.15f'). 而不是'%.15f' % inputValue ，但这有点慢（~30%）。

我本可以使用Decimal(inputValue).normalize() ，但这也有一些问题。 一方面，它慢了很多（~11x）。 我还发现，虽然它具有非常高的精度，但在使用normalize()时仍然会遭受精度损失。

>>> Decimal('0.21000000000000000000000000006').normalize()
Decimal('0.2100000000000000000000000001')
>>> Decimal('0.21000000000000000000000000006')
Decimal('0.21000000000000000000000000006')

最重要的是，我仍然会从float转换为Decimal ，这可能会使您最终得到除您输入的数字以外的其他内容。 我认为当算术保持在Decimal并且Decimal用字符串初始化时， Decimal效果最好。

>>> Decimal(1.35)
Decimal('1.350000000000000088817841970012523233890533447265625')
>>> Decimal('1.35')
Decimal('1.35')

我确定可以使用上下文设置将Decimal.normalize()的精度问题调整为所需的内容，但考虑到速度已经很慢并且不需要荒谬的精度以及我仍然会从浮点数转换并丢失的事实无论如何，我认为不值得追求。

我不关心可能的“-0”结果，因为 -0.0 是一个有效的浮点数，无论如何它可能很少发生，但是因为你确实提到你想保持字符串结果尽可能短，你总是可以以很少的额外速度成本使用额外的条件。

def floatToString(inputValue):
    result = ('%.15f' % inputValue).rstrip('0').rstrip('.')
    return '0' if result == '-0' else result

Answer 4

尝试最简单且可能最有效的方法怎么样？ 方法normalize()删除所有最右边的尾随零。

from decimal import Decimal

print (Decimal('0.001000').normalize())
# Result: 0.001

适用于Python 2和Python 3 。

- 更新 -

@BobStein-VisiBone 指出的唯一问题是，像 10、100、1000... 这样的数字将以指数表示形式显示。 这可以使用以下函数轻松修复：

from decimal import Decimal


def format_float(f):
    d = Decimal(str(f));
    return d.quantize(Decimal(1)) if d == d.to_integral() else d.normalize()

Answer 5

这是一个对我有用的解决方案。 它融合了PolyMesh的解决方案和使用新的.format() 语法。

for num in 3, 3., 3.0, 3.1, 3.14, 3.140:
    print('{0:.2f}'.format(num).rstrip('0').rstrip('.'))

输出：

3
3
3
3.1
3.14
3.14

Answer 6

您可以简单地使用 format() 来实现这一点：

format(3.140, '.10g')其中 10 是您想要的精度。

Answer 7

虽然格式化可能是大多数 Pythonic 的方式，但这里有一个使用more_itertools.rstrip工具的替代解决方案。

import more_itertools as mit


def fmt(num, pred=None):
    iterable = str(num)
    predicate = pred if pred is not None else lambda x: x in {".", "0"}
    return "".join(mit.rstrip(iterable, predicate))

assert fmt(3) == "3"
assert fmt(3.) == "3"
assert fmt(3.0) == "3"
assert fmt(3.1) == "3.1"
assert fmt(3.14) == "3.14"
assert fmt(3.140) == "3.14"
assert fmt(3.14000) == "3.14"
assert fmt("3,0", pred=lambda x: x in set(",0")) == "3"

该数字被转换为字符串，该字符串去除了满足谓词的尾随字符。 函数定义fmt不是必须的，但是这里用来测试断言，断言全部通过。 注意：它适用于字符串输入并接受可选谓词。

另请参阅有关此第三方库more_itertools详细信息。

Answer 8

>>> str(a if a % 1 else int(a))

Answer 9

使用QuantiPhy 包是一种选择。 通常在处理带有单位和 SI 比例因子的数字时会使用 QuantiPhy，但它具有多种不错的数字格式选项。

    >>> from quantiphy import Quantity

    >>> cases = '3 3. 3.0 3.1 3.14 3.140 3.14000'.split()
    >>> for case in cases:
    ...    q = Quantity(case)
    ...    print(f'{case:>7} -> {q:p}')
          3 -> 3
         3. -> 3
        3.0 -> 3
        3.1 -> 3.1
       3.14 -> 3.14
      3.140 -> 3.14
    3.14000 -> 3.14

在这种情况下它不会使用电子符号：

    >>> cases = '3.14e-9 3.14 3.14e9'.split()
    >>> for case in cases:
    ...    q = Quantity(case)
    ...    print(f'{case:>7} -> {q:,p}')
    3.14e-9 -> 0
       3.14 -> 3.14
     3.14e9 -> 3,140,000,000

您可能更喜欢的另一种方法是使用 SI 比例因子，可能带有单位。

    >>> cases = '3e-9 3.14e-9 3 3.14 3e9 3.14e9'.split()
    >>> for case in cases:
    ...    q = Quantity(case, 'm')
    ...    print(f'{case:>7} -> {q}')
       3e-9 -> 3 nm
    3.14e-9 -> 3.14 nm
          3 -> 3 m
       3.14 -> 3.14 m
        3e9 -> 3 Gm
     3.14e9 -> 3.14 Gm

Answer 10

答案如下：

import numpy

num1 = 3.1400
num2 = 3.000
numpy.format_float_positional(num1, 3, trim='-')
numpy.format_float_positional(num2, 3, trim='-')

输出“3.14”和“3”

trim='-'删除尾随零和小数。

Answer 11

OP 想要删除多余的零并使结果字符串尽可能短。

我发现 %g 指数格式缩短了非常大和非常小的值的结果字符串。 问题出现在不需要指数表示法的值上，例如 128.0，它既不是很大也不是很小。

这是将数字格式化为短字符串的一种方法，仅当 Decimal.normalize 创建太长的字符串时才使用 %g 指数表示法。 这可能不是最快的解决方案（因为它确实使用了 Decimal.normalize）

def floatToString (inputValue, precision = 3):
    rc = str(Decimal(inputValue).normalize())
    if 'E' in rc or len(rc) > 5:
        rc = '{0:.{1}g}'.format(inputValue, precision)        
    return rc

inputs = [128.0, 32768.0, 65536, 65536 * 2, 31.5, 1.000, 10.0]

outputs = [floatToString(i) for i in inputs]

print(outputs)

# ['128', '32768', '65536', '1.31e+05', '31.5', '1', '10']

Answer 12

对于浮动，你可以使用这个：

def format_float(num):
    return ('%i' if num == int(num) else '%s') % num

测试一下：

>>> format_float(1.00000)
'1'
>>> format_float(1.1234567890000000000)
'1.123456789'

对于十进制，请参见此处的解决方案： https : //stackoverflow.com/a/42668598/5917543

Answer 13

如果您可以忍受 3. 和 3.0 显示为“3.0”，这是一种非常简单的方法，可以从浮点表示中右删除零：

print("%s"%3.140)

（感谢@ellimilial 指出例外情况）

Answer 14

试试这个，它会允许你添加一个“精度”变量来设置你想要的小数位数。 只要记住它会四舍五入。 请注意，这仅在字符串中有小数时才有效。

 number = 4.364004650000000
 precision = 2
 result = "{:.{}f}".format(float(format(number).rstrip('0').rstrip('.')), precision)

输出

 4.364004650000000
 4.36

Answer 15

如果你想要一些既适用于数字输入又适用于字符串输入的东西：

def num(s):
    """ 3.0 -> 3, 3.001000 -> 3.001 otherwise return s """
    s = str(s)
    try:
        int(float(s))
        return s.rstrip('0').rstrip('.')
    except ValueError:
        return s

>>> for n in [3, 3., 3.0, 3.1, 3.14, 3.140, 3.001000 ]: print(num(n))
... 
3
3
3
3.1
3.14
3.14
3.001

>>> for n in [3, 3., 3.0, 3.1, 3.14, 3.140, 3.001000 ]: print(num(str(n)))
... 
3
3
3
3.1
3.14
3.14
3.001

Answer 16

您可以像这样使用max() ：

print(max(int(x), x))

Answer 17

"{:.5g}".format(x)

我用它来格式化浮点数以跟踪零。

Answer 18

使用宽度足够大的 %g，例如 '%.99g'。 对于任何相当大的数字，它将以定点表示法打印。

编辑：它不起作用

>>> '%.99g' % 0.0000001
'9.99999999999999954748111825886258685613938723690807819366455078125e-08'

Answer 19

您可以像这样以大多数pythonic方式实现这一目标：

蟒蛇3：

"{:0.0f}".format(num)

Answer 20

处理 %f 你应该把

%.2f

，其中： .2f == .00 浮点数。

例子：

打印“价格：%.2f”%价格[产品]

输出：

价格：1.50