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

例如：

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

我，我会做的('%f' % x).rstrip('0').rstrip('.')-保证定点格式，而不是科学记数法，等等等等呀，还不如光滑和优雅的%g，但是，它的工作原理（我不知道如何强制%g从不使用科学记数法; -）。

您可以%g用来实现以下目的：

'%g'%(3.140)

或者，对于Python 2.6或更高版本：

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

从文档中查找format：g原因（除其他外）

从有效数中删除不重要的尾随零，并且如果在其后没有剩余数字，则也删除小数点。

尝试最简单且可能最有效的方法呢？方法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()

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

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

最重要的是，我仍然会转换为Decimal从，float这样您最终可以得到的不是您输入的数字。我认为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

这是一个对我有用的解决方案。这是一个混合的解决方案通过多网并使用新的.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

您可以简单地使用format（）实现此目的：

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

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

尽管格式化可能是大多数Python方式，但这里是使用该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。

如果您可以将3.和3.0都显示为“ 3.0”，那么这是一种非常简单的方法，可将浮点数表示形式的零右移：

print("%s"%3.140)

（感谢@ellimilial指出例外）

您可以选择使用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

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']

对于float，您可以使用以下代码：

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

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

我用它来格式化浮点数以尾随零。

答案是：

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='-' 删除尾随零和小数。

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

编辑：这不起作用

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

您可以这样使用max()：

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

您可以通过以下大多数pythonic方式实现该目标：

python3：

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

处理％f，您应该放

％.2f

，其中：.2f == .00浮动。

例：

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

输出：

价格：1.50