轻松漂亮地打印浮点数？-IT科技

摘要：问题描述：我有一个浮点数列表。如果我简单print看一下，它会显示如下：[9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006] 我可以...

问题描述：

我有一个浮点数列表。如果我简单print看一下，它会显示如下：

[9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]

我可以使用print "%.2f"，这需要for循环来遍历列表，但它不适用于更复杂的数据结构。我想要类似的东西（我完全是编造的）

>>> import print_options
>>> print_options.set_float_precision(2)
>>> print [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]
[9.0, 0.05, 0.03, 0.01, 0.06, 0.08]

解决方案 1：

由于没有人添加它，应该注意，从 Python 2.6+ 开始，推荐使用来进行字符串格式化format，为 Python 3+ 做好准备。

print ["{0:0.2f}".format(i) for i in a]

新的字符串格式化语法并不难使用，而且功能非常强大。

我以为那可能pprint有什么用处，但我什么也没发现。

解决方案 2：

更持久的解决方案是子类化float：

>>> class prettyfloat(float):
    def __repr__(self):
        return "%0.2f" % self

>>> x
[1.290192, 3.0002, 22.119199999999999, 3.4110999999999998]
>>> x = map(prettyfloat, x)
>>> x
[1.29, 3.00, 22.12, 3.41]
>>> y = x[2]
>>> y
22.12

子类化的问题float在于它会破坏明确查找变量类型的代码。但据我所知，这是唯一的问题。一个简单的方法就x = map(float, x)可以撤消对的转换prettyfloat。

可悲的是，你不能只对进行 monkey-patch float.__repr__，因为float是不可变的。

如果你不想子类化float，但不介意定义一个函数，map(f, x)那么比[f(n) for n in x]

解决方案 3：

您可以执行以下操作：

a = [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]
print ["%0.2f" % i for i in a]

解决方案 4：

这是一个老问题，但我想补充一些可能有用的内容：

我知道您使用原始 Python 列表编写了示例，但如果您决定使用numpy数组（这在您的示例中是完全合法的，因为您似乎正在处理数字数组），那么就有（几乎完全）您所说的您编写的这个命令：

import numpy as np
np.set_printoptions(precision=2)

或者，如果您仍然想看到真正精确的数字的所有小数，但去掉尾随零，那么更好的方法是使用格式字符串%g：

np.set_printoptions(formatter={"float_kind": lambda x: "%g" % x})

如果只打印一次而不改变全局行为，请使用np.array2string与上面相同的参数。

解决方案 5：

请注意，您还可以乘以像“%.2f”这样的字符串（例如：“%.2f”*10）。

>>> print "%.2f "*len(yourlist) % tuple(yourlist)
2.00 33.00 4.42 0.31

解决方案 6：

最简单的选择应该是使用舍入程序：

import numpy as np
x=[9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]

print('standard:')
print(x)
print("
human readable:")
print(np.around(x,decimals=2))

输出结果如下：

standard:
[9.0, 0.053, 0.0325754, 0.0108928, 0.0557025, 0.0793303]

human readable:
[ 9.    0.05  0.03  0.01  0.06  0.08]

解决方案 7：

l = [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]

Python 2：

print ', '.join('{:0.2f}'.format(i) for i in l)

Python 3：

print(', '.join('{:0.2f}'.format(i) for i in l))

输出：

9.00, 0.05, 0.03, 0.01, 0.06, 0.08

解决方案 8：

print "[%s]"%", ".join(map(str,yourlist))

这将避免打印时二进制表示中的舍入错误，而不会引入固定精度约束（如使用格式化"%.2f"）：

[9.0, 0.053, 0.0325754, 0.0108928, 0.0557025, 0.0793303]

解决方案 9：

要控制有效数字的数量，请使用格式说明符 %g。

我们将 Emile 的解决方案命名为 prettylist2f。以下是修改后的解决方案：

prettylist2g = lambda l : '[%s]' % ', '.join("%.2g" % x for x in l)

用法：

>>> c_e_alpha_eps0 = [299792458., 2.718281828, 0.00729735, 8.8541878e-12]
>>> print(prettylist2f(c_e_alpha_eps0)) # [299792458.00, 2.72, 0.01, 0.00]
>>> print(prettylist2g(c_e_alpha_eps0)) # [3e+08, 2.7, 0.0073, 8.9e-12]

如果您希望有效数字的数量具有灵活性，请改用f 字符串格式：

prettyflexlist = lambda p, l : '[%s]' % ', '.join(f"{x:.{p}}" for x in l)
print(prettyflexlist(3,c_e_alpha_eps0)) # [3e+08, 2.72, 0.0073, 8.85e-12]

解决方案 10：

从 Python 3.6 开始，你可以使用 f 字符串：

list_ = [9.0, 0.052999999999999999, 
         0.032575399999999997, 0.010892799999999999, 
         0.055702500000000002, 0.079330300000000006]

print(*[f"{element:.2f}" for element in list_])
#9.00 0.05 0.03 0.01 0.06 0.08

您可以使用打印参数，同时保持代码的可读性：

print(*[f"{element:.2f}" for element in list_], sep='|', end='<--')
#9.00|0.05|0.03|0.01|0.06|0.08<--

解决方案 11：

我相信 Python 3.1 默认会打印得更好，无需更改任何代码。但如果你使用任何未更新为与 Python 3.1 兼容的扩展，那就没用了

解决方案 12：

列表组合是你的朋友。

print ", ".join("%.2f" % f for f in list_o_numbers)

尝试一下：

>>> nums = [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999]
>>> print ", ".join("%.2f" % f for f in nums)
9.00, 0.05, 0.03, 0.01

解决方案 13：

a = [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]
print(", ".join(f'{x:.2f}' for x in a))

f'{x}'表示 f 字符串等于str(x)；f'{x:.2f}'表示x将以带有两位小数的浮点数形式出现。

解决方案 14：

你可以使用熊猫。

以下是一个带有列表的示例：

In: import pandas as P
In: P.set_option('display.precision',3)
In: L = [3.4534534, 2.1232131, 6.231212, 6.3423423, 9.342342423]
In: P.Series(data=L)
Out: 
0    3.45
1    2.12
2    6.23
3    6.34
4    9.34
dtype: float64

如果你有一个字典 d，并且你想将它的键作为行：

In: d
Out: {1: 0.453523, 2: 2.35423234234, 3: 3.423432432, 4: 4.132312312}

In: P.DataFrame(index=d.keys(), data=d.values())
Out:  
    0
1   0.45
2   2.35
3   3.42
4   4.13

将 dict 赋给 DataFrame 的另一种方法：

P.DataFrame.from_dict(d, orient='index')

解决方案 15：

首先，集合内的元素打印它们的代表。您应该了解__repr__和__str__。

这就是 print repr(1.1) 和 print 1.1 的区别。让我们连接所有这些字符串而不是表示形式：

numbers = [9.0, 0.053, 0.0325754, 0.0108928, 0.0557025, 0.07933]
print "repr:", " ".join(repr(n) for n in numbers)
print "str:", " ".join(str(n) for n in numbers)

解决方案 16：

我在尝试使用 pprint 输出浮点元组列表时遇到了这个问题。嵌套理解可能不是一个好主意，但我做了以下事情：

tups = [
        (12.0, 9.75, 23.54),
        (12.5, 2.6, 13.85),
        (14.77, 3.56, 23.23),
        (12.0, 5.5, 23.5)
       ]
pprint([['{0:0.02f}'.format(num) for num in tup] for tup in tups])

我首先使用生成器表达式，但是 pprint 只是重复了生成器......

解决方案 17：

我遇到了这个问题，但是这里没有任何解决方案能够完全满足我的要求（我希望打印的输出是一个有效的 python 表达式），那么这个怎么样：

prettylist = lambda l : '[%s]' % ', '.join("%.2f" % f for f in l)

用法：

>>> ugly = [9.0, 0.052999999999999999, 0.032575399999999997,
            0.010892799999999999, 0.055702500000000002, 0.079330300000000006]
>>> prettylist = lambda l : '[%s]' % ', '.join("%.2f" % f for f in l)
>>> print prettylist(ugly)
[9.00, 0.05, 0.03, 0.01, 0.06, 0.08]

（我知道 .format() 应该是更标准的解决方案，但我发现这个更具可读性）

解决方案 18：

我同意 SilentGhost 的评论，for 循环并没有那么糟糕。你可以用以下方法实现你想要的效果：

l = [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]
for x in l: print "%0.2f" % (x)

解决方案 19：

下面的代码对我来说很好用。

list = map (lambda x: float('%0.2f' % x), list)