关于python：将float转换为位置格式的字符串(没有科学计数法和错误的精度)

Convert float to string in positional format (without scientific notation and false precision)

我想打印一些浮点数，以便它们始终以十进制形式(例如12345000000000000000000.0或0.000000000000012345，而不是以科学计数法表示)，但我希望结果最多具有?15.7个有效数字仅是IEEE 754的两倍。

理想情况下，我想要的是结果是位置十进制格式的最短字符串，当转换为float时仍会产生相同的值。

众所周知，如果指数大于15或小于-4，则用科学计数法表示float的repr：

1
2
3

>>> n = 0.000000054321654321
>>> n
5.4321654321e-08 # scientific notation

如果使用str，则生成的字符串再次采用科学计数法：

1 2	>>> str(n) '5.4321654321e-08'

建议我可以将format与f标志一起使用，并具有足够的精度来摆脱科学计数法：

1 2	>>> format(0.00000005, '.20f') '0.00000005000000000000'

它适用于该数字，尽管它有一些额外的尾随零。但是随后.1的相同格式失败，它给出的十进制数字超出了float的实际机器精度：

1 2	>>> format(0.1, '.20f') '0.10000000000000000555'

如果我的电话号码是4.5678e-20，则使用.20f仍然会失去相对精度：

1 2	>>> format(4.5678e-20, '.20f') '0.00000000000000000005'

因此，这些方法不符合我的要求。

这就引出了一个问题：用十进制格式打印任意浮点数，与repr(n)(或Python 3中的str(n))具有相同数字的最简单且性能最佳的方法是什么，但始终使用十进制格式，而不是科学计数法。

也就是说，例如将浮点值0.00000005转换为字符串'0.00000005'的函数或操作； 0.1至'0.1'; 420000000000000000.0到'420000000000000000.0'或420000000000000000，并将浮点值-4.5678e-5格式化为'-0.000045678'。

在赏金期之后：似乎至少有2种可行的方法，正如Karin证明的那样，与我在Python 2上使用的初始算法相比，使用字符串操作可以显着提高速度。

从而，

如果性能很重要并且需要Python 2兼容性；或者如果decimal模块由于某种原因而无法使用，那么Karin使用字符串操作的方法就是这样做的方法。
在Python 3上，我稍短的代码也将更快。

由于我主要是在Python 3上进行开发，因此我将接受自己的回答，并奖励Karin。

相关讨论

如果您对这个问题有更好的答案，请与我们分享。
一个下雨天的项目：向Python添加一个低级库函数(可能在sys模块中)，该函数返回给定有限浮点数(即，数字字符串，十进制)的"原始"二进制到十进制转换结果指数，符号)。这将使人们能够自由选择自己认为合适的格式。
简短的回答：不，没有更简单的方法可以做到这一点；至少不是Im知道的，而且还可以给出精确的结果。 (任何涉及首先通过按10的幂进行缩放来预处理数字的解决方案，都有可能引入数字误差。)
由于您要求的精度是15.7个十进制数字?= 16个精度的十进制数字为什么您的示例要求精度20？
20不是精度而是规模！
您写了yet Id want to keep the 15.7 decimal digits of precision and no more.，当您谈到格式函数时，也没有像scale这样的术语，甚至您可能会提到同一件事：精度是一个十进制数字，指示对于a的小数点应显示多少个数字浮点值
@AnttiHaapala在您的所有示例中，精度应为16而不是20，也请从示例中删除4.5678e-20，因为您要求的精度为16
@ rusu_ro1这里有2种不同的格式在起作用：源是浮点数，而目标是定点表示。对我来说，OP似乎有兴趣将源格式的精度保持在给定的规格。
thx @IljaEveril，这意味着OP帖子不完整？
我不这样看，只需要一点阅读。

不幸的是，似乎连float.__format__的新格式都不支持此功能。 float的默认格式与repr相同。并带有f标志，默认情况下有6个小数位：

1 2	>>> format(0.0000000005, 'f') '0.000000'

但是，有一种技巧可以达到预期的效果-不是最快的，而是相对简单的：

首先使用str()或repr()将浮点数转换为字符串
然后从该字符串创建一个新的Decimal实例。
Decimal.__format__支持提供所需结果的f标志，并且与float s不同，它打印实际精度而不是默认精度。

因此，我们可以制作一个简单的效用函数float_to_str：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import decimal

# create a new context for this task
ctx = decimal.Context()

# 20 digits should be enough for everyone :D
ctx.prec = 20

def float_to_str(f):
"""
Convert the given float to a string,
without resorting to scientific notation
"""
d1 = ctx.create_decimal(repr(f))
return format(d1, 'f')

必须注意不要使用全局十进制上下文，因此将为此函数构造一个新的上下文。这是最快的方法。另一种方法是使用decimal.local_context，但是它会更慢，为每次转换创建一个新的线程本地上下文和上下文管理器。

现在，此函数返回带有尾数所有可能数字的字符串，四舍五入为最短的等效表示形式：

1
2
3
4
5
6
7
8

>>> float_to_str(0.1)
'0.1'
>>> float_to_str(0.00000005)
'0.00000005'
>>> float_to_str(420000000000000000.0)
'420000000000000000'
>>> float_to_str(0.000000000123123123123123123123)
'0.00000000012312312312312313'

最后的结果四舍五入到最后一位

正如@Karin所指出的，float_to_str(420000000000000000.0)与所期望的格式不完全匹配。它返回420000000000000000而不尾随.0。

相关讨论

为什么不使用decimal.localcontext？ with localcontext() as ctx: ctx.prec = 20; d1 = Decimal(str(f))
@Bakuriu为什么我只能慢一些
我在输出中看到0.000000000123123123123123123123123的精度损失-float_to_str输出仅以12位精度截止，不足以重建原始浮点数。
@ user2357112好抓住。您正在使用Python 2；在Python 2中，str仅具有12位精度，而repr使用Python 3兼容算法。在Python 3中，两种形式都是相似的，因此很混乱。我将代码更改为使用repr。

如果您对科学计数法的精度感到满意，那么我们可以采用简单的字符串操作方法吗？也许它不是非常聪明，但是它似乎可以工作(通过了您提供的所有用例)，并且我认为这是可以理解的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

def float_to_str(f):
float_string = repr(f)
if 'e' in float_string: # detect scientific notation
digits, exp = float_string.split('e')
digits = digits.replace('.', '').replace('-', '')
exp = int(exp)
zero_padding = '0' * (abs(int(exp)) - 1) # minus 1 for decimal point in the sci notation
sign = '-' if f < 0 else ''
if exp > 0:
float_string = '{}{}{}.0'.format(sign, digits, zero_padding)
else:
float_string = '{}0.{}{}'.format(sign, zero_padding, digits)
return float_string

n = 0.000000054321654321
assert(float_to_str(n) == '0.000000054321654321')

n = 0.00000005
assert(float_to_str(n) == '0.00000005')

n = 420000000000000000.0
assert(float_to_str(n) == '420000000000000000.0')

n = 4.5678e-5
assert(float_to_str(n) == '0.000045678')

n = 1.1
assert(float_to_str(n) == '1.1')

n = -4.5678e-5
assert(float_to_str(n) == '-0.000045678')

性能：

我担心这种方法可能太慢，因此我运行了timeit并将其与OP的十进制上下文解决方案进行了比较。看来字符串操作实际上要快得多。编辑：在Python 2中，它似乎只会快得多。在Python 3中，结果是相似的，但使用十进制方法会更快。

结果：

Python 2：使用ctx.create_decimal()：2.43655490875
Python 2：使用字符串操作：0.305557966232
Python 3：使用ctx.create_decimal()：0.19519368198234588
Python 3：使用字符串操作：0.2661344590014778

这是时间代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

from timeit import timeit

CODE_TO_TIME = '''
float_to_str(0.000000054321654321)
float_to_str(0.00000005)
float_to_str(420000000000000000.0)
float_to_str(4.5678e-5)
float_to_str(1.1)
float_to_str(-0.000045678)
'''
SETUP_1 = '''
import decimal

# create a new context for this task
ctx = decimal.Context()

# 20 digits should be enough for everyone :D
ctx.prec = 20

def float_to_str(f):
"""
Convert the given float to a string,
without resorting to scientific notation
"""
d1 = ctx.create_decimal(repr(f))
return format(d1, 'f')
'''
SETUP_2 = '''
def float_to_str(f):
float_string = repr(f)
if 'e' in float_string: # detect scientific notation
digits, exp = float_string.split('e')
digits = digits.replace('.', '').replace('-', '')
exp = int(exp)
zero_padding = '0' * (abs(int(exp)) - 1) # minus 1 for decimal point in the sci notation
sign = '-' if f < 0 else ''
if exp > 0:
float_string = '{}{}{}.0'.format(sign, digits, zero_padding)
else:
float_string = '{}0.{}{}'.format(sign, zero_padding, digits)
return float_string
'''

print(timeit(CODE_TO_TIME, setup=SETUP_1, number=10000))
print(timeit(CODE_TO_TIME, setup=SETUP_2, number=10000))

相关讨论

您实际上可以将初始化(def format_float; import decimal; ctx = ...)指定为timeit的第二个参数。这样，它就不会包含在测量中。
嗯，这从现在的文档来看似乎很明显。很高兴知道！香港专业教育学院更新了我的时间代码，现在看起来更加干净了：)
不过，我需要再添加一个案例进行测试。该数字可以为负，您的数字仍为n = -4.5678e-5； assert(format_float(n) == -0.000045678)错误地：D
还有另一个要点：在Python 2上，这比我的代码快得多，但是在Python 3上，它要慢一些。似乎在Python 3中，十进制构造函数的性能要比Python 2好得多。
我一直感到惊讶的是，天真的"只是将其字符串化"方法的工作频率，有时甚至比其他情况更好。
@Antti着迷！我可以确认您的方法在Python 3中必须比Python 2更快。但是，另一个怪异之处是，对于Python 2和3中的十进制方法，420000000000000000.0用例实际上对我而言是失败的。
@Karin是因为，如果decimal的位置似乎超过16，则不再有.0。
@Antti但是，它在您的答案示例用法中如何为您工作？
坦白说，我不记得返回的字符串没有.0，我没有从Python shell复制粘贴示例输出，而是在此处编写。好的收获：D我确定了答案。
decimal在Python 3.3中获得了多项速度改进(切换到libmpdec，缓存等)，从而使性能提高了10倍-100倍，具体取决于您要实现的目标。
卡琳(Karin)，不仅是您了解我所寻求的唯一答案，而且您还找到了一种巧妙的方法来使用在Python 2上表现出色的字符串操作来实现它。：D因此，我向您授予了赏金。但是，在这种情况下，我选择接受自己的回答，因为我们需要的项目使用Python 3，并且已经成功使用了我的方法。
(还有一件事，这应该使用repr而不是str以获得一致的结果Python 2 vs3。)
@Antti谢谢！这是一个有趣的用例：)还建议将我的代码更新为使用repr。
好的答案，但是老实说，我觉得这应该直接在python中实现，并且可以通过.format来实现。我不明白为什么.format不包括此用例。例如，以非科学符号打印带有有效数字的数字就需要这样的技巧。然而，我认为它是绘制具有短对数刻度的科学图形的极为普遍的用例。

从NumPy 1.14.0开始，您只能使用numpy.format_float_positional。例如，针对您问题的输入：

1
2
3
4
5
6
7
8

>>> numpy.format_float_positional(0.000000054321654321)
'0.000000054321654321'
>>> numpy.format_float_positional(0.00000005)
'0.00000005'
>>> numpy.format_float_positional(0.1)
'0.1'
>>> numpy.format_float_positional(4.5678e-20)
'0.000000000000000000045678'

numpy.format_float_positional使用Dragon4算法以位置格式生成最短的十进制表示形式，该格式将往返返回原始浮点输入。还有numpy.format_float_scientific用于科学计数法，并且两个函数都提供了可选参数来自定义诸如舍入和修剪零的东西。

相关讨论

嘿，太好了。如果不需要NumPy，这是不实际的，但是如果确实是NumPy，那肯定是应该使用的。
更好的答案。尽管我认为该功能应作为字符串的.format方法中的一个选项直接包括在内。在具有对数刻度的科学图中，具有显着数字限制的十进制表示形式是极为常见的用例。

如果您准备通过在浮点数上调用str()来失去任意精度，则可以采用以下方法：

1
2
3
4
5
6
7

import decimal

def float_to_string(number, precision=20):
return '{0:.{prec}f}'.format(
decimal.Context(prec=100).create_decimal(str(number)),
prec=precision,
).rstrip('0').rstrip('.') or '0'

它不包括全局变量，允许您自己选择精度。选择小数精度100作为str(float)长度的上限。实际的最高要低得多。 or '0'部分适用于数量少且精度为零的情况。

请注意，它仍然有其后果：

1 2	>> float_to_string(0.10101010101010101010101010101) '0.10101010101'

否则，如果精度很重要，则format就可以了：

1
2
3
4
5
6

import decimal

def float_to_string(number, precision=20):
return '{0:.{prec}f}'.format(
number, prec=precision,
).rstrip('0').rstrip('.') or '0'

它不会丢失调用str(f)时丢失的精度。
or

1
2
3
4
5
6
7
8
9
10
11
12

>> float_to_string(0.1, precision=10)
'0.1'
>> float_to_string(0.1)
'0.10000000000000000555'
>>float_to_string(0.1, precision=40)
'0.1000000000000000055511151231257827021182'

>>float_to_string(4.5678e-5)
'0.000045678'

>>float_to_string(4.5678e-5, precision=1)
'0'

无论如何，最大的小数位数是有限的，因为float类型本身有其限制并且不能表示很长的浮点数：

1 2	>> float_to_string(0.1, precision=10000) '0.1000000000000000055511151231257827021181583404541015625'

另外，整数按原样格式化。

1 2	>> float_to_string(100) '100'

相关讨论

根本不需要创建该十进制数，您的方法已经适用于float，但是错误精度的结果在问题中被拒绝。这些是四舍五入的测量结果，而不是一些任意的二进制分数。

我认为rstrip可以完成工作。

1
2
3

a=5.4321654321e-08
'{0:.40f}'.format(a).rstrip("0") # float number and delete the zeros on the right
# '0.0000000543216543210000004442039220863003' # there's roundoff error though

让我知道这是否适合您。

相关讨论

不幸的是，正如我在问题中指出的那样，我不希望由于这些残差部分恰好以二进制形式存储，因此不希望有任何剩余的分数部分。

有趣的问题，要增加更多的内容，这是一个比较@Antti Haapala和@Harold解决方案输出的测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

import decimal
import math

ctx = decimal.Context()

def f1(number, prec=20):
ctx.prec = prec
return format(ctx.create_decimal(str(number)), 'f')

def f2(number, prec=20):
return '{0:.{prec}f}'.format(
number, prec=prec,
).rstrip('0').rstrip('.')

k = 2*8

for i in range(-2**8,2**8):
if i<0:
value = -k*math.sqrt(math.sqrt(-i))
else:
value = k*math.sqrt(math.sqrt(i))

value_s = '{0:.{prec}E}'.format(value, prec=10)

n = 10

print ' | '.join([str(value), value_s])
for f in [f1, f2]:
test = [f(value, prec=p) for p in range(n)]
print '\t{0}'.format(test)

在所有情况下，它们都不给出"一致"的结果。

使用Anti's，您会看到类似" -000"或" 000"的字符串
使用Harolds，您会看到类似''的字符串

我宁愿一致性，即使我牺牲一点速度。取决于您要针对用例进行哪些权衡。

相关讨论

为什么您要调整我的方法的精度？我将其固定为20，以获得IEEE-754精度的所有15.7个十进制数字加倍。