如何格式化小数以始终显示小数点后 2 位?

发布于 2024-08-16 07:04:12 字数 357 浏览 4 评论 0原文

我想显示:

4949.00

和:

54.954.90

无论小数长度或是否有小数位,我想显示一个有 2 位小数的 Decimal,并且我想以有效的方式做到这一点。目的是显示金钱价值。

例如,4898489.00


对于内置float类型的类似问题,请参阅将浮点数限制为小数点后两位

I want to display:

49 as 49.00

and:

54.9 as 54.90

Regardless of the length of the decimal or whether there are are any decimal places, I would like to display a Decimal with 2 decimal places, and I'd like to do it in an efficient way. The purpose is to display money values.

eg, 4898489.00


For the analogous issue with the built-in float type, see Limiting floats to two decimal points.

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(14

爱*していゐ 2024-08-23 07:04:12

您应该使用 新的格式规范来定义如何表示您的值:

>>> from math import pi  # pi ~ 3.141592653589793
>>> '{0:.2f}'.format(pi)
'3.14'

该文档有时可能有点迟钝,因此我推荐以下更易于阅读的参考:

Python 3.6 引入 文字字符串插值(也称为 f-strings),所以现在你可以写更多上面的内容简洁为:

>>> f'{pi:.2f}'
'3.14'

You should use the new format specifications to define how your value should be represented:

>>> from math import pi  # pi ~ 3.141592653589793
>>> '{0:.2f}'.format(pi)
'3.14'

The documentation can be a bit obtuse at times, so I recommend the following, easier readable references:

Python 3.6 introduced literal string interpolation (also known as f-strings) so now you can write the above even more succinct as:

>>> f'{pi:.2f}'
'3.14'
小姐丶请自重 2024-08-23 07:04:12

字符串格式化操作 部分Python 文档包含您正在寻找的答案。简而言之:

"%0.2f" % (num,)

一些例子:

>>> "%0.2f" % 10
'10.00'
>>> "%0.2f" % 1000
'1000.00'
>>> "%0.2f" % 10.1
'10.10'
>>> "%0.2f" % 10.120
'10.12'
>>> "%0.2f" % 10.126
'10.13'

The String Formatting Operations section of the Python documentation contains the answer you're looking for. In short:

"%0.2f" % (num,)

Some examples:

>>> "%0.2f" % 10
'10.00'
>>> "%0.2f" % 1000
'1000.00'
>>> "%0.2f" % 10.1
'10.10'
>>> "%0.2f" % 10.120
'10.12'
>>> "%0.2f" % 10.126
'10.13'
终难遇 2024-08-23 07:04:12

我想您可能正在使用 来自十进制模块? (如果您需要任意大数字的小数点后精确两位数的精度,那么您绝对应该这样做,这就是您的问题标题所暗示的......)

如果是这样,则 Decimal FAQ 文档部分有一个问题/答案对这可能对你有用:

问。在具有两位小数的定点应用程序中,某些输入有很多位,需要四舍五入。其他的不应该有多余的数字,需要进行验证。应该使用什么方法?

A. quantize() 方法四舍五入到固定的小数位数。如果设置了 Inexact 陷阱,它对于验证也很有用:

>>> TWOPLACES = Decimal(10) ** -2       # same as Decimal('0.01')
>>> # Round to two places
>>> Decimal('3.214').quantize(TWOPLACES)
Decimal('3.21')
>>> # Validate that a number does not exceed two places
>>> Decimal('3.21').quantize(TWOPLACES, context=Context(traps=[Inexact]))
Decimal('3.21')
>>> Decimal('3.214').quantize(TWOPLACES, context=Context(traps=[Inexact]))
Traceback (most recent call last):
   ...
Inexact: None

下一个问题是

问。一旦我有了有效的两位输入,我如何在整个应用程序中保持这种不变性?

如果您需要答案(以及许多其他有用的信息),请参阅 文档的上述部分。另外,如果您将 Decimal 保留为小数点以外两位数的精度(意味着将所有数字保留在小数点左侧和小数点右侧两位数所需的精度)就这样了……),然后用 str 将它们转换为字符串就可以正常工作:

str(Decimal('10'))
# -> '10'
str(Decimal('10.00'))
# -> '10.00'
str(Decimal('10.000'))
# -> '10.000'

I suppose you're probably using the Decimal() objects from the decimal module? (If you need exactly two digits of precision beyond the decimal point with arbitrarily large numbers, you definitely should be, and that's what your question's title suggests...)

If so, the Decimal FAQ section of the docs has a question/answer pair which may be useful for you:

Q. In a fixed-point application with two decimal places, some inputs have many places and need to be rounded. Others are not supposed to have excess digits and need to be validated. What methods should be used?

A. The quantize() method rounds to a fixed number of decimal places. If the Inexact trap is set, it is also useful for validation:

>>> TWOPLACES = Decimal(10) ** -2       # same as Decimal('0.01')
>>> # Round to two places
>>> Decimal('3.214').quantize(TWOPLACES)
Decimal('3.21')
>>> # Validate that a number does not exceed two places
>>> Decimal('3.21').quantize(TWOPLACES, context=Context(traps=[Inexact]))
Decimal('3.21')
>>> Decimal('3.214').quantize(TWOPLACES, context=Context(traps=[Inexact]))
Traceback (most recent call last):
   ...
Inexact: None

The next question reads

Q. Once I have valid two place inputs, how do I maintain that invariant throughout an application?

If you need the answer to that (along with lots of other useful information), see the aforementioned section of the docs. Also, if you keep your Decimals with two digits of precision beyond the decimal point (meaning as much precision as is necessary to keep all digits to the left of the decimal point and two to the right of it and no more...), then converting them to strings with str will work fine:

str(Decimal('10'))
# -> '10'
str(Decimal('10.00'))
# -> '10.00'
str(Decimal('10.000'))
# -> '10.000'
雨落星ぅ辰 2024-08-23 07:04:12
>>> print "{:.2f}".format(1.123456)
1.12

您可以将 2f 中的 2 更改为您想要显示的任意位数的小数点。

编辑:

Python3.6,这转换为:

>>> print(f"{1.1234:.2f}")
1.12
>>> print "{:.2f}".format(1.123456)
1.12

You can change 2 in 2f to any number of decimal points you want to show.

EDIT:

From Python3.6, this translates to:

>>> print(f"{1.1234:.2f}")
1.12
写给空气的情书 2024-08-23 07:04:12

您可以使用字符串格式化运算符 因此:

num = 49
x = "%.2f" % num  # x is now the string "49.00"

我不确定你所说的“高效”是什么意思——这几乎肯定不是你的应用程序的瓶颈。如果您的程序运行缓慢,请首先对其进行分析以找到热点,然后对其进行优化。

You can use the string formatting operator as so:

num = 49
x = "%.2f" % num  # x is now the string "49.00"

I'm not sure what you mean by "efficient" -- this is almost certainly not the bottleneck of your application. If your program is running slowly, profile it first to find the hot spots, and then optimize those.

跨年 2024-08-23 07:04:12

.format 是一种更易读的处理变量格式的方法:

'{:.{prec}f}'.format(26.034, prec=2)

.format is a more readable way to handle variable formatting:

'{:.{prec}f}'.format(26.034, prec=2)
羁〃客ぐ 2024-08-23 07:04:12

在 python 3 中,这样做的一种方法是

'{:.2f}'.format(number)

In python 3, a way of doing this would be

'{:.2f}'.format(number)
開玄 2024-08-23 07:04:12

OP 总是希望显示两位小数,因此像所有其他答案一样显式调用格式化函数还不够好。

正如其他人已经指出的那样,Decimal 对于货币来说效果很好。但是 Decimal 显示所有小数位。因此,覆盖其显示格式化程序:

class D(decimal.Decimal):
    def __str__(self):
        return f'{self:.2f}'  

用法:

>>> cash = D(300000.991)
>>> print(cash)
300000.99

简单。

编辑:

要显示至少两位小数,但截断有效数字:

class D(decimal.Decimal):
    def __str__(self):
        """Display at least two decimal places."""
        result = str(self)
        i = result.find('.')
        if i == -1:
             # No '.' in self. Pad with '.00'.
             result += '.00'
        elif len(result[i:]) == 2:
             # One digit after the decimal place. Pad with a '0'.
             result += '0'
        return result

我希望Python的未来版本能够改进数字格式以允许最小小数位。类似于 Excel 数字格式中的 # 符号。

The OP always wants two decimal places displayed, so explicitly calling a formatting function, as all the other answers have done, is not good enough.

As others have already pointed out, Decimal works well for currency. But Decimal shows all the decimal places. So, override its display formatter:

class D(decimal.Decimal):
    def __str__(self):
        return f'{self:.2f}'  

Usage:

>>> cash = D(300000.991)
>>> print(cash)
300000.99

Simple.

EDIT:

To display at least two decimal places but without truncating significant digits:

class D(decimal.Decimal):
    def __str__(self):
        """Display at least two decimal places."""
        result = str(self)
        i = result.find('.')
        if i == -1:
             # No '.' in self. Pad with '.00'.
             result += '.00'
        elif len(result[i:]) == 2:
             # One digit after the decimal place. Pad with a '0'.
             result += '0'
        return result

I hope that a future version of Python will improve the number formatting to allow minimum decimal places. Something like the # sign in Excel's number formatting.

甜中书 2024-08-23 07:04:12

如果你有多个参数,你可以使用

 print('some string {0:.2f} & {1:.2f}'.format(1.1234,2.345))
 >>> some string 1.12 & 2.35

if you have multiple parameters you can use

 print('some string {0:.2f} & {1:.2f}'.format(1.1234,2.345))
 >>> some string 1.12 & 2.35
寂寞美少年 2024-08-23 07:04:12

如果您将其用于货币,并且还希望该值由 , 分隔,您可以使用

$ {:,.f2}.format(currency_value)

例如:

currency_value = 1234.50

$ {:,.f2}.format(currency_value) --> < code>$ 1,234.50

这是我前段时间写的一些代码:

print("> 年底 " +year_string + " 支付的总金额为 \t$ {:,.2f} “.format(total_paid))

> At the end of year   1  total paid is         $ 43,806.36
> At the end of year   2  total paid is         $ 87,612.72
> At the end of year   3  total paid is         $ 131,419.08
> At the end of year   4  total paid is         $ 175,225.44
> At the end of year   5  total paid is         $ 219,031.80   <-- Note .80 and not .8
> At the end of year   6  total paid is         $ 262,838.16
> At the end of year   7  total paid is         $ 306,644.52
> At the end of year   8  total paid is         $ 350,450.88
> At the end of year   9  total paid is         $ 394,257.24
> At the end of year  10  total paid is         $ 438,063.60   <-- Note .60 and not .6
> At the end of year  11  total paid is         $ 481,869.96
> At the end of year  12  total paid is         $ 525,676.32
> At the end of year  13  total paid is         $ 569,482.68
> At the end of year  14  total paid is         $ 613,289.04
> At the end of year  15  total paid is         $ 657,095.40   <-- Note .40 and not .4  
> At the end of year  16  total paid is         $ 700,901.76
> At the end of year  17  total paid is         $ 744,708.12
> At the end of year  18  total paid is         $ 788,514.48
> At the end of year  19  total paid is         $ 832,320.84
> At the end of year  20  total paid is         $ 876,127.20   <-- Note .20 and not .2

If you're using this for currency, and also want the value to be seperated by ,'s you can use

$ {:,.f2}.format(currency_value).

e.g.:

currency_value = 1234.50

$ {:,.f2}.format(currency_value) --> $ 1,234.50

Here is a bit of code I wrote some time ago:

print("> At the end of year " + year_string + " total paid is \t$ {:,.2f}".format(total_paid))

> At the end of year   1  total paid is         $ 43,806.36
> At the end of year   2  total paid is         $ 87,612.72
> At the end of year   3  total paid is         $ 131,419.08
> At the end of year   4  total paid is         $ 175,225.44
> At the end of year   5  total paid is         $ 219,031.80   <-- Note .80 and not .8
> At the end of year   6  total paid is         $ 262,838.16
> At the end of year   7  total paid is         $ 306,644.52
> At the end of year   8  total paid is         $ 350,450.88
> At the end of year   9  total paid is         $ 394,257.24
> At the end of year  10  total paid is         $ 438,063.60   <-- Note .60 and not .6
> At the end of year  11  total paid is         $ 481,869.96
> At the end of year  12  total paid is         $ 525,676.32
> At the end of year  13  total paid is         $ 569,482.68
> At the end of year  14  total paid is         $ 613,289.04
> At the end of year  15  total paid is         $ 657,095.40   <-- Note .40 and not .4  
> At the end of year  16  total paid is         $ 700,901.76
> At the end of year  17  total paid is         $ 744,708.12
> At the end of year  18  total paid is         $ 788,514.48
> At the end of year  19  total paid is         $ 832,320.84
> At the end of year  20  total paid is         $ 876,127.20   <-- Note .20 and not .2
不寐倦长更 2024-08-23 07:04:12

这与您可能已经看到的解决方案相同,但通过这种方式,它会更清晰:

>>> num = 3.141592654

>>>> print(f"数字:{num:.2f}")

This is the same solution as you have probably seen already, but by doing it this way it's more clearer:

>>> num = 3.141592654

>>> print(f"Number: {num:.2f}")

呆萌少年 2024-08-23 07:04:12

向您展示如何执行此操作的最简单方法示例是:

代码:

>>>点 = 19.5

<代码>>>总计 = 22

>>>'正确答案:{:.2%}'.format(points/total)
`

输出:正确答案:88.64%

The Easiest way example to show you how to do that is :

Code :

>>> points = 19.5

>>> total = 22

>>>'Correct answers: {:.2%}'.format(points/total)
`

Output : Correct answers: 88.64%

淡淡の花香 2024-08-23 07:04:12

如果您有 Decimal 对象,最简单的方法是将 quantize 用作:

from decimal import Decimal

average_score = Decimal('4.5000000000000000')
rounded_average_score = average_score.quantize(Decimal('0.00'))

# returns: Decimal('4.50')

if you have a Decimal object the easiest way is to use quantize as:

from decimal import Decimal

average_score = Decimal('4.5000000000000000')
rounded_average_score = average_score.quantize(Decimal('0.00'))

# returns: Decimal('4.50')
清醇 2024-08-23 07:04:12

怎么样

print round(20.2564567 , 2)    >>>>>>>        20.25


print round(20.2564567 , 4)    >>>>>>>        20.2564

what about

print round(20.2564567 , 2)    >>>>>>>        20.25


print round(20.2564567 , 4)    >>>>>>>        20.2564
~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文