将浮点数限制为两位小数

Question

我希望将 a 四舍五入为13.95.我尝试使用round，但我得到：

>>> a
13.949999999999999
>>> round(a, 2)
13.949999999999999

---

_{对于标准库 Decimal 类的类似问题，请参阅How can I format a decimal to always show 2 decimal places?。}

Answer 1

您遇到了带有浮点数的 old problem，并非所有数字都可以准确表示。命令行只是向您显示内存中的完整浮点形式。

使用浮点表示，您的舍入版本是相同的数字。由于计算机是二进制的，它们将浮点数存储为整数，然后将其除以 2 的幂，因此 13.95 将以类似于 125650429603636838/(2**53) 的方式表示。

双精度数具有 53 位（16 位）的精度，而常规浮点数具有 24 位（8 位）的精度。 floating point type in Python uses double precision 用于存储值。

例如，

>>> 125650429603636838/(2**53)
13.949999999999999

>>> 234042163/(2**24)
13.949999988079071

>>> a = 13.946
>>> print(a)
13.946
>>> print("%.2f" % a)
13.95
>>> round(a,2)
13.949999999999999
>>> print("%.2f" % round(a, 2))
13.95
>>> print("{:.2f}".format(a))
13.95
>>> print("{:.2f}".format(round(a, 2)))
13.95
>>> print("{:.15f}".format(round(a, 2)))
13.949999999999999

如果您只在小数点后两位（例如显示货币值），那么您有几个更好的选择：

1. 使用整数并以分而不是美元存储值，然后除以 100 以转换为美元。
2. 或使用固定点数，如decimal。

Answer 2

有新的格式规范，String Format Specification Mini-Language：

您可以执行以下操作：

"{:.2f}".format(13.949999999999999)

注一：以上返回一个字符串。为了获得浮动，只需用float(...)包裹：

float("{:.2f}".format(13.949999999999999))

笔记2：用 float() 包装不会改变任何东西：

>>> x = 13.949999999999999999
>>> x
13.95
>>> g = float("{:.2f}".format(x))
>>> g
13.95
>>> x == g
True
>>> h = round(x, 2)
>>> h
13.95
>>> x == h
True

Answer 3

内置的 round() 在 Python 2.7 或更高版本中工作得很好。

例子：

>>> round(14.22222223, 2)
14.22

查看the documentation。

Answer 4

让我举一个 Python 3.6 的 f-string/template-string 格式的例子，我认为它非常简洁：

>>> f'{a:.2f}'

它也适用于更长的示例，使用运算符并且不需要括号：

>>> print(f'Completed in {time.time() - start:.2f}s')

Answer 5

我觉得最简单的方法是使用format()函数。

例如：

a = 13.949999999999999
format(a, '.2f')

13.95

这将生成一个浮点数作为四舍五入到两位小数的字符串。

Answer 6

大多数数字不能用浮点数精确表示。如果你想四舍五入这个数字，因为这是你的数学公式或算法所需要的，那么你想使用四舍五入。如果您只是想将显示限制在一定的精度，那么甚至不要使用 round 并将其格式化为该字符串。 （如果你想用一些替代的舍入方法显示它，并且有吨，那么你需要混合这两种方法。）

>>> "%.2f" % 3.14159
'3.14'
>>> "%.2f" % 13.9499999
'13.95'

最后，也许是最重要的，如果你想精确的数学那么你根本不需要花车。通常的例子是处理金钱并将“美分”存储为整数。

Answer 7

使用

print"{:.2f}".format(a)

代替

print"{0:.2f}".format(a)

因为后者在尝试输出多个变量时可能会导致输出错误（参见cmets）。

Answer 8

试试下面的代码：

>>> a = 0.99334
>>> a = int((a * 100) + 0.5) / 100.0 # Adding 0.5 rounds it up
>>> print a
0.99

Answer 9

TLDR ;）

输入输出的舍入问题由 Python 3.1 最终解决并且修复程序也被反向移植到 Python 2.7.0。

四舍五入的数字可以在 float 和 string 之间可逆地转换来回：
str -> float() -> repr() -> float() ...或Decimal -> float -> str -> Decimal

>>> 0.3
0.3
>>> float(repr(0.3)) == 0.3
True

Decimal 类型不再需要存储。

算术运算的结果必须再次四舍五入因为舍入错误可能会累积更多的不准确性，而不是解析一个数字后可能出现的情况。改进后的repr() 算法（Python >= 3.1，>= 2.7.0）没有解决这个问题：

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

---

输出字符串函数 str(float(...)) 在 Python < 2.7x 和 < 3.1 中四舍五入为 12 个有效数字，以防止类似于不固定的 repr() 输出的过多无效数字。在减去非常相似的数字后仍然不够，并且在其他操作后它过于四舍五入。 Python 2.7 和 3.1 使用相同长度的 str() 尽管 repr() 是固定的。一些旧版本的 Numpy 也有过多的无效数字，即使是固定的 Python。当前的 Numpy 是固定的。 Python 版本 >= 3.2 具有相同的 str() 和 repr() 函数结果以及 Numpy 中类似函数的输出。

---

测试

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

---

文档

见Release notes Python 2.7 - Other Language Changes第四段：

转换现在浮点数和字符串之间正确四舍五入在大多数平台上。这些转换发生在许多不同的地方：浮点数和复数上的 str()； float 和 complex 构造函数；数字格式；使用marshal、pickle和json模块对浮点数和复数进行序列化和反序列化；解析 Python 代码中的浮点数和虚数；和十进制到浮点数的转换。

与此相关的是代表（）浮点数 x 现在返回一个基于保证四舍五入到 x 的最短十进制字符串在正确的舍入下（使用四舍五入到四舍五入模式）。以前它给出了一个基于将 x 舍入为 17 位十进制数字的字符串。

The related issue

---

更多信息：Python 2.7 之前float 的格式类似于当前的numpy.float64。两种类型都使用相同的 64 位 IEEE 754 双精度和 52 位尾数。一个很大的区别是 np.float64.__repr__ 经常使用过多的十进制数字进行格式化，因此不会丢失任何位，但在 13.949999999999999 和 13.950000000000001 之间不存在有效的 IEEE 754 数字。结果不好，并且转换 repr(float(number_as_string)) 对于 numpy 是不可逆的。另一方面：float.__repr__ 的格式使得每个数字都很重要；序列没有间隙，转换是可逆的。很简单：如果您可能有一个 numpy.float64 数字，请将其转换为普通浮点数以便为人类格式化，而不是为数字处理器格式化，否则 Python 2.7+ 不需要更多。

Answer 10

使用：

float_number = 12.234325335563
round(float_number, 2)

这将返回；

12.23

解释：

这圆形的函数有两个参数； 要四舍五入的数字和要返回的小数位数。这里我返回了两位小数。

Answer 11

您可以修改输出格式：

>>> a = 13.95
>>> a
13.949999999999999
>>> print "%.2f" % a
13.95

Answer 12

对于 Python < 3（例如 2.6 或 2.7），有两种方法可以做到这一点。

# Option one 
older_method_string = "%.9f" % numvar

# Option two (note ':' before the '.9f')
newer_method_string = "{:.9f}".format(numvar)

但请注意，对于高于 3 的 Python 版本（例如 3.2 或 3.3），选项二是 preferred。

有关选项二的更多信息，我建议使用string formatting from the Python documentation 上的此链接。

有关选项一的更多信息，this link will suffice and has information on the various flags。

参考：Convert floating point number to a certain precision, and then copy to string

Answer 13

您可以使用 format 运算符在 Python 中将值四舍五入到小数点后两位：

print(format(14.4499923, '.2f')) // The output is 14.45

Answer 14

作为Matt pointed out，Python 3.6 提供了f-strings，他们也可以使用nested parameters：

value = 2.34558
precision = 2
width = 4

print(f'result: {value:{width}.{precision}f}')

这将显示result: 2.35

Answer 15

在 Python 2.7 中：

a = 13.949999999999999
output = float("%0.2f"%a)
print output

Answer 16

我们有多种选择来做到这一点：

选项1：

x = 1.090675765757
g = float("{:.2f}".format(x))
print(g)

选项 2： 内置的 round() 支持 Python 2.7 或更高版本。

x = 1.090675765757
g = round(x, 2)
print(g)

Answer 17

Python 教程有一个名为Floating Point Arithmetic: Issues and Limitations.阅读。它解释了正在发生的事情以及为什么 Python 正在竭尽全力。它甚至有一个与您的示例相匹配的示例。让我引用一点：

>>> 0.1
0.10000000000000001

你可能想使用round() 功能将其切回单 你期望的数字。但这使得不 不同之处：

>>> round(0.1, 1)
0.10000000000000001

问题是二进制 为“0.1”存储的浮点值 已经是最好的二进制文件 近似于1/10，所以试图 再次四舍五入不能让它变得更好： 它已经很好了。

另一个结果是因为0.1 不完全是1/10，总结十 0.1 的值可能不会完全产生 1.0，要么：

>>> sum = 0.0
>>> for i in range(10):
...     sum += 0.1
...
>>> sum
0.99999999999999989

您的问题的一种替代方法和解决方案是使用 decimal 模块。

Answer 18

使用 Decimal 对象和 round() 方法的组合。

Python 3.7.3
>>> from decimal import Decimal
>>> d1 = Decimal (13.949999999999999) # define a Decimal
>>> d1 
Decimal('13.949999999999999289457264239899814128875732421875')
>>> d2 = round(d1, 2) # round to 2 decimals
>>> d2
Decimal('13.95')

Answer 19

它完全按照您的指示进行操作并且工作正常。阅读更多关于 floating point confusion 的信息，也许可以试试 decimal 对象。

Answer 20

from decimal import Decimal


def round_float(v, ndigits=2, rt_str=False):
    d = Decimal(v)
    v_str = ("{0:.%sf}" % ndigits).format(round(d, ndigits))
    if rt_str:
        return v_str
    return Decimal(v_str)

结果：

Python 3.6.1 (default, Dec 11 2018, 17:41:10)
>>> round_float(3.1415926)
Decimal('3.14')
>>> round_float(3.1445926)
Decimal('3.14')
>>> round_float(3.1455926)
Decimal('3.15')
>>> round_float(3.1455926, rt_str=True)
'3.15'
>>> str(round_float(3.1455926))
'3.15'

Answer 21

简单的解决方案在这里

value = 5.34343
rounded_value = round(value, 2) # 5.34

Answer 22

使用这样的 lambda 函数：

arred = lambda x,n : x*(10**n)//1/(10**n)

这样你就可以这样做：

arred(3.141591657, 2)

并得到

3.14

Answer 23

orig_float = 232569 / 16000.0

14.5355625

short_float = float("{:.2f}".format(orig_float)) 

14.54

Answer 24

为了修复 Python 和 JavaScript 等类型动态语言中的浮点数，我使用了这种技术

# For example:
a = 70000
b = 0.14
c = a * b

print c # Prints 980.0000000002
# Try to fix
c = int(c * 10000)/100000
print c # Prints 980

您还可以使用 Decimal，如下所示：

from decimal import *
getcontext().prec = 6
Decimal(1) / Decimal(7)
# Results in 6 precision -> Decimal('0.142857')

getcontext().prec = 28
Decimal(1) / Decimal(7)
# Results in 28 precision -> Decimal('0.1428571428571428571428571429')

Answer 25

很简单，就像：

1. 使用decimal模块进行快速正确舍入的十进制浮点运算：

    d = Decimal(10000000.0000009)
   

   实现舍入：

    d.quantize(Decimal('0.01'))
   

   结果为Decimal('10000000.00')

2. 制作以上DRY：

   def round_decimal(number, exponent='0.01'):
       decimal_value = Decimal(number)
       return decimal_value.quantize(Decimal(exponent))
   

   或者

   def round_decimal(number, decimal_places=2):
       decimal_value = Decimal(number)
       return decimal_value.quantize(Decimal(10) ** -decimal_places)
   

   PS：批评别人：格式化不是四舍五入。

Answer 26

这是使用的简单解决方案format功能。

float(format(num, '.2f'))

笔记：我们正在将数字转换为浮点数，因为格式化方法返回的是字符串。

Answer 27

如果你想处理钱，使用 Python decimal 模块：

from decimal import Decimal, ROUND_HALF_UP

# 'amount' can be integer, string, tuple, float, or another Decimal object
def to_money(amount) -> Decimal:
    money = Decimal(amount).quantize(Decimal('.00'), rounding=ROUND_HALF_UP)
    return money

Answer 28

lambda x, n:int(x*10^n + 0.5)/10^n

为我工作过许多多年使用多种语言。

Answer 29

要将数字四舍五入为分辨率，最好的方法是以下方法，它适用于任何分辨率（两位小数或什至其他步长为 0.01）：

>>> import numpy as np
>>> value = 13.949999999999999
>>> resolution = 0.01
>>> newValue = int(np.round(value/resolution))*resolution
>>> print newValue
13.95

>>> resolution = 0.5
>>> newValue = int(np.round(value/resolution))*resolution
>>> print newValue
14.0

Answer 30

我看到的答案不适用于 float(52.15) 案例。经过一些测试，我正在使用的解决方案是：

import decimal
        
def value_to_decimal(value, decimal_places):
    decimal.getcontext().rounding = decimal.ROUND_HALF_UP  # define rounding method
    return decimal.Decimal(str(float(value))).quantize(decimal.Decimal('1e-{}'.format(decimal_places)))

（'value' 转换为 float 和 string 非常重要，这样，'value' 可以是 float、decimal、integer 或 string 类型！）

希望这对任何人都有帮助。